Changeset 1770 for branches/stable/mindi-busybox/networking – MondoRescue

branches/stable/mindi-busybox/networking/Config.in

-              r821
+              r1770
 menu "Networking Utilities"
 config CONFIG_FEATURE_IPV6
+config FEATURE_IPV6
     bool "Enable IPv6 support"
     default n
 …
       This adds IPv6 support in the networking applets.
+config CONFIG_ARPING
+config VERBOSE_RESOLUTION_ERRORS
+    bool "Verbose resolution errors"
+    default n
+    help
+      Enable if you are not satisfied with simplistic
+      "can't resolve 'hostname.com'" and want to know more.
+      This may increase size of your executable a bit.
+config ARP
+    bool "arp"
+    default n
+    help
+      Manipulate the system ARP cache.
+config ARPING
     bool "arping"
     default n
     help
       Ping hosts by ARP packets
 config CONFIG_DNSD
+      Ping hosts by ARP packets.
+config DNSD
     bool "dnsd"
     default n
     help
       Small and static DNS server daemon.
 config CONFIG_ETHER_WAKE
+      Small and static DNS server daemon.
+config ETHER_WAKE
     bool "ether-wake"
     default n
 …
       Send a magic packet to wake up sleeping machines.
 config CONFIG_FAKEIDENTD
+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 CONFIG_FTPGET
+config FTPGET
     bool "ftpget"
     default n
 …
       Retrieve a remote file via FTP.
 config CONFIG_FTPPUT
+config FTPPUT
     bool "ftpput"
     default n
 …
       Store a remote file via FTP.
 config CONFIG_FEATURE_FTPGETPUT_LONG_OPTIONS
+config FEATURE_FTPGETPUT_LONG_OPTIONS
     bool "Enable long options in ftpget/ftpput"
     default n
     depends on CONFIG_GETOPT_LONG && (CONFIG_FTPGET || CONFIG_FTPPUT)
+    depends on GETOPT_LONG && (FTPGET || FTPPUT)
     help
       Support long options for the ftpget/ftpput applet.
 config CONFIG_HOSTNAME
+config HOSTNAME
     bool "hostname"
     default n
     help
       Show or set the system's host name
 config CONFIG_HTTPD
+      Show or set the system's host name.
+config HTTPD
     bool "httpd"
     default n
 …
       Serve web pages via an HTTP server.
 config CONFIG_FEATURE_HTTPD_WITHOUT_INETD
     bool "Support using httpd as a daemon (not from inetd)"
     default n
     depends on CONFIG_HTTPD
     help
       This option enables uid and port options for the httpd applet,
       and eliminates the need to be called from the inetd server daemon.
 config CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+config FEATURE_HTTPD_USE_SENDFILE
+    bool "Use sendfile system call"
+    default n
+    depends on HTTPD
+    help
+      When enabled, httpd will use the kernel sendfile() function
+      instead of read/write loop.
+config FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
     bool "Support reloading the global config file using hup signal"
     default n
     depends on CONFIG_HTTPD && CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+    depends on HTTPD
     help
       This option enables processing of SIGHUP to reload cached
       configuration settings.
 config CONFIG_FEATURE_HTTPD_SETUID
     bool "Enable support -u <user> option"
     default n
     depends on CONFIG_HTTPD && CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+config FEATURE_HTTPD_SETUID
+    bool "Enable -u <user> option"
+    default n
+    depends on HTTPD
     help
       This option allows the server to run as a specific user
 …
       different user.
 config CONFIG_FEATURE_HTTPD_BASIC_AUTH
+config FEATURE_HTTPD_BASIC_AUTH
     bool "Enable Basic http Authentication"
     default y
     depends on CONFIG_HTTPD
+    depends on HTTPD
     help
       Utilizes password settings from /etc/httpd.conf for basic
       authentication on a per url basis.
 config CONFIG_FEATURE_HTTPD_AUTH_MD5
+config FEATURE_HTTPD_AUTH_MD5
     bool "Support MD5 crypted passwords for http Authentication"
     default n
     depends on CONFIG_FEATURE_HTTPD_BASIC_AUTH
+    depends on FEATURE_HTTPD_BASIC_AUTH
     help
       Enables basic per URL authentication from /etc/httpd.conf
       using md5 passwords.
 config CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+config FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
     bool "Support loading additional MIME types at run-time"
     default n
     depends on CONFIG_HTTPD
+    depends on HTTPD
     help
       This option enables support for additional MIME types at
       run-time to be specified in the configuration file.
 config CONFIG_FEATURE_HTTPD_CGI
+config FEATURE_HTTPD_CGI
     bool "Support Common Gateway Interface (CGI)"
     default y
     depends on CONFIG_HTTPD
+    depends on HTTPD
     help
       This option allows scripts and executables to be invoked
       when specific URLs are requested.
 config CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+config FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
     bool "Enable support for running scripts through an interpreter"
     default n
     depends on CONFIG_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
+    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
       config file:
       *.php:/path/to/your/php
 config CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+config FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
     bool "Support the REMOTE_PORT environment variable for CGI"
     default n
     depends on CONFIG_FEATURE_HTTPD_CGI
+    depends on FEATURE_HTTPD_CGI
     help
       Use of this option can assist scripts in generating
       references that contain a unique port number.
 config CONFIG_FEATURE_HTTPD_ENCODE_URL_STR
+config FEATURE_HTTPD_ENCODE_URL_STR
     bool "Enable the -e option for shell script CGI simplification."
     default y
     depends on CONFIG_HTTPD
+    depends on HTTPD
     help
       This option allows html encoding arbitrary
 …
       "&#60Hello&#32World&#62".
+config CONFIG_IFCONFIG
+config FEATURE_HTTPD_ERROR_PAGES
+    bool "Enable support for custom error pages"
+    default n
+    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 IFCONFIG
     bool "ifconfig"
     default n
 …
       Ifconfig is used to configure the kernel-resident network interfaces.
 config CONFIG_FEATURE_IFCONFIG_STATUS
+config FEATURE_IFCONFIG_STATUS
     bool "Enable status reporting output (+7k)"
     default y
     depends on CONFIG_IFCONFIG
+    depends on IFCONFIG
     help
       If ifconfig is called with no arguments it will display the status
       of the currently active interfaces.
 config CONFIG_FEATURE_IFCONFIG_SLIP
+config FEATURE_IFCONFIG_SLIP
     bool "Enable slip-specific options \"keepalive\" and \"outfill\""
     default n
     depends on CONFIG_IFCONFIG
+    depends on IFCONFIG
     help
       Allow "keepalive" and "outfill" support for SLIP.  If you're not
       planning on using serial lines, leave this unchecked.
 config CONFIG_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+config FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
     bool "Enable options \"mem_start\", \"io_addr\", and \"irq\""
     default n
     depends on CONFIG_IFCONFIG
+    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 CONFIG_FEATURE_IFCONFIG_HW
+config FEATURE_IFCONFIG_HW
     bool "Enable option \"hw\" (ether only)"
     default y
     depends on CONFIG_IFCONFIG
+    depends on IFCONFIG
     help
       Set the hardware address of this interface, if the device driver
 …
       class.
 config CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+config FEATURE_IFCONFIG_BROADCAST_PLUS
     bool "Set the broadcast automatically"
     default n
     depends on CONFIG_IFCONFIG
+    depends on IFCONFIG
     help
       Setting this will make ifconfig attempt to find the broadcast
       automatically if the value '+' is used.
 config CONFIG_IFUPDOWN
+config IFUPDOWN
     bool "ifupdown"
     default n
-    select CONFIG_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 CONFIG_IFCONFIG and CONFIG_ROUTE, or enable
       CONFIG_FEATURE_IFUPDOWN_IP and the various CONFIG_IP options.  Of
+      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 CONFIG_FEATURE_IFUPDOWN_IP
+      "ifconfig", "route" and "run-parts" or the "ip" command, either
+      via busybox or via standalone utilities.
+config IFUPDOWN_IFSTATE_PATH
+    string "Absolute path to ifstate file"
+    default "/var/run/ifstate"
+    help
+      ifupdown keeps state information in a file called ifstate.
+      Typically it is located in /var/run/ifstate, however
+      some distributions tend to put it in other places
+      (debian, for example, uses /etc/network/run/ifstate).
+      This config option defines location of ifstate.
+config FEATURE_IFUPDOWN_IP
     bool "Use ip applet"
     default n
     depends on CONFIG_IFUPDOWN
+    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 CONFIG_FEATURE_IFUPDOWN_IP_BUILTIN
+config FEATURE_IFUPDOWN_IP_BUILTIN
     bool "Use busybox ip applet"
     default y
     depends on CONFIG_FEATURE_IFUPDOWN_IP
     select CONFIG_IP
     select CONFIG_FEATURE_IP_ADDRESS
     select CONFIG_FEATURE_IP_LINK
     select CONFIG_FEATURE_IP_ROUTE
+    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 leave this disabled, you must install the full-blown iproute2
+      If left disabled, you must install the full-blown iproute2
       utility or the  "ifup" and "ifdown" applets will not work.
 config CONFIG_FEATURE_IFUPDOWN_IP_BUILTIN
+config FEATURE_IFUPDOWN_IFCONFIG_BUILTIN
     bool "Use busybox ifconfig and route applets"
     default y
     depends on CONFIG_IFUPDOWN && !CONFIG_FEATURE_IFUPDOWN_IP
     select CONFIG_IFCONFIG
     select CONFIG_ROUTE
+    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 leave this disabled, you must install the full-blown ifconfig
+      If left disabled, you must install the full-blown ifconfig
       and route utilities, or the  "ifup" and "ifdown" applets will not
       work.
 config CONFIG_FEATURE_IFUPDOWN_IPV4
+config FEATURE_IFUPDOWN_IPV4
     bool "Enable support for IPv4"
     default y
     depends on CONFIG_IFUPDOWN
     help
       If you want busybox to talk IPv4, leave this on.
 config CONFIG_FEATURE_IFUPDOWN_IPV6
+    depends on IFUPDOWN
+    help
+      If you want ifup/ifdown to talk IPv4, leave this on.
+config FEATURE_IFUPDOWN_IPV6
     bool "Enable support for IPv6"
     default n
     depends on CONFIG_IFUPDOWN && CONFIG_FEATURE_IPV6
+    depends on IFUPDOWN && FEATURE_IPV6
     help
       If you need support for IPv6, turn this option on.
+config CONFIG_FEATURE_IFUPDOWN_IPX
+    bool "Enable support for IPX"
+    default n
+    depends on CONFIG_IFUPDOWN
+    help
+      If this option is selected you can use busybox to work with IPX
+      networks.
+config CONFIG_FEATURE_IFUPDOWN_MAPPING
+### UNUSED
+### 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 CONFIG_IFUPDOWN
+    depends on IFUPDOWN
     help
       This enables support for the "mapping" stanza, unless you have
       a weird network setup you don't need it.
+config CONFIG_INETD
+config FEATURE_IFUPDOWN_EXTERNAL_DHCP
+    bool "Enable support for external dhcp clients"
+    default n
+    depends on IFUPDOWN
+    help
+      This enables support for the external dhcp clients. Clients are
+      tried in the following order: dhcpcd, dhclient, pump and udhcpc.
+      Otherwise, if udhcpc applet is enabled, it is used.
+      Otherwise, ifup/ifdown will have no support for DHCP.
+config INETD
     bool "inetd"
     default n
+    select FEATURE_SYSLOG
     help
       Internet superserver daemon
 config CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+config FEATURE_INETD_SUPPORT_BUILTIN_ECHO
     bool "Support echo service"
     default y
     depends on CONFIG_INETD
+    depends on INETD
     help
       Echo received data internal inetd service
 config CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
+config FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
     bool "Support discard service"
     default y
     depends on CONFIG_INETD
+    depends on INETD
     help
       Internet /dev/null internal inetd service
 config CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+config FEATURE_INETD_SUPPORT_BUILTIN_TIME
     bool "Support time service"
     default y
     depends on CONFIG_INETD
+    depends on INETD
     help
       Return 32 bit time since 1900 internal inetd service
 config CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+config FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
     bool "Support daytime service"
     default y
     depends on CONFIG_INETD
+    depends on INETD
     help
       Return human-readable time internal inetd service
 config CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
+config FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
     bool "Support chargen service"
     default y
     depends on CONFIG_INETD
+    depends on INETD
     help
       Familiar character generator internal inetd service
 config CONFIG_FEATURE_INETD_RPC
+config FEATURE_INETD_RPC
     bool "Support RPC services"
     default n
     depends on CONFIG_INETD
     help
       Suuport Sun-RPC based services
 config CONFIG_IP
+    depends on INETD
+    select FEATURE_HAVE_RPC
+    help
+      Support Sun-RPC based services
+config IP
     bool "ip"
     default n
 …
       TCP/IP.
 config CONFIG_FEATURE_IP_ADDRESS
+config FEATURE_IP_ADDRESS
     bool "ip address"
     default y
     depends on CONFIG_IP
+    depends on IP
     help
       Address manipulation support for the "ip" applet.
 config CONFIG_FEATURE_IP_LINK
+config FEATURE_IP_LINK
     bool "ip link"
     default y
     depends on CONFIG_IP
+    depends on IP
     help
       Configure network devices with "ip".
 config CONFIG_FEATURE_IP_ROUTE
+config FEATURE_IP_ROUTE
     bool "ip route"
     default y
     depends on CONFIG_IP
+    depends on IP
     help
       Add support for routing table management to "ip".
 config CONFIG_FEATURE_IP_TUNNEL
+config FEATURE_IP_TUNNEL
     bool "ip tunnel"
     default n
     depends on CONFIG_IP
+    depends on IP
     help
       Add support for tunneling commands to "ip".
+config CONFIG_FEATURE_IP_SHORT_FORMS
+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 CONFIG_IP
+    depends on IP
     help
       Also support short-form of ip <OBJECT> commands:
 …
       ip route  -> iproute
       ip tunnel -> iptunnel
+      ip rule   -> iprule
       Say N unless you desparately need the short form of the ip
       object commands.
 config CONFIG_IPADDR
+config IPADDR
     bool
     default y
     depends on CONFIG_FEATURE_IP_SHORT_FORMS && CONFIG_FEATURE_IP_ADDRESS
 config CONFIG_IPLINK
+    depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ADDRESS
+config IPLINK
     bool
     default y
     depends on CONFIG_FEATURE_IP_SHORT_FORMS && CONFIG_FEATURE_IP_LINK
 config CONFIG_IPROUTE
+    depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_LINK
+config IPROUTE
     bool
     default y
     depends on CONFIG_FEATURE_IP_SHORT_FORMS && CONFIG_FEATURE_IP_ROUTE
 config CONFIG_IPTUNNEL
+    depends on FEATURE_IP_SHORT_FORMS && FEATURE_IP_ROUTE
+config IPTUNNEL
     bool
     default y
+    depends on CONFIG_FEATURE_IP_SHORT_FORMS && CONFIG_FEATURE_IP_TUNNEL
+config CONFIG_IPCALC
+    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
 …
       resulting broadcast, network, and host range.
 config CONFIG_FEATURE_IPCALC_FANCY
+config FEATURE_IPCALC_FANCY
     bool "Fancy IPCALC, more options, adds 1 kbyte"
     default y
     depends on CONFIG_IPCALC
+    depends on IPCALC
     help
       Adds the options hostname, prefix and silent to the output of "ipcalc".
 config CONFIG_FEATURE_IPCALC_LONG_OPTIONS
+config FEATURE_IPCALC_LONG_OPTIONS
     bool "Enable long options"
     default n
     depends on CONFIG_IPCALC && CONFIG_GETOPT_LONG
+    depends on IPCALC && GETOPT_LONG
     help
       Support long options for the ipcalc applet.
 config CONFIG_NAMEIF
+config NAMEIF
     bool "nameif"
     default n
+    select FEATURE_SYSLOG
     help
       nameif is used to rename network interface by its MAC address.
 …
       new_interface_name    XX:XX:XX:XX:XX:XX
 config CONFIG_NC
+config NC
     bool "nc"
     default n
 …
       connections.
+config CONFIG_NC_GAPING_SECURITY_HOLE
+    bool "gaping security hole"
+    default n
+    depends on CONFIG_NC
+    help
+      Add support for executing a program after making or receiving a
+      successful connection (-e option).
+config CONFIG_NETSTAT
+config NC_SERVER
+    bool "Netcat server options (-l)"
+    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
 …
       netstat prints information about the Linux networking subsystem.
+config CONFIG_NSLOOKUP
+config FEATURE_NETSTAT_WIDE
+    bool "  Enable wide netstat output"
+    default n
+    depends on NETSTAT
+    help
+      Add support for wide columns. Useful when displaying IPv6 addresses
+      (-W option).
+config NSLOOKUP
     bool "nslookup"
     default n
 …
       nslookup is a tool to query Internet name servers.
 config CONFIG_PING
+config PING
     bool "ping"
     default n
 …
       elicit an ICMP ECHO_RESPONSE from a host or gateway.
+config CONFIG_FEATURE_FANCY_PING
+config PING6
+    bool "ping6"
+    default n
+    depends on FEATURE_IPV6 && PING
+    help
+      This will give you a ping that can talk IPv6.
+config PSCAN
+    bool "pscan"
+    default n
+    help
+      Simple network port scanner.
+config FEATURE_FANCY_PING
     bool "Enable fancy ping output"
     default y
     depends on CONFIG_PING
+    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 CONFIG_PING6
+    bool "ping6"
+    default n
+    depends on CONFIG_FEATURE_IPV6
+    help
+      This will give you a ping that can talk IPv6.
+config CONFIG_FEATURE_FANCY_PING6
+    bool "Enable fancy ping6 output"
+    default y
+    depends on CONFIG_PING6
+    help
+      Make the output from the ping6 applet include statistics, and at the
+      same time provide full support for ICMP packets.
+config CONFIG_ROUTE
+config ROUTE
     bool "route"
     default n
 …
       Route displays or manipulates the kernel's IP routing tables.
+config CONFIG_TELNET
+config SLATTACH
+    bool "slattach"
+    default n
+    help
+      slattach is a small utility to attach network interfaces to serial lines.
+config TELNET
     bool "telnet"
     default n
 …
       used to test other simple protocols.
 config CONFIG_FEATURE_TELNET_TTYPE
+config FEATURE_TELNET_TTYPE
     bool "Pass TERM type to remote host"
     default y
     depends on CONFIG_TELNET
+    depends on TELNET
     help
       Setting this option will forward the TERM environment variable to the
 …
       things like ANSI colors and other control sequences behave.
 config CONFIG_FEATURE_TELNET_AUTOLOGIN
+config FEATURE_TELNET_AUTOLOGIN
     bool "Pass USER type to remote host"
     default y
     depends on CONFIG_TELNET
+    depends on TELNET
     help
       Setting this option will forward the USER environment variable to the
 …
       option enables `-a' and `-l USER' arguments.
 config CONFIG_TELNETD
+config TELNETD
     bool "telnetd"
     default n
+    select FEATURE_SYSLOG
     help
       A daemon for the TELNET protocol, allowing you to log onto the host
 …
       Note that for busybox telnetd to work you need several things:
       First of all, your kernel needs:
           CONFIG_UNIX98_PTYS=y
           CONFIG_DEVPTS_FS=y
+          UNIX98_PTYS=y
+          DEVPTS_FS=y
       Next, you need a /dev/pts directory on your root filesystem:
 …
           mount -t devpts devpts /dev/pts
       You need to be sure that Busybox has CONFIG_LOGIN and
       CONFIG_FEATURE_SUID enabled.  And finally, you should make
+      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:
 …
+config CONFIG_FEATURE_TELNETD_INETD
+    bool "Support call from inetd only"
+    default n
+    depends on CONFIG_TELNETD
+    help
+      Selecting this will make telnetd only callable from inetd,
+      removing the standalone support.
+config CONFIG_TFTP
+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
 …
       for a network-enabled bootloader.
 config CONFIG_FEATURE_TFTP_GET
+config FEATURE_TFTP_GET
     bool "Enable \"get\" command"
     default y
     depends on CONFIG_TFTP
+    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 CONFIG_FEATURE_TFTP_PUT
+config FEATURE_TFTP_PUT
     bool "Enable \"put\" command"
     default y
     depends on CONFIG_TFTP
+    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 CONFIG_FEATURE_TFTP_BLOCKSIZE
+config FEATURE_TFTP_BLOCKSIZE
     bool "Enable \"blocksize\" command"
     default n
     depends on CONFIG_TFTP
+    depends on TFTP
     help
       Allow the client to specify the desired block size for transfers.
 config CONFIG_DEBUG_TFTP
+config DEBUG_TFTP
     bool "Enable debug"
     default n
     depends on CONFIG_TFTP
+    depends on TFTP
     help
       Enable debug settings for tftp.  This is useful if you're running
 …
       you run into problems.
 config CONFIG_TRACEROUTE
+config TRACEROUTE
     bool "traceroute"
     default n
 …
       Utility to trace the route of IP packets
 config CONFIG_FEATURE_TRACEROUTE_VERBOSE
+config FEATURE_TRACEROUTE_VERBOSE
     bool "Enable verbose output"
     default n
     depends on CONFIG_TRACEROUTE
+    depends on TRACEROUTE
     help
       Add some verbosity to traceroute.  This includes amongst other things
       hostnames and ICMP response types.
 config CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+config FEATURE_TRACEROUTE_SOURCE_ROUTE
     bool "Enable loose source route"
     default n
     depends on CONFIG_TRACEROUTE
+    depends on TRACEROUTE
     help
       Add option to specify a loose source route gateway
       (8 maximum).
 config CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+config FEATURE_TRACEROUTE_USE_ICMP
     bool "Use ICMP instead of UDP"
     default n
     depends on CONFIG_TRACEROUTE
+    depends on TRACEROUTE
     help
       Add feature to allow for ICMP ECHO instead of UDP datagrams.
 …
 source networking/udhcp/Config.in
 config CONFIG_VCONFIG
+config VCONFIG
     bool "vconfig"
     default n
 …
       Creates, removes, and configures VLAN interfaces
 config CONFIG_WGET
+config WGET
     bool "wget"
     default n
 …
       HTTPS, and FTP servers.
 config CONFIG_FEATURE_WGET_STATUSBAR
+config FEATURE_WGET_STATUSBAR
     bool "Enable a nifty process meter (+2k)"
     default y
     depends on CONFIG_WGET
+    depends on WGET
     help
       Enable the transfer progress bar for wget transfers.
 config CONFIG_FEATURE_WGET_AUTHENTICATION
+config FEATURE_WGET_AUTHENTICATION
     bool "Enable HTTP authentication"
     default y
     depends on CONFIG_WGET
+    depends on WGET
     help
       Support authenticated HTTP transfers.
+config CONFIG_FEATURE_WGET_IP6_LITERAL
+    bool "Enable IPv6 literal addresses"
+    default y
+    depends on CONFIG_WGET && CONFIG_FEATURE_IPV6
+    help
+      Support IPv6 address literal notation in URLs.
+config CONFIG_FEATURE_WGET_LONG_OPTIONS
+config FEATURE_WGET_LONG_OPTIONS
     bool "Enable long options"
     default n
     depends on CONFIG_WGET && CONFIG_GETOPT_LONG
+    depends on WGET && GETOPT_LONG
     help
       Support long options for the wget applet.
 config CONFIG_ZCIP
+config ZCIP
     bool "zcip"
     default n
+    select FEATURE_SYSLOG
     help
       ZCIP provides ZeroConf IPv4 address selection, according to RFC 3927.

branches/stable/mindi-busybox/networking/arping.c

-              r821
+              r1770
  */
-#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 <netpacket/packet.h>
+#include "busybox.h"
+#include "libbb.h"
+/* We don't expect to see 1000+ seconds delay, unsigned is enough */
+#define MONOTONIC_US() ((unsigned)monotonic_us())
 static struct in_addr src;
 …
 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 unsigned last;
+enum {
+    DAD = 1,
+    UNSOLICITED = 2,
+    ADVERT = 4,
+    QUIET = 8,
+    QUIT_ON_REPLY = 16,
+    BCAST_ONLY = 32,
+    UNICASTING = 64
 };
+static int cfg;
+static int s;
+static int count = -1;
+static int 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 )
+#if 0
+static void set_signal(int signo, void (*handler) (void))
+{
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = (void (*)(int)) handler;
+    sa.sa_flags = SA_RESTART;
+    sigaction(signo, &sa, NULL);
+}
+#endif
+static int send_pack(int sock, struct in_addr *src_addr,
+                     struct in_addr *dst_addr, struct sockaddr_ll *ME,
+                     struct sockaddr_ll *HE)
+static int sock;
+static unsigned count = UINT_MAX;
+static unsigned timeout_us;
+static unsigned sent;
+static unsigned brd_sent;
+static unsigned received;
+static unsigned brd_recv;
+static unsigned req_recv;
+static int send_pack(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);
+    unsigned now;
+    unsigned char buf[256];
     struct arphdr *ah = (struct arphdr *) buf;
     unsigned char *p = (unsigned char *) (ah + 1);
 …
     ah->ar_hln = ME->sll_halen;
     ah->ar_pln = 4;
     ah->ar_op = cfg&advert ? htons(ARPOP_REPLY) : htons(ARPOP_REQUEST);
+    ah->ar_op = option_mask32 & ADVERT ? htons(ARPOP_REPLY) : htons(ARPOP_REQUEST);
     memcpy(p, &ME->sll_addr, ah->ar_hln);
 …
     p += 4;
     if (cfg&advert)
+    if (option_mask32 & ADVERT)
         memcpy(p, &ME->sll_addr, ah->ar_hln);
     else
 …
     p += 4;
     gettimeofday(&now, NULL);
+    now = MONOTONIC_US();
     err = sendto(sock, buf, p - buf, 0, (struct sockaddr *) HE, sizeof(*HE));
     if (err == p - buf) {
         last = now;
         sent++;
         if (!(cfg&unicasting))
+        if (!(option_mask32 & UNICASTING))
             brd_sent++;
+    }
-    RELEASE_CONFIG_BUFFER(buf);
     return err;
+}
+static void finish(void) ATTRIBUTE_NORETURN;
 static void finish(void)
+{
+    if (!(cfg&quiet)) {
+        printf("Sent %d probes (%d broadcast(s))\n"
+            "Received %d repl%s",
+    if (!(option_mask32 & QUIET)) {
+        printf("Sent %u probe(s) (%u broadcast(s))\n"
+            "Received %u repl%s"
+            " (%u request(s), %u broadcast(s))\n",
             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)
+            received, (received == 1) ? "ies" : "y",
+            req_recv, brd_recv);
+    }
+    if (option_mask32 & DAD)
         exit(!!received);
     if (cfg&unsolicited)
+    if (option_mask32 & 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))
+    static unsigned start;
+    unsigned now;
+    now = MONOTONIC_US();
+    if (start == 0)
+        start = now;
+    if (count == 0 || (timeout_us && (now - start) > (timeout_us + 500000)))
         finish();
+    if (last.tv_sec == 0 || MS_TDIFF(tv, last) > 500) {
+        send_pack(s, &src, &dst, &me, &he);
+        if (count == 0 && cfg&unsolicited)
+    count--;
+    if (last == 0 || (now - last) > 500000) {
+        send_pack(&src, &dst, &me, &he);
+        if (count == 0 && (option_mask32 & UNSOLICITED))
             finish();
+    }
 …
     /* Filter out wild packets */
     if (FROM->sll_pkttype != PACKET_HOST &&
         FROM->sll_pkttype != PACKET_BROADCAST &&
         FROM->sll_pkttype != PACKET_MULTICAST)
+    if (FROM->sll_pkttype != PACKET_HOST
+     && FROM->sll_pkttype != PACKET_BROADCAST
+     && FROM->sll_pkttype != PACKET_MULTICAST)
         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)))
+    if (ah->ar_hrd != htons(FROM->sll_hatype)
+     && (FROM->sll_hatype != ARPHRD_FDDI || ah->ar_hrd != htons(ARPHRD_ETHER)))
         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 (!(option_mask32 & DAD)) {
         if (src_ip.s_addr != dst.s_addr)
             return 0;
 …
             return 0;
+    }
     if (!(cfg&quiet)) {
+    if (!(option_mask32 & 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",
+        printf("%scast re%s from %s [%s]",
+            FROM->sll_pkttype == PACKET_HOST ? "Uni" : "Broad",
+            ah->ar_op == htons(ARPOP_REPLY) ? "ply" : "quest",
             inet_ntoa(src_ip),
             ether_ntoa((struct ether_addr *) p));
 …
                 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);
+                ether_ntoa((struct ether_addr *) p + ah->ar_hln + 4));
+        }
+        if (last) {
+            printf(" %u.%03ums\n", last / 1000, last % 1000);
         } else {
             printf(" UNSOLICITED?\n");
 …
     if (ah->ar_op == htons(ARPOP_REQUEST))
         req_recv++;
     if (cfg&quit_on_reply)
+    if (option_mask32 & QUIT_ON_REPLY)
         finish();
     if (!(cfg&broadcast_only)) {
+    if (!(option_mask32 & BCAST_ONLY)) {
         memcpy(he.sll_addr, p, me.sll_halen);
         cfg |= unicasting;
+        option_mask32 |= UNICASTING;
+    }
     return 1;
+}
+int arping_main(int argc, char **argv);
 int arping_main(int argc, char **argv)
+{
     char *device = "eth0";
+    const char *device = "eth0";
     int ifindex;
     char *source = NULL;
     char *target;
+    s = socket(PF_PACKET, SOCK_DGRAM, 0);
     ifindex = errno;
+    unsigned char *packet;
+    sock = xsocket(PF_PACKET, SOCK_DGRAM, 0);
     // Drop suid root privileges
 …
+    {
         unsigned long opt;
         char *_count, *_timeout, *_device;
+        unsigned opt;
+        char *str_count, *str_timeout;
         /* Dad also sets quit_on_reply.
          * Advert also sets unsolicited.
          */
+        bb_opt_complementally = "Df:AU";
+        opt = bb_getopt_ulflags(argc, argv, "DUAqfbc:w:i:s:",
+                        &_count, &_timeout, &_device);
+        cfg |= opt & 63; /* set respective flags */
+        if (opt & 64) /* count */
+            count = atoi(_count);
+        if (opt & 128) /* timeout */
+            timeout = atoi(_timeout);
+        if (opt & 256) { /* interface */
+            if (strlen(_device) > IF_NAMESIZE) {
+                bb_error_msg_and_die("Interface name `%s' must be less than %d",
+                                _device, IF_NAMESIZE);
+            }
+            device = _device;
+        }
+        if (opt & 512) /* source */
+            source = optarg;
+    }
+    argc -= optind;
+    argv += optind;
+    if (argc != 1)
+        bb_show_usage();
+    target = *argv;
+    if (s < 0) {
+        bb_default_error_retval = ifindex;
+        bb_perror_msg_and_die("socket");
+    }
+    bb_default_error_retval = 2;
+        opt_complementary = "=1:Df:AU";
+        opt = getopt32(argv, "DUAqfbc:w:I:s:",
+                &str_count, &str_timeout, &device, &source);
+        if (opt & 0x40) /* -c: count */
+            count = xatou(str_count);
+        if (opt & 0x80) /* -w: timeout */
+            timeout_us = xatou_range(str_timeout, 0, INT_MAX/2000000) * 1000000;
+        //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 */
+        option_mask32 &= 0x3f; /* set respective flags */
+    }
+    target = argv[optind];
+    xfunc_error_retval = 2;
+    {
 …
         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);
+        }
+        ioctl_or_perror_and_die(sock, SIOCGIFINDEX, &ifr, "interface %s not found", device);
         ifindex = ifr.ifr_ifindex;
+        if (ioctl(s, SIOCGIFFLAGS, (char *) &ifr)) {
+            bb_error_msg_and_die("SIOCGIFFLAGS");
+        }
+        xioctl(sock, SIOCGIFFLAGS, (char *) &ifr);
         if (!(ifr.ifr_flags & IFF_UP)) {
             bb_error_msg_and_die("Interface %s is down", device);
+            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);
+            bb_error_msg("interface %s is not ARPable", device);
+            return (option_mask32 & 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);
+        len_and_sockaddr *lsa;
+        lsa = xhost_and_af2sockaddr(target, 0, AF_INET);
+        memcpy(&dst, &lsa->sin.sin_addr.s_addr, 4);
+        if (ENABLE_FEATURE_CLEAN_UP)
+            free(lsa);
+    }
 …
+    }
     if (!(cfg&dad) && cfg&unsolicited && src.s_addr == 0)
+    if (!(option_mask32 & DAD) && (option_mask32 & UNSOLICITED) && src.s_addr == 0)
         src = dst;
     if (!(cfg&dad) || src.s_addr) {
+    if (!(option_mask32 & DAD) || src.s_addr) {
         struct sockaddr_in saddr;
+        int probe_fd = socket(AF_INET, SOCK_DGRAM, 0); /* maybe use bb_xsocket? */
+        if (probe_fd < 0) {
+            bb_error_msg_and_die("socket");
+        }
+        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);
+            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));
 …
         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)) {
+            int on = 1;
+            xbind(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr));
+        } else if (!(option_mask32 & DAD)) {
             socklen_t alen = sizeof(saddr);
 …
             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) {
+            if (setsockopt(probe_fd, SOL_SOCKET, SO_DONTROUTE, &const_int_1, sizeof(const_int_1)) == -1)
+                bb_perror_msg("warning: setsockopt(SO_DONTROUTE)");
+            xconnect(probe_fd, (struct sockaddr *) &saddr, sizeof(saddr));
+            if (getsockname(probe_fd, (struct sockaddr *) &saddr, &alen) == -1) {
                 bb_error_msg_and_die("getsockname");
+            }
 …
+        }
         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");
+    }
+    xbind(sock, (struct sockaddr *) &me, sizeof(me));
+    {
         socklen_t alen = sizeof(me);
         if (getsockname(s, (struct sockaddr *) &me, &alen) == -1) {
+        if (getsockname(sock, (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);
+        bb_error_msg("interface \"%s\" is not ARPable (no ll address)", device);
+        return (option_mask32 & DAD ? 0 : 2);
+    }
     he = me;
     memset(he.sll_addr, -1, he.sll_halen);
     if (!(cfg&quiet)) {
+    if (!(option_mask32 & QUIET)) {
         printf("ARPING to %s from %s via %s\n",
             inet_ntoa(dst), inet_ntoa(src),
 …
+    }
     if (!src.s_addr && !(cfg&dad)) {
+    if (!src.s_addr && !(option_mask32 & DAD)) {
         bb_error_msg_and_die("no src address in the non-DAD mode");
+    }
 …
     catcher();
+    packet = xmalloc(4096);
     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) {
             perror("recvfrom");
+        cc = recvfrom(sock, packet, 4096, 0, (struct sockaddr *) &from, &alen);
+        if (cc < 0) {
+            bb_perror_msg("recvfrom");
             continue;
+        }
 …
         recv_pack(packet, cc, &from);
         sigprocmask(SIG_SETMASK, &osset, NULL);
+        RELEASE_CONFIG_BUFFER(packet);
+    }
+}
+    }
+}

branches/stable/mindi-busybox/networking/dnsd.c

-              r902
+              r1770
  */
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <ctype.h>
+#include "busybox.h"
+static char *fileconf = "/etc/dnsd.conf";
+#define LOCK_FILE       "/var/run/dnsd.lock"
+#define LOG_FILE        "/var/log/dnsd.log"
+#define is_daemon()  (flags&16)
+#define is_verbose() (flags&32)
+//#define DEBUG
+#include <syslog.h>
+#include "libbb.h"
+//#define DEBUG 1
+#define DEBUG 0
 enum {
 …
 };
+static struct dns_entry *dnsentry = NULL;
+static int daemonmode = 0;
+static struct dns_entry *dnsentry;
 static uint32_t ttl = DEFAULT_TTL;
+static const char *fileconf = "/etc/dnsd.conf";
+// Must match getopt32 call
+#define OPT_daemon  (option_mask32 & 0x10)
+#define OPT_verbose (option_mask32 & 0x20)
 /*
  * Convert host name from C-string to dns length/string.
 …
+{
     int i = (q[0] == '.') ? 0 : 1;
     for(; i < MAX_HOST_LEN-1 && *q; i++, q++)
+    for (; i < MAX_HOST_LEN-1 && *q; i++, q++)
         a[i] = tolower(*q);
     a[0] = i - 1;
 …
+{
     int i = 0, s = 0;
+    while(rip[i]) i++;
+    for(--i; i >= 0; i--) {
+        if(rip[i] == '.') {
+    while (rip[i])
+        i++;
+    for (--i; i >= 0; i--) {
+        if (rip[i] == '.') {
             rip[i] = s;
             s = 0;
 …
 /*
- * 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.
+ * Hostnames with more than one label are 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, int verb)
+static int getfileentry(FILE * fp, struct dns_entry *s)
+{
     unsigned int a,b,c,d;
+    char *r, *name;
+restart:
+    if(!(r = bb_get_line_from_file(fp)))
+    char *line, *r, *name;
+ restart:
+    line = r = xmalloc_fgets(fp);
+    if (!r)
         return -1;
     while(*r == ' ' || *r == '\t') {
+    while (*r == ' ' || *r == '\t') {
         r++;
+        if(!*r || *r == '#' || *r == '\n')
+        if (!*r || *r == '#' || *r == '\n') {
+            free(line);
             goto restart; /* skipping empty/blank and commented lines  */
+        }
+    }
     name = r;
     while(*r != ' ' && *r != '\t')
+    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);
+    *r++ = '\0';
+    if (sscanf(r, ".%u.%u.%u.%u"+1, &a, &b, &c, &d) != 4) {
+        free(line);
+        goto restart; /* skipping wrong lines */
+    }
+    sprintf(s->ip, ".%u.%u.%u.%u"+1, 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(verb)
+        fprintf(stderr,"\tname:%s, ip:%s\n",&(s->name[1]),s->ip);
+    return 0; /* warningkiller */
+    convname(s->name, (uint8_t*)name);
+    if (OPT_verbose)
+        fprintf(stderr, "\tname:%s, ip:%s\n", &(s->name[1]),s->ip);
+    free(line);
+    return 0;
+}
 …
  * Read hostname/IP records from file
  */
 static void dnsentryinit(int verb)
+static void dnsentryinit(void)
+{
     FILE *fp;
     struct dns_entry *m, *prev;
     prev = dnsentry = NULL;
+    fp = bb_xfopen(fileconf, "r");
+    fp = xfopen(fileconf, "r");
     while (1) {
+        m = xmalloc(sizeof(struct dns_entry));
+        m->next = NULL;
+        if (getfileentry(fp, m, verb))
+        m = xzalloc(sizeof(*m));
+        /*m->next = NULL;*/
+        if (getfileentry(fp, m))
             break;
 …
+}
-/*
- * Set up UDP socket
- */
-static int listen_socket(char *iface_addr, int listen_port)
+{
-    struct sockaddr_in a;
-    char msg[100];
-    int s;
-    int yes = 1;
-    s = bb_xsocket(PF_INET, SOCK_DGRAM, 0);
-#ifdef SO_REUSEADDR
-    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&yes, sizeof(yes)) < 0)
-        bb_perror_msg_and_die("setsockopt() failed");
-#endif
-    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");
-    bb_xbind(s, (struct sockaddr *)&a, sizeof(a));
-    listen(s, 50); /* bb_xlisten? */
-    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
 …
     struct dns_entry *d = dnsentry;
+    if(d) do {
+#ifdef DEBUG
+        if(qs && d) {
+            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));
+        }
+    do {
+#if DEBUG
+        char *p,*q;
+        q = (char *)&(qs[1]);
+        p = &(d->name[1]);
+        fprintf(stderr, "\n%s: %d/%d p:%s q:%s %d",
+            __FUNCTION__, (int)strlen(p), (int)(d->name[0]),
+            p, q, (int)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])
+        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
+            if (i > (int)(d->name[0])) {
                 strcpy((char *)as, d->ip);
 #ifdef DEBUG
                 fprintf(stderr, " as:%s\n", as);
+#if DEBUG
+                fprintf(stderr, " OK as:%s\n", as);
 #endif
                 return 0;
+            }
+        } else
+        if (type == REQ_PTR) {          /* search by IP-address */
+        } 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);
 …
+            }
+        }
+    } while ((d = d->next) != NULL);
+        d = d->next;
+    } while (d);
     return -1;
+}
 …
  * Decode message and generate answer
  */
-#define eret(s) do { fprintf (stderr, "%s\n", s); return -1; } while (0)
 static int process_packet(uint8_t * buf)
+{
 …
     head = (struct dns_head *)buf;
+    if (head->nquer == 0)
+        eret("no queries");
+    if ((head->flags & 0x8000))
+        eret("ignoring response packet");
+    if (head->nquer == 0) {
+        bb_error_msg("no queries");
+        return -1;
+    }
+    if (head->flags & 0x8000) {
+        bb_error_msg("ignoring response packet");
+        return -1;
+    }
     from = (void *)&head[1];    //  start of query string
 …
     // We have a standard query
     log_message(LOG_FILE, (char *)from);
+    bb_info_msg("%s", (char *)from);
     lookup_result = table_lookup(type, answstr, (uint8_t*)from);
     if (lookup_result != 0) {
 …
         memcpy(answstr, &a.s_addr, 4);  // save before a disappears
         outr.rlen = 4;          // uint32_t IP
+    }
+    else
+    } else
         outr.rlen = strlen((char *)answstr) + 1;    // a host name
     outr.r = answstr;           // 32 bit ip or a host name
 …
     next += outr.rlen;
+empty_packet:
+ empty_packet:
     flags = ntohs(head->flags);
     // clear rcode and RA, set responsebit and our new flags
 …
     head->nquer = htons(1);
     packet_len = next - (void *)buf;
+    packet_len = (uint8_t *)next - buf;
     return packet_len;
+}
 …
 static void interrupt(int x)
+{
     unlink(LOCK_FILE);
     write(2, "interrupt exiting\n", 18);
+    /* unlink("/var/run/dnsd.lock"); */
+    bb_error_msg("interrupt, exiting\n");
     exit(2);
+}
+int dnsd_main(int argc, char **argv);
 int dnsd_main(int argc, char **argv)
+{
+    const char *listen_interface = "0.0.0.0";
+    char *sttl, *sport;
+    len_and_sockaddr *lsa;
     int udps;
     uint16_t port = 53;
     uint8_t buf[MAX_PACK_LEN];
+    unsigned long flags = 0;
+    char *listen_interface = "0.0.0.0";
+    char *sttl=NULL, *sport=NULL;
+    if(argc > 1)
+        flags = bb_getopt_ulflags(argc, argv, "i:c:t:p:dv", &listen_interface, &fileconf, &sttl, &sport);
+    if(sttl)
+        if(!(ttl = atol(sttl)))
+            bb_show_usage();
+    if(sport)
+        if(!(port = atol(sport)))
+            bb_show_usage();
+    if(is_verbose()) {
+        fprintf(stderr,"listen_interface: %s\n", listen_interface);
+        fprintf(stderr,"ttl: %d, port: %d\n", ttl, port);
+        fprintf(stderr,"fileconf: %s\n", fileconf);
+    }
+    if(is_daemon())
+#ifdef BB_NOMMU
+        /* reexec for vfork() do continue parent */
+        vfork_daemon_rexec(1, 0, argc, argv, "-d");
+#else
+        bb_xdaemon(1, 0);
+#endif
+    dnsentryinit(is_verbose());
+    getopt32(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
+        ttl = xatou_range(sttl, 1, 0xffffffff);
+    if (option_mask32 & 0x8) // -p
+        port = xatou_range(sport, 1, 0xffff);
+    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) {
+        bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv);
+        openlog(applet_name, LOG_PID, LOG_DAEMON);
+        logmode = LOGMODE_SYSLOG;
+    }
+    dnsentryinit();
     signal(SIGINT, interrupt);
     signal(SIGPIPE, SIG_IGN);
+    /* why? signal(SIGPIPE, SIG_IGN); */
     signal(SIGHUP, SIG_IGN);
 #ifdef SIGTSTP
 …
 #endif
+    udps = listen_socket(listen_interface, port);
+    if (udps < 0)
+        exit(1);
+    lsa = xdotted2sockaddr(listen_interface, port);
+    udps = xsocket(lsa->sa.sa_family, SOCK_DGRAM, 0);
+    xbind(udps, &lsa->sa, lsa->len);
+    /* xlisten(udps, 50); - ?!! DGRAM sockets are never listened on I think? */
+    bb_info_msg("Accepting UDP packets on %s",
+            xmalloc_sockaddr2dotted(&lsa->sa));
     while (1) {
-        fd_set fdset;
         int r;
+        FD_ZERO(&fdset);
+        FD_SET(udps, &fdset);
+        // Block until a message arrives
+        if((r = select(udps + 1, &fdset, NULL, NULL, NULL)) < 0)
+            bb_perror_msg_and_die("select error");
+        else
+        if(r == 0)
+            bb_perror_msg_and_die("select spurious return");
+        /* Can this test ever be false? */
+        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(is_verbose())
+                fprintf(stderr, "\n--- Got UDP size=%d ", r);
+            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
+        socklen_t fromlen = lsa->len;
+// FIXME: need to get *DEST* address (to which of our addresses
+// this query was directed), and reply from the same address.
+// Or else we can exhibit usual UDP ugliness:
+// [ip1.multihomed.ip2] <=  query to ip1  <= peer
+// [ip1.multihomed.ip2] => reply from ip2 => peer (confused)
+        r = recvfrom(udps, buf, sizeof(buf), 0, &lsa->sa, &fromlen);
+        if (OPT_verbose)
+            bb_info_msg("Got UDP packet");
+        if (r < 12 || r > 512) {
+            bb_error_msg("invalid packet size");
+            continue;
+        }
+        r = process_packet(buf);
+        if (r <= 0)
+            continue;
+        sendto(udps, buf, r, 0, &lsa->sa, fromlen);
+    }
     return 0;
+}

branches/stable/mindi-busybox/networking/ether-wake.c

-              r821
+              r1770
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include <ctype.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <features.h>
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
-#include <netdb.h>
 #include <netinet/ether.h>
-#ifdef __linux__
 #include <linux/if.h>
+#endif
+#include "busybox.h"
+#include "libbb.h"
 /* Note: PF_INET, SOCK_DGRAM, IPPROTO_UDP would allow SIOCGIFHWADDR to
 …
 #ifdef PF_PACKET
 # define whereto_t sockaddr_ll
 # define make_socket() bb_xsocket(PF_PACKET, SOCK_RAW, 0)
+# define make_socket() xsocket(PF_PACKET, SOCK_RAW, 0)
 #else
 # define whereto_t sockaddr
 # define make_socket() bb_xsocket(AF_INET, SOCK_PACKET, SOCK_PACKET)
+# define make_socket() xsocket(AF_INET, SOCK_PACKET, SOCK_PACKET)
 #endif
 …
     for (i = 0; i < pktsize; ++i) {
         printf("%2.2x ", outpack[i]);
         if (i % 20 == 19) printf("\n");
+        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 etherwake_main(int argc, char *argv[])
+{
+    char *ifname = "eth0", *pass = NULL;
+    unsigned long flags;
+# define bb_debug_msg(fmt, args...)             ((void)0)
+# define bb_debug_dump_packet(outpack, pktsize) ((void)0)
+#endif
+/* Convert the host ID string to a MAC address.
+ * The string may be a:
+ *    Host name
+ *    IP address string
+ *    MAC address string
+*/
+static 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));
+#endif
+    } else
+        bb_show_usage();
+}
+static int get_fill(unsigned char *pkt, struct ether_addr *eaddr, int broadcast)
+{
+    int i;
+    unsigned char *station_addr = eaddr->ether_addr_octet;
+    memset(pkt, 0xff, 6);
+    if (!broadcast)
+        memcpy(pkt, station_addr, 6);
+    pkt += 6;
+    memcpy(pkt, station_addr, 6); /* 6 */
+    pkt += 6;
+    *pkt++ = 0x08; /* 12 */ /* Or 0x0806 for ARP, 0x8035 for RARP */
+    *pkt++ = 0x42; /* 13 */
+    memset(pkt, 0xff, 6); /* 14 */
+    for (i = 0; i < 16; ++i) {
+        pkt += 6;
+        memcpy(pkt, station_addr, 6); /* 20,26,32,... */
+    }
+    return 20 + 16*6; /* length of packet */
+}
+static int get_wol_pw(const char *ethoptarg, unsigned char *wol_passwd)
+{
+    unsigned 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 */
+// FIXME: why < 4?? should it be < 6?
+    if (byte_cnt < 4)
+        byte_cnt = sscanf(ethoptarg, "%u.%u.%u.%u",
+                          &passwd[0], &passwd[1], &passwd[2], &passwd[3]);
+    if (byte_cnt < 4) {
+        bb_error_msg("cannot read Wake-On-LAN pass");
+        return 0;
+    }
+// TODO: check invalid numbers >255??
+    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;
+}
+int ether_wake_main(int argc, char **argv);
+int ether_wake_main(int argc, char **argv)
+{
+    const char *ifname = "eth0";
+    char *pass;
+    unsigned flags;
     unsigned char wol_passwd[6];
     int wol_passwd_sz = 0;
     int s;                      /* Raw socket */
     int pktsize;
 …
     /* handle misc user options */
+    flags = bb_getopt_ulflags(argc, argv, "bi:p:", &ifname, &pass);
+    if (optind == argc)
+        bb_show_usage();
+    if (pass)
+    opt_complementary = "=1";
+    flags = getopt32(argv, "bi:p:", &ifname, &pass);
+    if (flags & 4) /* -p */
         wol_passwd_sz = get_wol_pw(pass, wol_passwd);
+    flags &= 1; /* we further interested only in -b [bcast] flag */
     /* create the raw socket */
 …
     /* now that we have a raw socket we can drop root */
     xsetuid(getuid());
+    /* xsetuid(getuid()); - but save on code size... */
     /* look up the dest mac address */
 …
     /* fill out the header of the packet */
     pktsize = get_fill(outpack, &eaddr, flags /*& 1 [OPT_BROADCAST]*/);
+    pktsize = get_fill(outpack, &eaddr, flags /* & 1 OPT_BROADCAST */);
     bb_debug_dump_packet(outpack, pktsize);
 …
         struct ifreq if_hwaddr;
+        strcpy(if_hwaddr.ifr_name, ifname);
+        if (ioctl(s, SIOCGIFHWADDR, &if_hwaddr) < 0)
+            bb_perror_msg_and_die("SIOCGIFHWADDR on %s failed", ifname);
+        strncpy(if_hwaddr.ifr_name, ifname, sizeof(if_hwaddr.ifr_name));
+        ioctl_or_perror_and_die(s, SIOCGIFHWADDR, &if_hwaddr, "SIOCGIFHWADDR on %s failed", ifname);
         memcpy(outpack+6, if_hwaddr.ifr_hwaddr.sa_data, 6);
 …
     /* This is necessary for broadcasts to work */
+    if (flags /*& 1 [OPT_BROADCAST]*/) {
+        int one = 1;
+        if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, (void *)&one, sizeof(one)) < 0)
+    if (flags /* & 1 OPT_BROADCAST */) {
+        if (setsockopt_broadcast(s) != 0)
             bb_perror_msg("SO_BROADCAST");
+    }
 …
         struct ifreq ifr;
         strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+        if (ioctl(s, SIOCGIFINDEX, &ifr) == -1)
+            bb_perror_msg_and_die("SIOCGIFINDEX");
+        xioctl(s, SIOCGIFINDEX, &ifr);
         memset(&whereto, 0, sizeof(whereto));
         whereto.sll_family = AF_PACKET;
 …
     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);
+    xsendto(s, outpack, pktsize, (struct sockaddr *)&whereto, sizeof(whereto));
+    if (ENABLE_FEATURE_CLEAN_UP)
+        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("Unable to read the 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;
+}

branches/stable/mindi-busybox/networking/ftpgetput.c

-              r821
+              r1770
  */
-#include <sys/ioctl.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
 #include <getopt.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include "busybox.h"
+#include "libbb.h"
 typedef struct ftp_host_info_s {
     char *user;
     char *password;
     struct sockaddr_in *s_in;
+    const char *user;
+    const char *password;
+    struct len_and_sockaddr *lsa;
 } ftp_host_info_t;
+static char verbose_flag = 0;
+static char do_continue = 0;
+static smallint verbose_flag;
+static smallint do_continue;
+static void ftp_die(const char *msg, const char *remote) ATTRIBUTE_NORETURN;
+static void ftp_die(const char *msg, const char *remote)
+{
+    /* Guard against garbage from remote server */
+    const char *cp = remote;
+    while (*cp >= ' ' && *cp < '\x7f') cp++;
+    bb_error_msg_and_die("unexpected server response%s%s: %.*s",
+            msg ? " to " : "", msg ? msg : "",
+            (int)(cp - remote), remote);
+}
 static int ftpcmd(const char *s1, const char *s2, FILE *stream, char *buf)
+{
+    unsigned n;
     if (verbose_flag) {
         bb_error_msg("cmd %s%s", s1, s2);
+        bb_error_msg("cmd %s %s", s1, s2);
+    }
     if (s1) {
         if (s2) {
             fprintf(stream, "%s%s\r\n", s1, s2);
+            fprintf(stream, "%s %s\r\n", s1, s2);
         } else {
             fprintf(stream, "%s\r\n", s1);
 …
         if (fgets(buf, 510, stream) == NULL) {
             bb_perror_msg_and_die("fgets()");
+            bb_perror_msg_and_die("fgets");
+        }
         buf_ptr = strstr(buf, "\r\n");
 …
             *buf_ptr = '\0';
+        }
+    } while (! isdigit(buf[0]) || buf[3] != ' ');
+    return atoi(buf);
+}
+static int xconnect_ftpdata(ftp_host_info_t *server, const char *buf)
+    } while (!isdigit(buf[0]) || buf[3] != ' ');
+    buf[3] = '\0';
+    n = xatou(buf);
+    buf[3] = ' ';
+    return n;
+}
+static int xconnect_ftpdata(ftp_host_info_t *server, char *buf)
+{
     char *buf_ptr;
     unsigned short port_num;
+    /* Response is "NNN 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 */
+    buf_ptr = strrchr(buf, ')');
+    if (buf_ptr) *buf_ptr = '\0';
     buf_ptr = strrchr(buf, ',');
     *buf_ptr = '\0';
     port_num = atoi(buf_ptr + 1);
+    port_num = xatoul_range(buf_ptr + 1, 0, 255);
     buf_ptr = strrchr(buf, ',');
     *buf_ptr = '\0';
     port_num += atoi(buf_ptr + 1) * 256;
     server->s_in->sin_port=htons(port_num);
     return(xconnect(server->s_in));
+    port_num += xatoul_range(buf_ptr + 1, 0, 255) * 256;
+    set_nport(server->lsa, htons(port_num));
+    return xconnect_stream(server->lsa);
+}
 …
     /* Connect to the command socket */
     control_stream = fdopen(xconnect(server->s_in), "r+");
+    control_stream = fdopen(xconnect_stream(server->lsa), "r+");
     if (control_stream == NULL) {
+        bb_perror_msg_and_die("Couldnt open control stream");
+        /* fdopen failed - extremely unlikely */
+        bb_perror_nomsg_and_die();
+    }
     if (ftpcmd(NULL, NULL, control_stream, buf) != 220) {
         bb_error_msg_and_die("%s", buf + 4);
+        ftp_die(NULL, buf);
+    }
     /*  Login to the server */
     switch (ftpcmd("USER ", server->user, control_stream, buf)) {
+    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);
+        if (ftpcmd("PASS", server->password, control_stream, buf) != 230) {
+            ftp_die("PASS", buf);
+        }
         break;
     default:
         bb_error_msg_and_die("USER error: %s", buf + 4);
+        ftp_die("USER", buf);
+    }
     ftpcmd("TYPE I", NULL, control_stream, buf);
     return(control_stream);
+    return control_stream;
+}
 #if !ENABLE_FTPGET
+#define ftp_receive 0
+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,
+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;
+/* I think 'filesize' usage here is bogus. Let's see... */
+    //off_t filesize = -1;
+#define filesize ((off_t)-1)
     int fd_data;
     int fd_local = -1;
 …
     /* Connect to the data socket */
     if (ftpcmd("PASV", NULL, control_stream, buf) != 227) {
         bb_error_msg_and_die("PASV error: %s", buf + 4);
+        ftp_die("PASV", buf);
+    }
     fd_data = xconnect_ftpdata(server, buf);
+    if (ftpcmd("SIZE ", server_path, control_stream, buf) == 213) {
+        unsigned long value=filesize;
+        if (safe_strtoul(buf + 4, &value))
+            bb_error_msg_and_die("SIZE error: %s", buf + 4);
+        filesize = value;
+    if (ftpcmd("SIZE", server_path, control_stream, buf) == 213) {
+        //filesize = BB_STRTOOFF(buf + 4, NULL, 10);
+        //if (errno || filesize < 0)
+        //  ftp_die("SIZE", buf);
     } else {
-        filesize = -1;
         do_continue = 0;
+    }
     if ((local_path[0] == '-') && (local_path[1] == '\0')) {
+    if (LONE_DASH(local_path)) {
         fd_local = STDOUT_FILENO;
         do_continue = 0;
 …
         struct stat sbuf;
         if (lstat(local_path, &sbuf) < 0) {
             bb_perror_msg_and_die("fstat()");
+            bb_perror_msg_and_die("lstat");
+        }
         if (sbuf.st_size > 0) {
 …
     if (do_continue) {
         sprintf(buf, "REST %ld", (long)beg_range);
+        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);
+            //if (filesize != -1)
+            //  filesize -= beg_range;
+        }
+    }
+    if (ftpcmd("RETR", server_path, control_stream, buf) > 150) {
+        ftp_die("RETR", buf);
+    }
 …
     if (fd_local == -1) {
         if (do_continue) {
             fd_local = bb_xopen(local_path, O_APPEND | O_WRONLY);
+            fd_local = xopen(local_path, O_APPEND | O_WRONLY);
         } else {
             fd_local = bb_xopen(local_path, O_CREAT | O_TRUNC | O_WRONLY);
+            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);
+        if (bb_copyfd_size(fd_data, fd_local, filesize) == -1)
+            return EXIT_FAILURE;
     } else {
         if (-1 == bb_copyfd_eof(fd_data, fd_local))
             exit(EXIT_FAILURE);
+        if (bb_copyfd_eof(fd_data, fd_local) == -1)
+            return EXIT_FAILURE;
+    }
 …
     close(fd_data);
     if (ftpcmd(NULL, NULL, control_stream, buf) != 226) {
         bb_error_msg_and_die("ftp error: %s", buf + 4);
+        ftp_die(NULL, buf);
+    }
     ftpcmd("QUIT", NULL, control_stream, buf);
     return(EXIT_SUCCESS);
+    return EXIT_SUCCESS;
+}
 #endif
 #if !ENABLE_FTPPUT
+#define ftp_send 0
+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,
+static
+int ftp_send(ftp_host_info_t *server, FILE *control_stream,
         const char *server_path, char *local_path)
+{
 …
     /*  Connect to the data socket */
     if (ftpcmd("PASV", NULL, control_stream, buf) != 227) {
         bb_error_msg_and_die("PASV error: %s", buf + 4);
+        ftp_die("PASV", buf);
+    }
     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 = bb_xopen(local_path, O_RDONLY);
+    fd_local = STDIN_FILENO;
+    if (NOT_LONE_DASH(local_path)) {
+        fd_local = xopen(local_path, O_RDONLY);
         fstat(fd_local, &sbuf);
         sprintf(buf, "ALLO %lu", (unsigned long)sbuf.st_size);
+        sprintf(buf, "ALLO %"OFF_FMT"u", sbuf.st_size);
         response = ftpcmd(buf, NULL, control_stream, buf);
         switch (response) {
 …
         default:
             close(fd_local);
             bb_error_msg_and_die("ALLO error: %s", buf + 4);
+            ftp_die("ALLO", buf);
             break;
+        }
+    }
     response = ftpcmd("STOR ", server_path, control_stream, buf);
+    response = ftpcmd("STOR", server_path, control_stream, buf);
     switch (response) {
     case 125:
 …
     default:
         close(fd_local);
         bb_error_msg_and_die("STOR error: %s", buf + 4);
+        ftp_die("STOR", buf);
+    }
 …
     close(fd_data);
     if (ftpcmd(NULL, NULL, control_stream, buf) != 226) {
         bb_error_msg_and_die("error: %s", buf + 4);
+        ftp_die("close", buf);
+    }
     ftpcmd("QUIT", NULL, control_stream, buf);
     return(EXIT_SUCCESS);
+    return EXIT_SUCCESS;
+}
 #endif
 …
 #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}
+};
+#else
+#define ftpgetput_long_options 0
+#endif
+static const char ftpgetput_longopts[] ALIGN1 =
+    "continue\0" Required_argument "c"
+    "verbose\0"  No_argument       "v"
+    "username\0" Required_argument "u"
+    "password\0" Required_argument "p"
+    "port\0"     Required_argument "P"
+    ;
+#endif
+int ftpgetput_main(int argc, char **argv);
 int ftpgetput_main(int argc, char **argv)
+{
     /* content-length of the file */
+    unsigned long opt;
+    char *port = "ftp";
+    unsigned opt;
+    const char *port = "ftp";
     /* socket to ftp server */
     FILE *control_stream;
+    struct sockaddr_in s_in;
+    /* continue a prev transfer (-c) */
+    /* continue previous transfer (-c) */
     ftp_host_info_t *server;
+    int (*ftp_action)(ftp_host_info_t *, FILE *, const char *, char *) = NULL;
+#if ENABLE_FTPPUT && !ENABLE_FTPGET
+# define ftp_action ftp_send
+#elif ENABLE_FTPGET && !ENABLE_FTPPUT
+# define ftp_action ftp_receive
+#else
+    int (*ftp_action)(ftp_host_info_t *, FILE *, const char *, char *) = ftp_send;
     /* Check to see if the command is ftpget or ftput */
+    if (ENABLE_FTPPUT && (!ENABLE_FTPGET || bb_applet_name[3] == 'p')) {
+        ftp_action = ftp_send;
+    }
+    if (ENABLE_FTPGET && (!ENABLE_FTPPUT || bb_applet_name[3] == 'g')) {
+    if (applet_name[3] == 'g') {
         ftp_action = ftp_receive;
+    }
+#endif
     /* Set default values */
     server = xmalloc(sizeof(ftp_host_info_t));
+    server = xmalloc(sizeof(*server));
     server->user = "anonymous";
     server->password = "busybox@";
-    verbose_flag = 0;
     /*
      * Decipher the command line
      */
+    if (ENABLE_FEATURE_FTPGETPUT_LONG_OPTIONS)
+        bb_applet_long_options = ftpgetput_long_options;
+    opt = bb_getopt_ulflags(argc, argv, "cvu:p:P:", &server->user, &server->password, &port);
+#if ENABLE_FEATURE_FTPGETPUT_LONG_OPTIONS
+    applet_long_options = ftpgetput_longopts;
+#endif
+    opt_complementary = "=3"; /* must have 3 params */
+    opt = getopt32(argv, "cvu:p:P:", &server->user, &server->password, &port);
+    argv += optind;
     /* Process the non-option command line arguments */
-    if (argc - optind != 3) {
-        bb_show_usage();
+    }
     if (opt & FTPGETPUT_OPT_CONTINUE) {
         do_continue = 1;
 …
      * 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);
+    server->lsa = xhost2sockaddr(argv[0], 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));
+        printf("Connecting to %s (%s)\n", argv[0],
+            xmalloc_sockaddr2dotted(&server->lsa->sa));
+    }
 …
     control_stream = ftp_login(server);
     return(ftp_action(server, control_stream, argv[optind + 1], argv[optind + 2]));
+}
+    return ftp_action(server, control_stream, argv[1], argv[2]);
+}

branches/stable/mindi-busybox/networking/hostname.c

-              r821
+              r1770
 /* 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
+ *
 …
  * use of long options and GNU getopt.  Improved the usage info.
+ *
+ * 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.
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
+#include <errno.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include "busybox.h"
+extern char *optarg; /* in unistd.h */
+extern int  optind, opterr, optopt; /* in unistd.h */
+#include "libbb.h"
 static void do_sethostname(char *s, int isfile)
+{
     FILE *f;
-    char buf[255];
     if (!s)
 …
         if (sethostname(s, strlen(s)) < 0) {
             if (errno == EPERM)
                 bb_error_msg_and_die("you must be root to change the hostname");
+                bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
             else
                 bb_perror_msg_and_die("sethostname");
+        }
     } else {
+        f = bb_xfopen(s, "r");
+        while (fgets(buf, 255, f) != NULL) {
+            if (buf[0] =='#') {
+        f = xfopen(s, "r");
+#define strbuf bb_common_bufsiz1
+        while (fgets(strbuf, sizeof(strbuf), f) != NULL) {
+            if (strbuf[0] == '#') {
                 continue;
+            }
             chomp(buf);
             do_sethostname(buf, 0);
+            chomp(strbuf);
+            do_sethostname(strbuf, 0);
+        }
+#ifdef CONFIG_FEATURE_CLEAN_UP
+        fclose(f);
+#endif
+        if (ENABLE_FEATURE_CLEAN_UP)
+            fclose(f);
+    }
+}
+int hostname_main(int argc, char **argv);
 int hostname_main(int argc, char **argv)
+{
+    int opt;
+    int type = 0;
+    struct hostent *hp;
+    char *filename = NULL;
+    char buf[255];
+    char *p = NULL;
+    enum {
+        OPT_d = 0x1,
+        OPT_f = 0x2,
+        OPT_i = 0x4,
+        OPT_s = 0x8,
+        OPT_F = 0x10,
+        OPT_dfis = 0xf,
+    };
+    char buf[256];
+    char *hostname_str;
     if (argc < 1)
         bb_show_usage();
+    while ((opt = getopt(argc, argv, "dfisF:")) > 0) {
+        switch (opt) {
+        case 'd':
+        case 'f':
+        case 'i':
+        case 's':
+            type = opt;
+            break;
+        case 'F':
+            filename = optarg;
+            break;
+        default:
+            bb_show_usage();
+        }
+    }
+    getopt32(argv, "dfisF:", &hostname_str);
     /* Output in desired format */
+    if (type != 0) {
+        gethostname(buf, 255);
+    if (option_mask32 & OPT_dfis) {
+        struct hostent *hp;
+        char *p;
+        gethostname(buf, sizeof(buf));
         hp = xgethostbyname(buf);
         p = strchr(hp->h_name, '.');
         if (type == 'f') {
+        if (option_mask32 & OPT_f) {
             puts(hp->h_name);
         } else if (type == 's') {
+        } else if (option_mask32 & OPT_s) {
             if (p != NULL) {
                 *p = 0;
+                *p = '\0';
+            }
             puts(hp->h_name);
+        } else if (type == 'd') {
+            if (p) puts(p + 1);
+        } else if (type == 'i') {
+        } else if (option_mask32 & OPT_d) {
+            if (p)
+                puts(p + 1);
+        } else if (option_mask32 & OPT_i) {
             while (hp->h_addr_list[0]) {
                 printf("%s ", inet_ntoa(*(struct in_addr *) (*hp->h_addr_list++)));
+            }
             printf("\n");
+            puts("");
+        }
+    }
     /* Set the hostname */
     else if (filename != NULL) {
         do_sethostname(filename, 1);
+    else if (option_mask32 & OPT_F) {
+        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, 255);
+    else {
+        gethostname(buf, sizeof(buf));
         puts(buf);
+    }
     return(0);
+    return 0;
+}

branches/stable/mindi-busybox/networking/httpd.c

-              r902
+              r1770
+ *
+ *
  * When a url contains "cgi-bin" it is assumed to be a cgi script.  The
+ * When a url starts by "/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
 …
  * A:127.0.0.1       # Allow local loopback connections
  * D:*               # Deny from other IP connections
+ * E404:/path/e404.html # /path/e404.html is the 404 (not found) error page
  * /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/
 …
  * result, the subdir settings only have a lifetime of a single request.
+ *
+ * Custom error pages can contain an absolute path or be relative to
+ * 'home_httpd'. Error pages are to be static files (no CGI or script). Error
+ * page can only be defined in the root configuration file and are not taken
+ * into account in local (directories) config files.
+ *
  * If -c is not set, an attempt will be made to open the default
 …
  * server exits with an error.
+ *
+*/
+#include <stdio.h>
+#include <ctype.h>         /* for isspace           */
+#include <string.h>
+#include <stdlib.h>        /* for malloc            */
+#include <time.h>
+#include <unistd.h>        /* for close             */
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>    /* for connect and socket*/
+#include <netinet/in.h>    /* for sockaddr_in       */
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>         /* for open modes        */
+#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[] = "./";
+#ifdef CONFIG_LFS
+# define cont_l_fmt "%lld"
+# define cont_l_type (long long)
+#else
+# define cont_l_fmt "%ld"
+# define cont_l_type (long)
+#endif
+#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
+ */
+#include "libbb.h"
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+#include <sys/sendfile.h>
+#endif
 //#define DEBUG 1
+#ifndef DEBUG
+# define DEBUG 0
+#endif
+#define MAX_MEMORY_BUFF 8192    /* IO buffer */
+typedef struct HT_ACCESS {
+#define DEBUG 0
+/* amount of buffering in a pipe */
+#ifndef PIPE_BUF
+# define PIPE_BUF 4096
+#endif
+#define IOBUF_SIZE 8192    /* IO buffer */
+#define HEADER_READ_TIMEOUT 60
+static const char default_path_httpd_conf[] ALIGN1 = "/etc";
+static const char httpd_conf[] ALIGN1 = "httpd.conf";
+static const char HTTP_200[] ALIGN1 = "HTTP/1.0 200 OK\r\n";
+typedef struct has_next_ptr {
+    struct has_next_ptr *next;
+} has_next_ptr;
+/* Must have "next" as a first member */
+typedef struct Htaccess {
+    struct Htaccess *next;
     char *after_colon;
+    struct HT_ACCESS *next;
+    char before_colon[1];         /* really bigger, must last */
+    char before_colon[1];  /* really bigger, must be last */
 } Htaccess;
+typedef struct HT_ACCESS_IP {
+    unsigned int ip;
+    unsigned int mask;
+/* Must have "next" as a first member */
+typedef struct Htaccess_IP {
+    struct Htaccess_IP *next;
+    unsigned ip;
+    unsigned 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 defined(CONFIG_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 */
+  union HTTPD_FOUND {
+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,
+    HTTP_CONTINUE = 100,
+#if 0   /* future use */
+    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
+};
+static const uint16_t http_response_type[] ALIGN2 = {
+    HTTP_OK,
+    HTTP_MOVED_TEMPORARILY,
+    HTTP_REQUEST_TIMEOUT,
+    HTTP_NOT_IMPLEMENTED,
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    HTTP_UNAUTHORIZED,
+#endif
+    HTTP_NOT_FOUND,
+    HTTP_BAD_REQUEST,
+    HTTP_FORBIDDEN,
+    HTTP_INTERNAL_SERVER_ERROR,
+#if 0   /* not implemented */
+    HTTP_CREATED,
+    HTTP_ACCEPTED,
+    HTTP_NO_CONTENT,
+    HTTP_MULTIPLE_CHOICES,
+    HTTP_MOVED_PERMANENTLY,
+    HTTP_NOT_MODIFIED,
+    HTTP_BAD_GATEWAY,
+    HTTP_SERVICE_UNAVAILABLE,
+#endif
+};
+static const struct {
+    const char *name;
+    const char *info;
+} http_response[ARRAY_SIZE(http_response_type)] = {
+    { "OK", NULL },
+    { "Found", "Directories must end with a slash" }, /* ?? */
+    { "Request Timeout", "No request appeared within 60 seconds" },
+    { "Not Implemented", "The requested method is not recognized" },
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    { "Unauthorized", "" },
+#endif
+    { "Not Found", "The requested URL was not found" },
+    { "Bad Request", "Unsupported method" },
+    { "Forbidden", ""  },
+    { "Internal Server Error", "Internal Server Error" },
+#if 0   /* not implemented */
+    { "Created" },
+    { "Accepted" },
+    { "No Content" },
+    { "Multiple Choices" },
+    { "Moved Permanently" },
+    { "Not Modified" },
+    { "Bad Gateway", "" },
+    { "Service Unavailable", "" },
+#endif
+};
+struct globals {
+    int verbose;            /* must be int (used by getopt32) */
+    smallint flg_deny_all;
+    unsigned rmt_ip;    /* used for IP-based allow/deny rules */
+    time_t last_mod;
+    off_t ContentLength;    /* -1 - unknown */
+    char *rmt_ip_str;       /* for $REMOTE_ADDR and $REMOTE_PORT */
+    const char *bind_addr_or_port;
+    const char *g_query;
+    const char *configFile;
+    const char *home_httpd;
     const char *found_mime_type;
     const char *found_moved_temporarily;
+  } httpd_found;
+  off_t ContentLength;          /* -1 - unknown */
+  time_t last_mod;
+  Htaccess_IP *ip_a_d;          /* config allow/deny lines */
+  int flg_deny_all;
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+  Htaccess *auth;               /* config user:password lines */
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+  Htaccess *mime_a;             /* config mime types */
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+  int accepted_socket;
+# define a_c_r config->accepted_socket
+# define a_c_w config->accepted_socket
+#else
+# define a_c_r 0
+# define a_c_w 1
+#endif
+  volatile int alarm_signaled;
+#ifdef CONFIG_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
+, "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." },
+#ifdef CONFIG_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", "" },
+    Htaccess_IP *ip_a_d;    /* config allow/deny lines */
+    USE_FEATURE_HTTPD_BASIC_AUTH(const char *g_realm;)
+    USE_FEATURE_HTTPD_BASIC_AUTH(char *remoteuser;)
+    USE_FEATURE_HTTPD_CGI(char *referer;)
+    USE_FEATURE_HTTPD_CGI(char *user_agent;)
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    Htaccess *g_auth;       /* config user:password lines */
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+    Htaccess *mime_a;       /* config mime types */
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+    Htaccess *script_i;     /* config script interpreters */
+#endif
+    char *iobuf;            /* [IOBUF_SIZE] */
+#define hdr_buf bb_common_bufsiz1
+    char *hdr_ptr;
+    int hdr_cnt;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    const char *http_error_page[ARRAY_SIZE(http_response_type)];
 #endif
 };
+static const char RFC1123FMT[] = "%a, %d %b %Y %H:%M:%S GMT";
+static const char Content_length[] = "Content-length:";
+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)
+#define G (*ptr_to_globals)
+#define verbose           (G.verbose          )
+#define flg_deny_all      (G.flg_deny_all     )
+#define rmt_ip            (G.rmt_ip           )
+#define bind_addr_or_port (G.bind_addr_or_port)
+#define g_query           (G.g_query          )
+#define configFile        (G.configFile       )
+#define home_httpd        (G.home_httpd       )
+#define found_mime_type   (G.found_mime_type  )
+#define found_moved_temporarily (G.found_moved_temporarily)
+#define ContentLength     (G.ContentLength    )
+#define last_mod          (G.last_mod         )
+#define ip_a_d            (G.ip_a_d           )
+#define g_realm           (G.g_realm          )
+#define remoteuser        (G.remoteuser       )
+#define referer           (G.referer          )
+#define user_agent        (G.user_agent       )
+#define rmt_ip_str        (G.rmt_ip_str       )
+#define g_auth            (G.g_auth           )
+#define mime_a            (G.mime_a           )
+#define script_i          (G.script_i         )
+#define iobuf             (G.iobuf            )
+#define hdr_ptr           (G.hdr_ptr          )
+#define hdr_cnt           (G.hdr_cnt          )
+#define http_error_page   (G.http_error_page  )
+#define INIT_G() do { \
+    PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
+    USE_FEATURE_HTTPD_BASIC_AUTH(g_realm = "Web Server Authentication";) \
+    bind_addr_or_port = "80"; \
+    ContentLength = -1; \
+} while (0)
+#define STRNCASECMP(a, str) strncasecmp((a), (str), sizeof(str)-1)
+/* Prototypes */
+static void send_file_and_exit(const char *url, int headers) ATTRIBUTE_NORETURN;
+static void free_llist(has_next_ptr **pptr)
+{
+    has_next_ptr *cur = *pptr;
+    while (cur) {
+        has_next_ptr *t = cur;
+        cur = cur->next;
+        free(t);
+    }
+    *pptr = NULL;
+}
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
+ || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
+ || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+static ALWAYS_INLINE void free_Htaccess_list(Htaccess **pptr)
+{
+    free_llist((has_next_ptr**)pptr);
+}
+#endif
+static ALWAYS_INLINE void free_Htaccess_IP_list(Htaccess_IP **pptr)
+{
+    free_llist((has_next_ptr**)pptr);
+}
+/* Returns presumed mask width in bits or < 0 on error.
+ * Updates strp, stores IP at provided pointer */
+static int scan_ip(const char **strp, unsigned *ipp, unsigned char endc)
+{
+    const char *p = *strp;
+    int auto_mask = 8;
+    unsigned ip = 0;
+    int j;
+    if (*p == '/')
         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;
+            }
+    for (j = 0; j < 4; j++) {
+        unsigned octet;
+        if ((*p < '0' || *p > '9') && *p != '/' && *p)
+            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)
+            auto_mask += 8;
+        ip = (ip << 8) | octet;
+    }
+    if (*p) {
+        if (*p != endc)
+            return -auto_mask;
+        p++;
+        if (*p == '\0')
+            return -auto_mask;
+    }
+    *ipp = ip;
+    *strp = p;
+    return auto_mask;
+}
+/* Returns 0 on success. Stores IP and mask at provided pointers */
+static int scan_ip_mask(const char *str, unsigned *ipp, unsigned *maskp)
+{
+    int i;
+    unsigned mask;
+    char *p;
+    i = scan_ip(&str, ipp, '/');
+    if (i < 0)
+        return i;
+    if (*str) {
+        /* there is /xxx after dotted-IP address */
+        i = bb_strtou(str, &p, 10);
+        if (*p == '.') {
+            /* 'xxx' itself is dotted-IP mask, parse it */
+            /* (return 0 (success) only if it has N.N.N.N form) */
+            return scan_ip(&str, maskp, '\0') - 32;
+        }
+        if (*p)
             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 defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_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
+    }
+    if (i > 32)
+        return -1;
+    if (sizeof(unsigned) == 4 && i == 32) {
+        /* mask >>= 32 below may not work */
+        mask = 0;
+    } else {
+        mask = 0xffffffff;
+        mask >>= i;
+    }
+    /* i == 0 -> *maskp = 0x00000000
+     * i == 1 -> *maskp = 0x80000000
+     * i == 4 -> *maskp = 0xf0000000
+     * i == 31 -> *maskp = 0xfffffffe
+     * i == 32 -> *maskp = 0xffffffff */
+    *maskp = (uint32_t)(~mask);
+    return 0;
+}
+/*
+ * 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
+ *    Ennn:error.html  # error page for status nnn
+ *
+ * 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.
+ * Error pages are only parsed on the main config file.
+ *
+ * path   Path where to look for httpd.conf (without filename).
+ * flag   Type of the parse request.
+ */
 /* flag */
 #define FIRST_PARSE          0
 …
 #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;
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+    Htaccess *prev, *cur;
+#elif CONFIG_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 defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR)
+    /* retain previous auth and mime config only for subdir parse */
+    if(flag != SUBDIR_PARSE) {
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+    free_config_lines(&config->auth);
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+    free_config_lines(&config->mime_a);
+#endif
+#ifdef CONFIG_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;
+    }
+#ifdef CONFIG_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'
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+       && *p0 != '/'
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+       && *p0 != '.'
+#endif
+#ifdef CONFIG_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 */
+    FILE *f;
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    Htaccess *prev;
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH \
+ || ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES \
+ || ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+    Htaccess *cur;
+#endif
+    const char *cf = configFile;
+    char buf[160];
+    char *p0 = NULL;
+    char *c, *p;
+    Htaccess_IP *pip;
+    /* discard old rules */
+    free_Htaccess_IP_list(&ip_a_d);
+    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_Htaccess_list(&g_auth);
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+        free_Htaccess_list(&mime_a);
+#endif
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+        free_Htaccess_list(&script_i);
+#endif
+    }
+#endif
+    if (flag == SUBDIR_PARSE || cf == NULL) {
+        cf = alloca(strlen(path) + sizeof(httpd_conf) + 2);
+        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 (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 = g_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';
+            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;
+    }
+#ifdef CONFIG_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 '.' */
+        if (*c == '*') {
+            if (*p0 == 'D') {
+                /* memorize deny all */
+                flg_deny_all = 1;
+            }
+            /* skip default other "word:*" config lines */
+            continue;
+        }
+        if (*p0 == 'a')
+            *p0 = 'A';
+        if (*p0 == 'A' || *p0 == 'D') {
+            /* storing current config IP line */
+            pip = xzalloc(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:from_IP move top */
+                    pip->next = ip_a_d;
+                    ip_a_d = pip;
+                } else {
+                    /* add to bottom A:form_IP config line */
+                    Htaccess_IP *prev_IP = ip_a_d;
+                    if (prev_IP == NULL) {
+                        ip_a_d = pip;
+                    } else {
+                        while (prev_IP->next)
+                            prev_IP = prev_IP->next;
+                        prev_IP->next = pip;
+                    }
+                }
+            }
+            continue;
+        }
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+        if (flag == FIRST_PARSE && *p0 == 'E') {
+            int i;
+            /* error status code */
+            int status = atoi(++p0);
+            /* c already points at the character following ':' in parse loop */
+            /* c = strchr(p0, ':'); c++; */
+            if (status < HTTP_CONTINUE) {
+                bb_error_msg("config error '%s' in '%s'", buf, cf);
                 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 defined(CONFIG_FEATURE_HTTPD_BASIC_AUTH) || defined(CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES) || defined(CONFIG_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;
+#ifdef CONFIG_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
+#ifdef CONFIG_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
+#ifdef CONFIG_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);
+}
+#ifdef CONFIG_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          /* CONFIG_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)    flag   . . . 1 if require decode '+' as ' ' for CGI
+ *
+ * $Return: (char *)  . . . . A pointer to the decoded string (same as input).
+ *
+ * $Errors: None
+ *
+ ****************************************************************************/
+static char *decodeString(char *orig, int flag_plus_to_space)
+{
+  /* note that decoded string is always shorter than original */
+  char *string = orig;
+  char *ptr = string;
+  while (*ptr)
+  {
+    if (*ptr == '+' && flag_plus_to_space)    { *string++ = ' '; ptr++; }
+    else if (*ptr != '%') *string++ = *ptr++;
+    else  {
+      unsigned int value1, value2;
+      ptr++;
+      if(sscanf(ptr, "%1X", &value1) != 1 ||
+                sscanf(ptr+1, "%1X", &value2) != 1) {
+    if(!flag_plus_to_space)
+        return NULL;
+    *string++ = '%';
+      } else {
+    value1 = value1 * 16 + value2;
+    if(value1 == '/' || value1 == 0)
+        return orig+1;
+    *string++ = value1;
+    ptr += 2;
+      }
+    }
+  }
+  *string = '\0';
+  return orig;
+}
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+/****************************************************************************
+ *
+ > $Function: addEnv()
+ *
+ * $Description: Add an environment variable setting to the global list.
+ *    A NAME=VALUE string is allocated, filled, and added to the list of
+ *    environment settings passed to the cgi execution script.
+ *
+ * $Parameters:
+ *  (char *) name_before_underline - The first part environment variable name.
+ *  (char *) name_after_underline  - The second part environment variable name.
+ *  (char *) value  . . The value to which the env variable is set.
+ *
+ * $Return: (void)
+ *
+ * $Errors: Silently returns if the env runs out of space to hold the new item
+ *
+ ****************************************************************************/
+static void addEnv(const char *name_before_underline,
+            const char *name_after_underline, const char *value)
+{
+  char *s = NULL;
+  const char *underline;
+  if (!value)
+    value = "";
+  underline = *name_after_underline ? "_" : "";
+  asprintf(&s, "%s%s%s=%s", name_before_underline, underline,
+                    name_after_underline, value);
+  if(s) {
+    putenv(s);
+  }
+}
+#if defined(CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV) || defined(CONFIG_FEATURE_HTTPD_WITHOUT_INETD)
+/* set environs SERVER_PORT and REMOTE_PORT */
+static void addEnvPort(const char *port_name)
+{
+      char buf[16];
+      sprintf(buf, "%u", config->port);
+      addEnv(port_name, "PORT", buf);
+}
+#endif
+#endif          /* CONFIG_FEATURE_HTTPD_CGI */
+#ifdef CONFIG_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
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+/****************************************************************************
+ *
+ > $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;
+  int on = 1;
+  /* 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 = bb_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
+  setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (void *)&on, sizeof(on)) ;
+#else
+  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on)) ;
+#endif
+  bb_xbind(fd, (struct sockaddr *)&lsocket, sizeof(lsocket));
+  listen(fd, 9); /* bb_xlisten? */
+  signal(SIGCHLD, SIG_IGN);   /* prevent zombie (defunct) processes */
+  return fd;
+}
+#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
+/****************************************************************************
+ *
+ > $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;
+  for (i = 0;
+    i < (sizeof(httpResponseNames)/sizeof(httpResponseNames[0])); 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->httpd_found.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);
+#ifdef CONFIG_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->httpd_found.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 " cont_l_fmt "\r\n",
+                  timeStr, Content_length, cont_l_type 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'", buf);
+#endif
+  return bb_full_write(a_c_w, 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(a_c_r, 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 owerflow */
+    count++;
+  }
+  if (count) return count;
+  else return -1;
+}
+#ifdef CONFIG_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;
+  do {
+    if (pipe(fromCgi) != 0) {
+      break;
+    }
+    if (pipe(toCgi) != 0) {
+      break;
+    }
+    pid = fork();
+    if (pid < 0) {
+    pid = 0;
+    break;
+    }
+    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]);
+      /*
+       * 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 '/' */
+      }
+      addEnv("PATH", "INFO", script);   /* set /PATH_INFO or NULL */
+      addEnv("PATH",           "",         getenv("PATH"));
+      addEnv("REQUEST",        "METHOD",   request);
+      if(config->query) {
+    char *uri = alloca(strlen(purl) + 2 + strlen(config->query));
+    if(uri)
+        sprintf(uri, "%s?%s", purl, config->query);
+    addEnv("REQUEST",        "URI",   uri);
+      } else {
+    addEnv("REQUEST",        "URI",   purl);
+      }
+      if(script != NULL)
+    *script = '\0';         /* reduce /PATH_INFO */
+       /* SCRIPT_FILENAME required by PHP in CGI mode */
+       if(realpath(purl + 1, realpath_buff))
+     addEnv("SCRIPT", "FILENAME", realpath_buff);
+       else
+     *realpath_buff = 0;
+      /* set SCRIPT_NAME as full path: /cgi-bin/dirs/script.cgi */
+      addEnv("SCRIPT_NAME",    "",         purl);
+      addEnv("QUERY_STRING",   "",         config->query);
+      addEnv("SERVER",         "SOFTWARE", httpdVersion);
+      addEnv("SERVER",         "PROTOCOL", "HTTP/1.0");
+      addEnv("GATEWAY_INTERFACE", "",      "CGI/1.1");
+      addEnv("REMOTE",         "ADDR",     config->rmt_ip_str);
+#ifdef CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+      addEnvPort("REMOTE");
+#endif
+      if(bodyLen) {
+    char sbl[32];
+    sprintf(sbl, "%d", bodyLen);
+    addEnv("CONTENT", "LENGTH", sbl);
+      }
+      if(cookie)
+    addEnv("HTTP", "COOKIE", cookie);
+      if(content_type)
+    addEnv("CONTENT", "TYPE", content_type);
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+      if(config->remoteuser) {
+    addEnv("REMOTE", "USER", config->remoteuser);
+    addEnv("AUTH_TYPE", "", "Basic");
+      }
+#endif
+      if(config->referer)
+    addEnv("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 */
+      if(*realpath_buff) {
+        script = strrchr(realpath_buff, '/');
+        if(script) {
+        *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.
+#ifdef CONFIG_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;
+            }
+            /* then error page; find matching status */
+            for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
+                if (http_response_type[i] == status) {
+                    http_error_page[i] = concat_path_file((*c == '/') ? NULL : home_httpd, c);
                     break;
+                }
+          }
+#endif
+          *script = '/';
+#ifdef CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+          if (interpr)
+            execv(interpr, argp);
+          else
+#endif
+            execv(realpath_buff, argp);
+        }
+        }
+      }
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+      config->accepted_socket = 1;      /* send to stdout */
+#endif
+      sendHeaders(HTTP_NOT_FOUND);
+      _exit(242);
+    } /* end child */
+  } while (0);
+  if (pid) {
+    /* parent process */
+    int status;
+    size_t 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(a_c_r, &readSet);
+        if(nfound < a_c_r)
+            nfound = a_c_r;
+    }
+      /* 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);
+            }
+            continue;
+        }
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+        if (*p0 == '/') {
+            /* make full path from httpd root / current_path / config_line_path */
+            cf = (flag == SUBDIR_PARSE ? path : "");
+            p0 = xmalloc(strlen(cf) + (c - buf) + 2 + strlen(c));
+            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 + strlen(p0), ":%s", 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 = xzalloc(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 = mime_a;
+                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 = script_i;
+                script_i = cur;
+                continue;
+            }
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+            free(p0);
+            if (prev == NULL) {
+                /* first line */
+                g_auth = prev = cur;
+            } else {
+                /* sort path, if current lenght eq or bigger then move up */
+                Htaccess *prev_hti = g_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 */
+                            g_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
+/*
+ * 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().
+ *
+ * Returns a pointer to the encoded string (malloced).
+ */
+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 = xmalloc(len * 6 + 1);
+    char *p = out;
+    char ch;
+    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 */
+/*
+ * 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.
+ *
+ * string    The first string to decode.
+ * option_d  1 if called for httpd -d
+ *
+ * Returns a pointer to the decoded string (same as input).
+ */
+static unsigned hex_to_bin(unsigned char c)
+{
+    unsigned v;
+    v = c - '0';
+    if (v <= 9)
+        return v;
+    /* c | 0x20: letters to lower case, non-letters
+     * to (potentially different) non-letters */
+    v = (unsigned)(c | 0x20) - 'a';
+    if (v <= 5)
+        return v + 10;
+    return ~0;
+}
+/* For testing:
+void t(char c) { printf("'%c'(%u) %u\n", c, c, hex_to_bin(c)); }
+int main() { t(0x10); t(0x20); t('0'); t('9'); t('A'); t('F'); t('a'); t('f');
+t('0'-1); t('9'+1); t('A'-1); t('F'+1); t('a'-1); t('f'+1); return 0; }
+*/
+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 v;
+        if (option_d && c == '+') {
+            *string++ = ' ';
+            continue;
+        }
+        if (c != '%') {
+            *string++ = c;
+            continue;
+        }
+        v = hex_to_bin(ptr[0]);
+        if (v > 15) {
+ bad_hex:
+            if (!option_d)
+                return NULL;
+            *string++ = '%';
+            continue;
+        }
+        v = (v * 16) | hex_to_bin(ptr[1]);
+        if (v > 255)
+            goto bad_hex;
+        if (!option_d && (v == '/' || v == '\0')) {
+            /* caller takes it as indication of invalid
+             * (dangerous wrt exploits) chars */
+            return orig + 1;
+        }
+        *string++ = v;
+        ptr += 2;
+    }
+    *string = '\0';
+    return orig;
+}
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+/*
+ * Decode a base64 data stream as per rfc1521.
+ * Note that the rfc states that non 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: a pointer to a base64 encoded string.
+ * Decoded data is stored in-place.
+ */
+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 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
+/*
+ * Create a listen server socket on the designated port.
+ */
+static int openServer(void)
+{
+    int n = bb_strtou(bind_addr_or_port, NULL, 10);
+    if (!errno && n && n <= 0xffff)
+        n = create_and_bind_stream_or_die(NULL, n);
+    else
+        n = create_and_bind_stream_or_die(bind_addr_or_port, 80);
+    xlisten(n, 9);
+    return n;
+}
+/*
+ * Log the connection closure and exit.
+ */
+static void log_and_exit(void) ATTRIBUTE_NORETURN;
+static void log_and_exit(void)
+{
+    /* Paranoia. IE said to be buggy. It may send some extra data
+     * or be confused by us just exiting without SHUT_WR. Oh well. */
+    shutdown(1, SHUT_WR);
+    ndelay_on(0);
+    while (read(0, iobuf, IOBUF_SIZE) > 0)
+        continue;
+    if (verbose > 2)
+        bb_error_msg("closed");
+    _exit(xfunc_error_retval);
+}
+/*
+ * 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.
+ * responseNum - the result code to send.
+ */
+static void send_headers(int responseNum)
+{
+    static const char RFC1123FMT[] ALIGN1 = "%a, %d %b %Y %H:%M:%S GMT";
+    const char *responseString = "";
+    const char *infoString = NULL;
+    const char *mime_type;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    const char *error_page = 0;
+#endif
+    unsigned i;
+    time_t timer = time(0);
+    char tmp_str[80];
+    int len;
+    for (i = 0; i < ARRAY_SIZE(http_response_type); i++) {
+        if (http_response_type[i] == responseNum) {
+            responseString = http_response[i].name;
+            infoString = http_response[i].info;
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+            error_page = http_error_page[i];
+#endif
+            break;
+        }
+    }
+    /* error message is HTML */
+    mime_type = responseNum == HTTP_OK ?
+                found_mime_type : "text/html";
+    if (verbose)
+        bb_error_msg("response:%u", responseNum);
+    /* emit the current date */
+    strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&timer));
+    len = sprintf(iobuf,
+            "HTTP/1.0 %d %s\r\nContent-type: %s\r\n"
+            "Date: %s\r\nConnection: close\r\n",
+            responseNum, responseString, mime_type, tmp_str);
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (responseNum == HTTP_UNAUTHORIZED) {
+        len += sprintf(iobuf + len,
+                "WWW-Authenticate: Basic realm=\"%s\"\r\n",
+                g_realm);
+    }
+#endif
+    if (responseNum == HTTP_MOVED_TEMPORARILY) {
+        len += sprintf(iobuf + len, "Location: %s/%s%s\r\n",
+                found_moved_temporarily,
+                (g_query ? "?" : ""),
+                (g_query ? g_query : ""));
+    }
+#if ENABLE_FEATURE_HTTPD_ERROR_PAGES
+    if (error_page && !access(error_page, R_OK)) {
+        strcat(iobuf, "\r\n");
+        len += 2;
+        if (DEBUG)
+            fprintf(stderr, "headers: '%s'\n", iobuf);
+        full_write(1, iobuf, len);
+        if (DEBUG)
+            fprintf(stderr, "writing error page: '%s'\n", error_page);
+        return send_file_and_exit(error_page, FALSE);
+    }
+#endif
+    if (ContentLength != -1) {    /* file */
+        strftime(tmp_str, sizeof(tmp_str), RFC1123FMT, gmtime(&last_mod));
+        len += sprintf(iobuf + len, "Last-Modified: %s\r\n%s %"OFF_FMT"d\r\n",
+            tmp_str, "Content-length:", ContentLength);
+    }
+    iobuf[len++] = '\r';
+    iobuf[len++] = '\n';
+    if (infoString) {
+        len += sprintf(iobuf + len,
+                "<HTML><HEAD><TITLE>%d %s</TITLE></HEAD>\n"
+                "<BODY><H1>%d %s</H1>\n%s\n</BODY></HTML>\n",
+                responseNum, responseString,
+                responseNum, responseString, infoString);
+    }
+    if (DEBUG)
+        fprintf(stderr, "headers: '%s'\n", iobuf);
+    if (full_write(1, iobuf, len) != len) {
+        if (verbose > 1)
+            bb_perror_msg("error");
+        log_and_exit();
+    }
+}
+static void send_headers_and_exit(int responseNum) ATTRIBUTE_NORETURN;
+static void send_headers_and_exit(int responseNum)
+{
+    send_headers(responseNum);
+    log_and_exit();
+}
+/*
+ * Read from the socket until '\n' or EOF. '\r' chars are removed.
+ * '\n' is replaced with NUL.
+ * Return number of characters read or 0 if nothing is read
+ * ('\r' and '\n' are not counted).
+ * Data is returned in iobuf.
+ */
+static int get_line(void)
+{
+    int count = 0;
+    char c;
+    while (1) {
+        if (hdr_cnt <= 0) {
+            hdr_cnt = safe_read(0, hdr_buf, sizeof(hdr_buf));
+            if (hdr_cnt <= 0)
+                break;
+            hdr_ptr = hdr_buf;
+        }
+        iobuf[count] = c = *hdr_ptr++;
+        hdr_cnt--;
+        if (c == '\r')
+            continue;
+        if (c == '\n') {
+            iobuf[count] = '\0';
+            return count;
+        }
+        if (count < (IOBUF_SIZE - 1))      /* check overflow */
+            count++;
+    }
+    return count;
+}
+#if ENABLE_FEATURE_HTTPD_CGI
+static void setenv1(const char *name, const char *value)
+{
+    setenv(name, value ? value : "", 1);
+}
+/*
+ * Spawn CGI script, forward CGI's stdin/out <=> network
+ *
+ * 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.
+ */
+static void send_cgi_and_exit(
+        const char *url,
+        const char *request,
+        int bodyLen,
+        const char *cookie,
+        const char *content_type) ATTRIBUTE_NORETURN;
+static void send_cgi_and_exit(
+        const char *url,
+        const char *request,
+        int bodyLen,
+        const char *cookie,
+        const char *content_type)
+{
+    struct { int rd; int wr; } fromCgi;  /* CGI -> httpd pipe */
+    struct { int rd; int wr; } toCgi;    /* httpd -> CGI pipe */
+    char *fullpath;
+    char *script;
+    char *purl;
+    int buf_count;
+    int status;
+    int pid = 0;
+    /*
+     * We are mucking with environment _first_ and then vfork/exec,
+     * this allows us to use vfork safely. Parent don't care about
+     * these environment changes anyway.
+     */
+    /*
+     * Find PATH_INFO.
+     */
+    purl = xstrdup(url);
+    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)) {
+            /* not directory, found script.cgi/PATH_INFO */
+            *script = '/';
+            break;
+        }
+        *script = '/';          /* is directory, find next '/' */
+    }
+    setenv1("PATH_INFO", script);   /* set /PATH_INFO or "" */
+    setenv1("REQUEST_METHOD", request);
+    if (g_query) {
+        putenv(xasprintf("%s=%s?%s", "REQUEST_URI", purl, g_query));
+    } else {
+        setenv1("REQUEST_URI", purl);
+    }
+    if (script != NULL)
+        *script = '\0';         /* cut off /PATH_INFO */
+    /* SCRIPT_FILENAME required by PHP in CGI mode */
+    fullpath = concat_path_file(home_httpd, purl);
+    setenv1("SCRIPT_FILENAME", fullpath);
+    /* 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 seem to do some decoding) */
+    setenv1("QUERY_STRING", g_query);
+    putenv((char*)"SERVER_SOFTWARE=busybox httpd/"BB_VER);
+    putenv((char*)"SERVER_PROTOCOL=HTTP/1.0");
+    putenv((char*)"GATEWAY_INTERFACE=CGI/1.1");
+    /* Having _separate_ variables for IP and port defeats
+     * the purpose of having socket abstraction. Which "port"
+     * are you using on Unix domain socket?
+     * IOW - REMOTE_PEER="1.2.3.4:56" makes much more sense.
+     * Oh well... */
+    {
+        char *p = rmt_ip_str ? rmt_ip_str : (char*)"";
+        char *cp = strrchr(p, ':');
+        if (ENABLE_FEATURE_IPV6 && cp && strchr(cp, ']'))
+            cp = NULL;
+        if (cp) *cp = '\0'; /* delete :PORT */
+        setenv1("REMOTE_ADDR", p);
+        if (cp) {
+            *cp = ':';
+#if ENABLE_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV
+            setenv1("REMOTE_PORT", cp + 1);
+#endif
+        }
+    }
+    setenv1("HTTP_USER_AGENT", user_agent);
+    if (bodyLen)
+        putenv(xasprintf("CONTENT_LENGTH=%d", bodyLen));
+    if (cookie)
+        setenv1("HTTP_COOKIE", cookie);
+    if (content_type)
+        setenv1("CONTENT_TYPE", content_type);
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (remoteuser) {
+        setenv1("REMOTE_USER", remoteuser);
+        putenv((char*)"AUTH_TYPE=Basic");
+    }
+#endif
+    if (referer)
+        setenv1("HTTP_REFERER", referer);
+    xpipe(&fromCgi.rd);
+    xpipe(&toCgi.rd);
+    pid = vfork();
+    if (pid < 0) {
+        /* TODO: log perror? */
+        log_and_exit();
+    }
+    if (!pid) {
+        /* Child process */
+        xfunc_error_retval = 242;
+        xmove_fd(toCgi.rd, 0);  /* replace stdin with the pipe */
+        xmove_fd(fromCgi.wr, 1);  /* replace stdout with the pipe */
+        close(fromCgi.rd);
+        close(toCgi.wr);
+        /* User seeing stderr output can be a security problem.
+         * If CGI really wants that, it can always do dup itself. */
+        /* dup2(1, 2); */
+        /* script must have absolute path */
+        script = strrchr(fullpath, '/');
+        if (!script)
+            goto error_execing_cgi;
+        *script = '\0';
+        /* chdiring to script's dir */
+        if (chdir(fullpath) == 0) {
+            char *argv[2];
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+            char *interpr = NULL;
+            char *suffix = strrchr(purl, '.');
+            if (suffix) {
+                Htaccess *cur;
+                for (cur = script_i; cur; cur = cur->next) {
+                    if (strcmp(cur->before_colon + 1, suffix) == 0) {
+                        interpr = cur->after_colon;
+                        break;
+                    }
+                }
+            }
+#endif
+            *script = '/';
+            /* set argv[0] to name without path */
+            argv[0] = (char*)bb_basename(purl);
+            argv[1] = NULL;
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+            if (interpr)
+                execv(interpr, argv);
+            else
+#endif
+                execv(fullpath, argv);
+        }
+ error_execing_cgi:
+        /* send to stdout
+         * (we are CGI here, our stdout is pumped to the net) */
+        send_headers_and_exit(HTTP_NOT_FOUND);
+    } /* end child */
+    /* Parent process */
+    /* First, restore variables possibly changed by child */
+    xfunc_error_retval = 0;
+    /* Prepare for pumping data.
+     * iobuf is used for CGI -> network data,
+     * hdr_buf is for network -> CGI data (POSTDATA) */
+    buf_count = 0;
+    close(fromCgi.wr);
+    close(toCgi.rd);
+    /* If CGI dies, we still want to correctly finish reading its output
+     * and send it to the peer. So please no SIGPIPEs! */
+    signal(SIGPIPE, SIG_IGN);
+    /* This loop still looks messy. What is an exit criteria?
+     * "CGI's output closed"? Or "CGI has exited"?
+     * What to do if CGI has closed both input and output, but
+     * didn't exit? etc... */
+    /* NB: breaking out of this loop jumps to log_and_exit() */
+    while (1) {
+        fd_set readSet;
+        fd_set writeSet;
+        int nfound;
+        int count;
+        FD_ZERO(&readSet);
+        FD_ZERO(&writeSet);
+        FD_SET(fromCgi.rd, &readSet);
+        if (bodyLen > 0 || hdr_cnt > 0) {
+            FD_SET(toCgi.wr, &writeSet);
+            nfound = toCgi.wr > fromCgi.rd ? toCgi.wr : fromCgi.rd;
+            if (hdr_cnt <= 0)
+                FD_SET(0, &readSet);
+            /* Now wait on the set of sockets! */
+            nfound = select(nfound + 1, &readSet, &writeSet, NULL, NULL);
+        } else {
+            if (!bodyLen) {
+                close(toCgi.wr); /* no more POST data to CGI */
+                bodyLen = -1;
+            }
+            nfound = select(fromCgi.rd + 1, &readSet, NULL, NULL, NULL);
+        }
+        if (nfound <= 0) {
+            if (waitpid(pid, &status, WNOHANG) <= 0) {
+                /* Weird. CGI didn't exit and no fd's
+                 * are ready, yet select returned?! */
+                continue;
+            }
+            close(fromCgi.rd);
+            if (DEBUG && WIFEXITED(status))
+                bb_error_msg("CGI exited, status=%d", WEXITSTATUS(status));
+            if (DEBUG && WIFSIGNALED(status))
+                bb_error_msg("CGI killed, signal=%d", WTERMSIG(status));
+            break;
+        }
+        if (hdr_cnt > 0 && FD_ISSET(toCgi.wr, &writeSet)) {
+            /* Have data from peer and can write to CGI */
+            count = safe_write(toCgi.wr, hdr_ptr, hdr_cnt);
+            /* Doesn't happen, we dont use nonblocking IO here
+             *if (count < 0 && errno == EAGAIN) {
+             *  ...
+             *} else */
+            if (count > 0) {
+                hdr_ptr += count;
+                hdr_cnt -= count;
+            } else {
+                hdr_cnt = bodyLen = 0; /* EOF/broken pipe to CGI */
+            }
+        } else if (bodyLen > 0 && hdr_cnt == 0
+         && FD_ISSET(0, &readSet)
+        ) {
+            /* We expect data, prev data portion is eaten by CGI
+             * and there *is* data to read from the peer
+             * (POSTDATA?) */
+            count = bodyLen > (int)sizeof(hdr_buf) ? (int)sizeof(hdr_buf) : bodyLen;
+            count = safe_read(0, hdr_buf, count);
+            if (count > 0) {
+                hdr_cnt = count;
+                hdr_ptr = hdr_buf;
+                bodyLen -= count;
+            } else {
+                bodyLen = 0; /* closed */
+            }
+        }
+#define PIPESIZE PIPE_BUF
+#if PIPESIZE >= IOBUF_SIZE
+# error "PIPESIZE >= IOBUF_SIZE"
+#endif
+        if (FD_ISSET(fromCgi.rd, &readSet)) {
+            /* There is something to read from CGI */
+            char *rbuf = iobuf;
+            /* Are we still buffering CGI output? */
+            if (buf_count >= 0) {
+                /* HTTP_200[] has single "\r\n" at the end.
+                 * According to http://hoohoo.ncsa.uiuc.edu/cgi/out.html,
+                 * CGI scripts MUST send their own header terminated by
+                 * empty line, then data. That's why we have only one
+                 * <cr><lf> pair here. We will output "200 OK" line
+                 * if needed, but CGI still has to provide blank line
+                 * between header and body */
+                /* Must use safe_read, not full_read, because
+                 * CGI may output a few first bytes and then wait
+                 * for POSTDATA without closing stdout.
+                 * With full_read we may wait here forever. */
+                count = safe_read(fromCgi.rd, rbuf + buf_count, PIPESIZE - 8);
+                if (count <= 0) {
+                    /* eof (or error) and there was no "HTTP",
+                     * so write it, then write received data */
+                    if (buf_count) {
+                        full_write(1, HTTP_200, sizeof(HTTP_200)-1);
+                        full_write(1, rbuf, buf_count);
+                    }
+                    break; /* CGI stdout is closed, exiting */
+                }
+                buf_count += count;
+                count = 0;
+                /* "Status" header format is: "Status: 302 Redirected\r\n" */
+                if (buf_count >= 8 && memcmp(rbuf, "Status: ", 8) == 0) {
+                    /* send "HTTP/1.0 " */
+                    if (full_write(1, HTTP_200, 9) != 9)
+                        break;
+                    rbuf += 8; /* skip "Status: " */
+                    count = buf_count - 8;
+                    buf_count = -1; /* buffering off */
+                } else if (buf_count >= 4) {
+                    /* Did CGI add "HTTP"? */
+                    if (memcmp(rbuf, HTTP_200, 4) != 0) {
+                        /* there is no "HTTP", do it ourself */
+                        if (full_write(1, HTTP_200, sizeof(HTTP_200)-1) != sizeof(HTTP_200)-1)
+                            break;
+                    }
+                    /* Commented out:
+                    if (!strstr(rbuf, "ontent-")) {
+                        full_write(s, "Content-type: text/plain\r\n\r\n", 28);
+                    }
+                     * Counter-example of valid CGI without Content-type:
+                     * echo -en "HTTP/1.0 302 Found\r\n"
+                     * echo -en "Location: http://www.busybox.net\r\n"
+                     * echo -en "\r\n"
+                     */
+                    count = buf_count;
+                    buf_count = -1; /* buffering off */
+                }
+            } else {
+                count = safe_read(fromCgi.rd, rbuf, PIPESIZE);
+                if (count <= 0)
+                    break;  /* eof (or error) */
+            }
+            if (full_write(1, rbuf, count) != count)
+                break;
+            if (DEBUG)
+                fprintf(stderr, "cgi read %d bytes: '%.*s'\n", count, count, rbuf);
+        } /* if (FD_ISSET(fromCgi.rd)) */
+    } /* while (1) */
+    log_and_exit();
+}
+#endif          /* FEATURE_HTTPD_CGI */
+/*
+ * Send a file response to a HTTP request, and exit
+ *
+ * Parameters:
+ * const char *url    The requested URL (with leading /).
+ * headers            Don't send headers before if FALSE.
+ */
+static void send_file_and_exit(const char *url, int headers)
+{
+    static const char *const suffixTable[] = {
+    /* Warning: shorter 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
+        NULL
+    };
+    char *suffix;
+    int f;
+    const char *const *table;
+    const char *try_suffix;
+    ssize_t count;
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+    off_t offset = 0;
+#endif
+    suffix = strrchr(url, '.');
+    /* If not found, set default as "application/octet-stream";  */
+    found_mime_type = "application/octet-stream";
+    if (suffix) {
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+        Htaccess *cur;
+#endif
+        for (table = suffixTable; *table; table += 2) {
+            try_suffix = strstr(table[0], suffix);
+            if (try_suffix) {
+                try_suffix += strlen(suffix);
+                if (*try_suffix == '\0' || *try_suffix == '.') {
+                    found_mime_type = table[1];
+                    break;
+                }
+            }
+        }
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES
+        for (cur = mime_a; cur; cur = cur->next) {
+            if (strcmp(cur->before_colon, suffix) == 0) {
+                found_mime_type = cur->after_colon;
+                break;
+            }
+        }
+#endif
+    }
+    if (DEBUG)
+        bb_error_msg("sending file '%s' content-type: %s",
+            url, found_mime_type);
+    f = open(url, O_RDONLY);
+    if (f < 0) {
+        if (DEBUG)
+            bb_perror_msg("cannot open '%s'", url);
+        if (headers)
+            send_headers_and_exit(HTTP_NOT_FOUND);
+    }
+    if (headers)
+        send_headers(HTTP_OK);
+    /* If you want to know about EPIPE below
+     * (happens if you abort downloads from local httpd): */
+    signal(SIGPIPE, SIG_IGN);
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+    do {
+        /* byte count (3rd arg) is rounded down to 64k */
+        count = sendfile(1, f, &offset, MAXINT(ssize_t) - 0xffff);
+        if (count < 0) {
+            if (offset == 0)
+                goto fallback;
+            goto fin;
+        }
+    } while (count > 0);
+    log_and_exit();
+ fallback:
+#endif
+    while ((count = safe_read(f, iobuf, IOBUF_SIZE)) > 0) {
+        ssize_t n = count;
+        count = full_write(1, iobuf, count);
+        if (count != n)
+            break;
+    }
+#if ENABLE_FEATURE_HTTPD_USE_SENDFILE
+ fin:
+#endif
+    if (count < 0 && verbose > 1)
+        bb_perror_msg("error");
+    log_and_exit();
+}
+static int checkPermIP(void)
+{
+    Htaccess_IP *cur;
+    /* This could stand some work */
+    for (cur = ip_a_d; cur; cur = cur->next) {
 #if DEBUG
+      if (WIFEXITED(status))
+          bb_error_msg("piped has exited with status=%d", WEXITSTATUS(status));
+      if (WIFSIGNALED(status))
+          bb_error_msg("piped has exited with signal=%d", WTERMSIG(status));
+#endif
+      break;
+    }
+      } else if(post_readed_size > 0 && FD_ISSET(outFd, &writeSet)) {
+        count = bb_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(a_c_r, &readSet)) {
+        count = bodyLen > (int)sizeof(wbuf) ? (int)sizeof(wbuf) : bodyLen;
+        count = safe_read(a_c_r, wbuf, count);
+        if(count > 0) {
+            post_readed_size += count;
+            bodyLen -= count;
+        } else {
+            bodyLen = 0;    /* closed */
+        }
+      }
+      if(FD_ISSET(inFd, &readSet)) {
+    int s = a_c_w;
+    char *rbuf = config->buf;
+#ifndef PIPE_BUF
+# define PIPESIZE 4096          /* amount of buffering in a pipe */
+        fprintf(stderr,
+            "checkPermIP: '%s' ? '%u.%u.%u.%u/%u.%u.%u.%u'\n",
+            rmt_ip_str,
+            (unsigned char)(cur->ip >> 24),
+            (unsigned char)(cur->ip >> 16),
+            (unsigned char)(cur->ip >> 8),
+            (unsigned char)(cur->ip),
+            (unsigned char)(cur->mask >> 24),
+            (unsigned char)(cur->mask >> 16),
+            (unsigned char)(cur->mask >> 8),
+            (unsigned char)(cur->mask)
+        );
+#endif
+        if ((rmt_ip & cur->mask) == cur->ip)
+            return cur->allow_deny == 'A';   /* Allow/Deny */
+    }
+    /* if unconfigured, return 1 - access from all */
+    return !flg_deny_all;
+}
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+/*
+ * 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
+ *
+ * path      The file path.
+ * request   User information to validate.
+ *
+ * Returns 1 if request is OK.
+ */
+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 = g_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 doesn't match */
+                    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:
+                remoteuser = strdup(request);
+                if (remoteuser)
+                    remoteuser[u - request] = '\0';
+                return 1;   /* Ok */
+            }
+            /* unauthorized */
+        }
+    } /* for */
+    return prev == NULL;
+}
+#endif  /* FEATURE_HTTPD_BASIC_AUTH */
+/*
+ * Handle timeouts
+ */
+static void exit_on_signal(int sig) ATTRIBUTE_NORETURN;
+static void exit_on_signal(int sig)
+{
+    send_headers_and_exit(HTTP_REQUEST_TIMEOUT);
+}
+/*
+ * Handle an incoming http request and exit.
+ */
+static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr) ATTRIBUTE_NORETURN;
+static void handle_incoming_and_exit(const len_and_sockaddr *fromAddr)
+{
+    static const char request_GET[] ALIGN1 = "GET";
+    struct stat sb;
+    char *urlcopy;
+    char *urlp;
+    char *tptr;
+    int http_major_version;
+    int ip_allowed;
+#if ENABLE_FEATURE_HTTPD_CGI
+    const char *prequest;
+    unsigned long length = 0;
+    char *cookie = 0;
+    char *content_type = 0;
+#endif
+    struct sigaction sa;
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    int credentials = -1;  /* if not required this is Ok */
+#endif
+    /* Allocation of iobuf is postponed until now
+     * (IOW, server process doesn't need to waste 8k) */
+    iobuf = xmalloc(IOBUF_SIZE);
+    rmt_ip = 0;
+    if (fromAddr->sa.sa_family == AF_INET) {
+        rmt_ip = ntohl(fromAddr->sin.sin_addr.s_addr);
+    }
+#if ENABLE_FEATURE_IPV6
+    if (fromAddr->sa.sa_family == AF_INET6
+     && fromAddr->sin6.sin6_addr.s6_addr32[0] == 0
+     && fromAddr->sin6.sin6_addr.s6_addr32[1] == 0
+     && ntohl(fromAddr->sin6.sin6_addr.s6_addr32[2]) == 0xffff)
+        rmt_ip = ntohl(fromAddr->sin6.sin6_addr.s6_addr32[3]);
+#endif
+    if (ENABLE_FEATURE_HTTPD_CGI || DEBUG || verbose) {
+        rmt_ip_str = xmalloc_sockaddr2dotted(&fromAddr->sa);
+    }
+    if (verbose) {
+        /* this trick makes -v logging much simpler */
+        applet_name = rmt_ip_str;
+        if (verbose > 2)
+            bb_error_msg("connected");
+    }
+    /* Install timeout handler */
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = exit_on_signal;
+    /* sigemptyset(&sa.sa_mask); - memset should be enough */
+    /*sa.sa_flags = 0; - no SA_RESTART */
+    sigaction(SIGALRM, &sa, NULL);
+    alarm(HEADER_READ_TIMEOUT);
+    if (!get_line()) /* EOF or error or empty line */
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    /* Determine type of request (GET/POST) */
+    urlp = strpbrk(iobuf, " \t");
+    if (urlp == NULL)
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    *urlp++ = '\0';
+#if ENABLE_FEATURE_HTTPD_CGI
+    prequest = request_GET;
+    if (strcasecmp(iobuf, prequest) != 0) {
+        prequest = "POST";
+        if (strcasecmp(iobuf, prequest) != 0)
+            send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+    }
 #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) {
+          bb_full_write(s, "HTTP/1.0 200 OK\r\n", 17);
+        }
+        if (strstr(rbuf, "ontent-") == 0) {
+          bb_full_write(s, "Content-type: text/plain\r\n\r\n", 28);
+        }
+        firstLine = 0;
+      }
+      if (bb_full_write(s, rbuf, count) != count)
+          break;
+#if DEBUG
+      fprintf(stderr, "cgi read %d bytes\n", count);
+#endif
+    }
+      }
+    }
+  }
+  return 0;
+}
+#endif          /* CONFIG_FEATURE_HTTPD_CGI */
+/****************************************************************************
+ *
+ > $Function: sendFile()
+ *
+ * $Description: Send a file response to an 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->httpd_found.found_mime_type = *(table+1);
+#ifdef CONFIG_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->httpd_found.found_mime_type = cur->after_colon;
+        break;
+    }
+    }
+  }
+#endif  /* CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES */
+#if DEBUG
+  fprintf(stderr, "Sending file '%s' Content-type: %s\n",
+            url, config->httpd_found.found_mime_type);
+#endif
+  f = open(url, O_RDONLY);
+  if (f >= 0) {
+    int count;
+    char *buf = config->buf;
+    sendHeaders(HTTP_OK);
+    while ((count = bb_full_read(f, buf, MAX_MEMORY_BUFF)) > 0) {
+        if (bb_full_write(a_c_w, buf, count) != count)
+            break;
+    }
+    close(f);
+  } else {
+#if DEBUG
+    bb_perror_msg("Unable to open '%s'", url);
+#endif
+    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);
+    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);
+#endif
+    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.
+ *
+ ****************************************************************************/
+#ifdef CONFIG_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) {
+    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);
+#endif
+    if (strcasecmp(iobuf, request_GET) != 0)
+        send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+#endif
+    urlp = skip_whitespace(urlp);
+    if (urlp[0] != '/')
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    /* Find end of URL and parse HTTP version, if any */
+    http_major_version = -1;
+    tptr = strchrnul(urlp, ' ');
+    /* Is it " HTTP/"? */
+    if (tptr[0] && strncmp(tptr + 1, HTTP_200, 5) == 0)
+        http_major_version = (tptr[6] - '0');
+    *tptr = '\0';
+    /* Copy URL from after "GET "/"POST " to stack-allocated char[] */
+    urlcopy = alloca((tptr - urlp) + sizeof("/index.html"));
+    /*if (urlcopy == NULL)
+     *  send_headers_and_exit(HTTP_INTERNAL_SERVER_ERROR);*/
+    strcpy(urlcopy, urlp);
+    /* NB: urlcopy ptr is never changed after this */
+    /* Extract url args if present */
+    tptr = strchr(urlcopy, '?');
+    g_query = NULL;
+    if (tptr) {
+        *tptr++ = '\0';
+        g_query = tptr;
+    }
+    /* Decode URL escape sequences */
+    tptr = decodeString(urlcopy, 0);
+    if (tptr == NULL)
+        send_headers_and_exit(HTTP_BAD_REQUEST);
+    if (tptr == urlcopy + 1) {
+        /* '/' or NUL is encoded */
+        send_headers_and_exit(HTTP_NOT_FOUND);
+    }
+    /* Canonicalize path */
+    /* Algorithm stolen from libbb bb_simplify_path(),
+     * but don't strdup and reducing trailing slash and protect out root */
+    urlp = tptr = urlcopy;
+    do {
+        if (*urlp == '/') {
+            /* skip duplicate (or initial) slash */
+            if (*tptr == '/') {
+                continue;
+            }
+            if (*tptr == '.') {
+                /* skip extra '.' */
+                if (tptr[1] == '/' || !tptr[1]) {
+                    continue;
+                }
+                /* '..': be careful */
+                if (tptr[1] == '.' && (tptr[2] == '/' || !tptr[2])) {
+                    ++tptr;
+                    if (urlp == urlcopy) /* protect root */
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                    while (*--urlp != '/') /* omit previous dir */;
+                        continue;
+                }
+            }
+        }
+        *++urlp = *tptr;
+    } while (*++tptr);
+    *++urlp = '\0';       /* so keep last character */
+    tptr = urlp;          /* end ptr */
+    /* If URL is a directory, add '/' */
+    if (tptr[-1] != '/') {
+        if (is_directory(urlcopy + 1, 1, &sb)) {
+            found_moved_temporarily = urlcopy;
+        }
+    }
+    /* Log it */
+    if (verbose > 1)
+        bb_error_msg("url:%s", urlcopy);
+    tptr = urlcopy;
+    ip_allowed = checkPermIP();
+    while (ip_allowed && (tptr = strchr(tptr + 1, '/')) != NULL) {
+        /* have path1/path2 */
+        *tptr = '\0';
+        if (is_directory(urlcopy + 1, 1, &sb)) {
+            /* may be having subdir config */
+            parse_conf(urlcopy + 1, SUBDIR_PARSE);
+            ip_allowed = checkPermIP();
+        }
+        *tptr = '/';
+    }
+    if (http_major_version >= 0) {
+        /* Request was with "... HTTP/nXXX", and n >= 0 */
+        /* Read until blank line for HTTP version specified, else parse immediate */
+        while (1) {
+            alarm(HEADER_READ_TIMEOUT);
+            if (!get_line())
+                break; /* EOF or error or empty line */
+            if (DEBUG)
+                bb_error_msg("header: '%s'", iobuf);
+#if ENABLE_FEATURE_HTTPD_CGI
+            /* try and do our best to parse more lines */
+            if ((STRNCASECMP(iobuf, "Content-length:") == 0)) {
+                /* extra read only for POST */
+                if (prequest != request_GET) {
+                    tptr = iobuf + sizeof("Content-length:") - 1;
+                    if (!tptr[0])
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                    errno = 0;
+                    /* not using strtoul: it ignores leading minus! */
+                    length = strtol(tptr, &tptr, 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 (tptr[0] || errno || length > INT_MAX)
+                        send_headers_and_exit(HTTP_BAD_REQUEST);
+                }
+            } else if (STRNCASECMP(iobuf, "Cookie:") == 0) {
+                cookie = strdup(skip_whitespace(iobuf + sizeof("Cookie:")-1));
+            } else if (STRNCASECMP(iobuf, "Content-Type:") == 0) {
+                content_type = strdup(skip_whitespace(iobuf + sizeof("Content-Type:")-1));
+            } else if (STRNCASECMP(iobuf, "Referer:") == 0) {
+                referer = strdup(skip_whitespace(iobuf + sizeof("Referer:")-1));
+            } else if (STRNCASECMP(iobuf, "User-Agent:") == 0) {
+                user_agent = strdup(skip_whitespace(iobuf + sizeof("User-Agent:")-1));
+            }
+#endif
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+            if (STRNCASECMP(iobuf, "Authorization:") == 0) {
+                /* We only allow Basic credentials.
+                 * It shows up as "Authorization: Basic <userid:password>" where
+                 * the userid:password is base64 encoded.
+                 */
+                tptr = skip_whitespace(iobuf + sizeof("Authorization:")-1);
+                if (STRNCASECMP(tptr, "Basic") != 0)
+                    continue;
+                tptr += sizeof("Basic")-1;
+                /* decodeBase64() skips whitespace itself */
+                decodeBase64(tptr);
+                credentials = checkPerm(urlcopy, tptr);
+            }
+#endif          /* FEATURE_HTTPD_BASIC_AUTH */
+        } /* while extra header reading */
+    }
+    /* We read headers, disable peer timeout */
+    alarm(0);
+    if (strcmp(bb_basename(urlcopy), httpd_conf) == 0 || ip_allowed == 0) {
+        /* protect listing [/path]/httpd_conf or IP deny */
+        send_headers_and_exit(HTTP_FORBIDDEN);
+    }
+#if ENABLE_FEATURE_HTTPD_BASIC_AUTH
+    if (credentials <= 0 && checkPerm(urlcopy, ":") == 0) {
+        send_headers_and_exit(HTTP_UNAUTHORIZED);
+    }
+#endif
+    if (found_moved_temporarily) {
+        send_headers_and_exit(HTTP_MOVED_TEMPORARILY);
+    }
+    tptr = urlcopy + 1;      /* skip first '/' */
+#if ENABLE_FEATURE_HTTPD_CGI
+    if (strncmp(tptr, "cgi-bin/", 8) == 0) {
+        if (tptr[8] == '\0') {
+            /* protect listing "cgi-bin/" */
+            send_headers_and_exit(HTTP_FORBIDDEN);
+        }
+        send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
+    }
+#if ENABLE_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR
+    {
+        size_t 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;
+            }
+#ifdef CONFIG_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;
+            }
+        }
+#endif
+        if (strcmp(p, request) == 0) {
+#ifdef CONFIG_FEATURE_HTTPD_AUTH_MD5
+set_remoteuser_var:
+#endif
+            config->remoteuser = strdup(request);
+            if(config->remoteuser)
+            config->remoteuser[(u - request)] = 0;
+            return 1;   /* Ok */
+        }
+        /* unauthorized */
+        }
+    }
+    }   /* for */
+    return prev == NULL;
+}
+#endif  /* CONFIG_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;
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+  const char *prequest = request_GET;
+  long length=0;
+  char *cookie = 0;
+  char *content_type = 0;
+#endif
+  fd_set s_fd;
+  struct timeval tv;
+  int retval;
+  struct sigaction sa;
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+  int credentials = -1;  /* if not requred 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;
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+    if(strcasecmp(buf, prequest) != 0) {
+    prequest = "POST";
+    if(strcasecmp(buf, prequest) != 0) {
+        sendHeaders(HTTP_NOT_IMPLEMENTED);
+        break;
+    }
+    }
+        char *suffix = strrchr(tptr, '.');
+        if (suffix) {
+            Htaccess *cur;
+            for (cur = script_i; cur; cur = cur->next) {
+                if (strcmp(cur->before_colon + 1, suffix) == 0) {
+                    send_cgi_and_exit(urlcopy, prequest, length, cookie, content_type);
+                }
+            }
+        }
+    }
+#endif
+    if (prequest != request_GET) {
+        send_headers_and_exit(HTTP_NOT_IMPLEMENTED);
+    }
+#endif  /* FEATURE_HTTPD_CGI */
+    if (urlp[-1] == '/')
+        strcpy(urlp, "index.html");
+    if (stat(tptr, &sb) == 0) {
+        /* It's a dir URL and there is index.html */
+        ContentLength = sb.st_size;
+        last_mod = sb.st_mtime;
+    }
+#if ENABLE_FEATURE_HTTPD_CGI
+    else if (urlp[-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) {
+            urlp[0] = '\0';
+            g_query = urlcopy;
+            send_cgi_and_exit("/cgi-bin/index.cgi", prequest, length, cookie, content_type);
+        }
+    }
+#endif
+    /* else {
+     *  fall through to send_file, it errors out if open fails
+     * }
+     */
+    send_file_and_exit(tptr, TRUE);
+}
+/*
+ * The main http server function.
+ * Given a socket, listen for new connections and farm out
+ * the processing as a [v]forked process.
+ * Never returns.
+ */
+#if BB_MMU
+static void mini_httpd(int server_socket) ATTRIBUTE_NORETURN;
+static void mini_httpd(int server_socket)
+{
+    /* NB: it's best to not use xfuncs in this loop before fork().
+     * Otherwise server may die on transient errors (temporary
+     * out-of-memory condition, etc), which is Bad(tm).
+     * Try to do any dangerous calls after fork.
+     */
+    while (1) {
+        int n;
+        len_and_sockaddr fromAddr;
+        /* Wait for connections... */
+        fromAddr.len = LSA_SIZEOF_SA;
+        n = accept(server_socket, &fromAddr.sa, &fromAddr.len);
+        if (n < 0)
+            continue;
+        /* set the KEEPALIVE option to cull dead connections */
+        setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+        if (fork() == 0) {
+            /* child */
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+            /* Do not reload config on HUP */
+            signal(SIGHUP, SIG_IGN);
+#endif
+            close(server_socket);
+            xmove_fd(n, 0);
+            xdup2(0, 1);
+            handle_incoming_and_exit(&fromAddr);
+        }
+        /* parent, or fork failed */
+        close(n);
+    } /* while (1) */
+    /* never reached */
+}
 #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) + 12);      /* + sizeof("/index.html\0") */
+    if(url == NULL) {
+    sendHeaders(HTTP_INTERNAL_SERVER_ERROR);
+    break;
+    }
+    strcpy(url, buf);
+    /* extract url args if present */
+    test = strchr(url, '?');
+    if (test) {
+      *test++ = 0;
+      config->query = test;
+    }
+    test = decodeString(url, 0);
+    if(test == NULL)
+    goto BAD_REQUEST;
+    if(test == (buf+1)) {
+    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 == '/') {
+        if (*test == '/') {        /* skip duplicate (or initial) slash */
+        continue;
+        } else if (*test == '.') {
+        if (test[1] == '/' || test[1] == 0) { /* skip extra '.' */
+            continue;
+        } else 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->httpd_found.found_moved_temporarily = url;
+        }
+    }
+#if DEBUG
+    fprintf(stderr, "url='%s', args=%s\n", url, config->query);
+#endif
+    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);
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+    /* try and do our best to parse more lines */
+    if ((strncasecmp(buf, Content_length, 15) == 0)) {
+      if(prequest != request_GET)
+          length = strtol(buf + 15, 0, 0); // extra read only for POST
+    } else if ((strncasecmp(buf, "Cookie:", 7) == 0)) {
+          for(test = buf + 7; isspace(*test); test++)
+              ;
+          cookie = strdup(test);
+    } else if ((strncasecmp(buf, "Content-Type:", 13) == 0)) {
+          for(test = buf + 13; isspace(*test); test++)
+              ;
+          content_type = strdup(test);
+    } else if ((strncasecmp(buf, "Referer:", 8) == 0)) {
+          for(test = buf + 8; isspace(*test); test++)
+              ;
+          config->referer = strdup(test);
+    }
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+    if (strncasecmp(buf, "Authorization:", 14) == 0) {
+      /* We only allow Basic credentials.
+       * It shows up as "Authorization: Basic <userid:password>" where
+       * the userid:password is base64 encoded.
+       */
+      for(test = buf + 14; isspace(*test); test++)
+          ;
+      if (strncasecmp(test, "Basic", 5) != 0)
+          continue;
+      test += 5;  /* decodeBase64() skiping space self */
+      decodeBase64(test);
+      credentials = checkPerm(url, test);
+    }
+#endif          /* CONFIG_FEATURE_HTTPD_BASIC_AUTH */
+      }   /* while extra header reading */
+    }
+    (void) 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 */
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+FORBIDDEN:      /* protect listing /cgi-bin */
+#endif
+        sendHeaders(HTTP_FORBIDDEN);
+        break;
+    }
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+    if (credentials <= 0 && checkPerm(url, ":") == 0) {
+      sendHeaders(HTTP_UNAUTHORIZED);
+      break;
+    }
+#endif
+    if(config->httpd_found.found_moved_temporarily) {
+    sendHeaders(HTTP_MOVED_TEMPORARILY);
+#if DEBUG
+    /* clear unforked memory flag */
+    config->httpd_found.found_moved_temporarily = NULL;
+#endif
+    break;
+    }
+    test = url + 1;      /* skip first '/' */
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+    /* if strange Content-Length */
+    if (length < 0)
+    break;
+    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);
+    } else {
+    if (prequest != request_GET)
+        sendHeaders(HTTP_NOT_IMPLEMENTED);
+    else {
+#endif  /* CONFIG_FEATURE_HTTPD_CGI */
+        if(purl[-1] == '/')
+            strcpy(purl, "index.html");
+        if ( stat(test, &sb ) == 0 ) {
+            config->ContentLength = sb.st_size;
+            config->last_mod = sb.st_mtime;
+        }
+        sendFile(test);
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+        /* unset if non inetd looped */
+        config->ContentLength = -1;
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+    }
+    }
+#endif
+  } while (0);
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+/* from inetd don`t looping: freeing, closing automatic from exit always */
+# if DEBUG
+  fprintf(stderr, "closing socket\n");
+# endif
+# ifdef CONFIG_FEATURE_HTTPD_CGI
+  free(cookie);
+  free(content_type);
+  free(config->referer);
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+  free(config->remoteuser);
+#endif
+# endif
+#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
+  shutdown(a_c_w, SHUT_WR);
+  /* Properly wait for remote to closed */
+  FD_ZERO (&s_fd) ;
+  FD_SET (a_c_r, &s_fd) ;
+  do {
+    tv.tv_sec = 2 ;
+    tv.tv_usec = 0 ;
+    retval = select (a_c_r + 1, &s_fd, NULL, NULL, &tv);
+  } while (retval > 0 && (read (a_c_r, buf, sizeof (config->buf)) > 0));
+  shutdown(a_c_r, SHUT_RD);
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+  close(config->accepted_socket);
+#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
+}
+/****************************************************************************
+ *
+ > $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.
+ *
+ ****************************************************************************/
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+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) {
+    readfd = portfd;
+    /* Now wait INDEFINITELY on the set of sockets! */
+    if (select(server + 1, &readfd, 0, 0, 0) > 0) {
+      if (FD_ISSET(server, &readfd)) {
+    int on;
+    struct sockaddr_in fromAddr;
+    socklen_t fromAddrLen = sizeof(fromAddr);
+    int 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 defined(CONFIG_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\n",
+                    config->rmt_ip_str, config->port);
+#endif
+#endif /* CONFIG_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
+    if (fork() == 0)
+#endif
+    {
+        /* This is the spawned thread */
+#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+        /* protect reload config, may be confuse checking */
+        signal(SIGHUP, SIG_IGN);
+#endif
+        handleIncoming();
+#if !DEBUG
+        exit(0);
+#endif
+    }
+    close(s);
+      }
+    }
+  } // while (1)
+  return 0;
+}
+#else
+    /* from inetd */
+static int miniHttpd(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);
+#ifdef CONFIG_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;
+}
+#endif  /* CONFIG_FEATURE_HTTPD_WITHOUT_INETD */
+#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+static void mini_httpd_nommu(int server_socket, int argc, char **argv) ATTRIBUTE_NORETURN;
+static void mini_httpd_nommu(int server_socket, int argc, char **argv)
+{
+    char *argv_copy[argc + 2];
+    argv_copy[0] = argv[0];
+    argv_copy[1] = (char*)"-i";
+    memcpy(&argv_copy[2], &argv[1], argc * sizeof(argv[0]));
+    /* NB: it's best to not use xfuncs in this loop before vfork().
+     * Otherwise server may die on transient errors (temporary
+     * out-of-memory condition, etc), which is Bad(tm).
+     * Try to do any dangerous calls after fork.
+     */
+    while (1) {
+        int n;
+        len_and_sockaddr fromAddr;
+        /* Wait for connections... */
+        fromAddr.len = LSA_SIZEOF_SA;
+        n = accept(server_socket, &fromAddr.sa, &fromAddr.len);
+        if (n < 0)
+            continue;
+        /* set the KEEPALIVE option to cull dead connections */
+        setsockopt(n, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
+        if (vfork() == 0) {
+            /* child */
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+            /* Do not reload config on HUP */
+            signal(SIGHUP, SIG_IGN);
+#endif
+            close(server_socket);
+            xmove_fd(n, 0);
+            xdup2(0, 1);
+            /* Run a copy of ourself in inetd mode */
+            re_exec(argv_copy);
+        }
+        /* parent, or vfork failed */
+        close(n);
+    } /* while (1) */
+    /* never reached */
+}
+#endif
+/*
+ * Process a HTTP connection on stdin/out.
+ * Never returns.
+ */
+static void mini_httpd_inetd(void) ATTRIBUTE_NORETURN;
+static void mini_httpd_inetd(void)
+{
+    len_and_sockaddr fromAddr;
+    fromAddr.len = LSA_SIZEOF_SA;
+    getpeername(0, &fromAddr.sa, &fromAddr.len);
+    handle_incoming_and_exit(&fromAddr);
+}
+#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);
+    parse_conf(default_path_httpd_conf, sig == SIGHUP ? SIGNALED_PARSE : FIRST_PARSE);
+    memset(&sa, 0, sizeof(sa));
     sa.sa_handler = sighup_handler;
     sigemptyset(&sa.sa_mask);
+    /*sigemptyset(&sa.sa_mask); - memset should be enough */
     sa.sa_flags = SA_RESTART;
     sigaction(SIGHUP, &sa, NULL);
 …
 #endif
 enum httpd_opts_nums {
+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,)
+    USE_FEATURE_HTTPD_WITHOUT_INETD(p_opt_port,)
+    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,
+    p_opt_verbose   ,
+    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,
+    OPT_VERBOSE     = 1 << p_opt_verbose,
 };
+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:")
+    USE_FEATURE_HTTPD_WITHOUT_INETD("p:");
+#define OPT_CONFIG_FILE (1<<c_opt_config_file)
+#define OPT_DECODE_URL  (1<<d_opt_decode_url)
+#define OPT_HOME_HTTPD  (1<<h_opt_home_httpd)
+#define OPT_ENCODE_URL  USE_FEATURE_HTTPD_ENCODE_URL_STR((1<<e_opt_encode_url)) \
+            SKIP_FEATURE_HTTPD_ENCODE_URL_STR(0)
+#define OPT_REALM       USE_FEATURE_HTTPD_BASIC_AUTH((1<<r_opt_realm)) \
+            SKIP_FEATURE_HTTPD_BASIC_AUTH(0)
+#define OPT_MD5         USE_FEATURE_HTTPD_AUTH_MD5((1<<m_opt_md5)) \
+            SKIP_FEATURE_HTTPD_AUTH_MD5(0)
+#define OPT_SETUID      USE_FEATURE_HTTPD_SETUID((1<<u_opt_setuid)) \
+            SKIP_FEATURE_HTTPD_SETUID(0)
+#define OPT_PORT        USE_FEATURE_HTTPD_WITHOUT_INETD((1<<p_opt_port)) \
+            SKIP_FEATURE_HTTPD_WITHOUT_INETD(0)
+int httpd_main(int argc, char *argv[])
+{
+  unsigned long opt;
+  const char *home_httpd = home;
+  char *url_for_decode;
+  USE_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
+  USE_FEATURE_HTTPD_WITHOUT_INETD(const char *s_port;)
+  USE_FEATURE_HTTPD_WITHOUT_INETD(int server;)
+  USE_FEATURE_HTTPD_SETUID(const char *s_uid;)
+  USE_FEATURE_HTTPD_SETUID(long uid = -1;)
+  USE_FEATURE_HTTPD_AUTH_MD5(const char *pass;)
+  config = xcalloc(1, sizeof(*config));
+#ifdef CONFIG_FEATURE_HTTPD_BASIC_AUTH
+  config->realm = "Web Server Authentication";
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+  config->port = 80;
+#endif
+  config->ContentLength = -1;
+  opt = bb_getopt_ulflags(argc, argv, httpd_opts,
+            &(config->configFile), &url_for_decode, &home_httpd
+int httpd_main(int argc, char **argv);
+int httpd_main(int argc, char **argv)
+{
+    int server_socket = server_socket; /* for gcc */
+    unsigned opt;
+    char *url_for_decode;
+    USE_FEATURE_HTTPD_ENCODE_URL_STR(const char *url_for_encode;)
+    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;)
+    INIT_G();
+#if ENABLE_LOCALE_SUPPORT
+    /* Undo busybox.c: we want to speak English in http (dates etc) */
+    setlocale(LC_TIME, "C");
+#endif
+    home_httpd = xrealloc_getcwd_or_warn(NULL);
+    /* -v counts, -i implies -f */
+    opt_complementary = "vv:if";
+    /* We do not "absolutize" path given by -h (home) opt.
+     * If user gives relative path in -h, $SCRIPT_FILENAME can end up
+     * relative too. */
+    opt = getopt32(argv, "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:ifv",
+            &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_BASIC_AUTH(, &g_realm)
             USE_FEATURE_HTTPD_AUTH_MD5(, &pass)
+            USE_FEATURE_HTTPD_SETUID(, &s_uid)
+            USE_FEATURE_HTTPD_WITHOUT_INETD(, &s_port)
+    );
+  if(opt & OPT_DECODE_URL) {
+      printf("%s", decodeString(url_for_decode, 1));
+      return 0;
+  }
+#ifdef CONFIG_FEATURE_HTTPD_ENCODE_URL_STR
+  if(opt & OPT_ENCODE_URL) {
+      printf("%s", encodeString(url_for_encode));
+      return 0;
+  }
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_AUTH_MD5
+  if(opt & OPT_MD5) {
+      printf("%s\n", pw_encrypt(pass, "$1$"));
+      return 0;
+  }
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+    if(opt & OPT_PORT)
+    config->port = bb_xgetlarg(s_port, 10, 1, 0xffff);
+#ifdef CONFIG_FEATURE_HTTPD_SETUID
+    if(opt & OPT_SETUID) {
+    char *e;
+    uid = strtol(s_uid, &e, 0);
+    if(*e != '\0') {
+        /* not integer */
+        uid = bb_xgetpwnam(s_uid);
+    }
+      }
+#endif
+#endif
+  bb_xchdir(home_httpd);
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+  server = openServer();
+# ifdef CONFIG_FEATURE_HTTPD_SETUID
+  /* drop privileges */
+  if(uid > 0)
+    setuid(uid);
+# endif
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_CGI
+   {
+    char *p = getenv("PATH");
+    if(p) {
+        p = bb_xstrdup(p);
+    }
+    clearenv();
+    if(p)
+        setenv("PATH", p, 1);
+# ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+    addEnvPort("SERVER");
+# endif
+   }
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+  sighup_handler(0);
+            USE_FEATURE_HTTPD_SETUID(, &s_ugid)
+            , &bind_addr_or_port
+            , &verbose
+        );
+    if (opt & OPT_DECODE_URL) {
+        fputs(decodeString(url_for_decode, 1), stdout);
+        return 0;
+    }
+#if ENABLE_FEATURE_HTTPD_ENCODE_URL_STR
+    if (opt & OPT_ENCODE_URL) {
+        fputs(encodeString(url_for_encode), stdout);
+        return 0;
+    }
+#endif
+#if ENABLE_FEATURE_HTTPD_AUTH_MD5
+    if (opt & OPT_MD5) {
+        puts(pw_encrypt(pass, "$1$"));
+        return 0;
+    }
+#endif
+#if ENABLE_FEATURE_HTTPD_SETUID
+    if (opt & OPT_SETUID) {
+        if (!get_uidgid(&ugid, s_ugid, 1))
+            bb_error_msg_and_die("unrecognized user[:group] "
+                        "name '%s'", s_ugid);
+    }
+#endif
+#if !BB_MMU
+    if (!(opt & OPT_FOREGROUND)) {
+        bb_daemonize_or_rexec(0, argv); /* don't change current directory */
+    }
+#endif
+    xchdir(home_httpd);
+    if (!(opt & OPT_INETD)) {
+        signal(SIGCHLD, SIG_IGN);
+        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");
+        /* env strings themself are not freed, no need to strdup(p): */
+        clearenv();
+        if (p)
+            putenv(p - 5);
+//      if (!(opt & OPT_INETD))
+//          setenv_long("SERVER_PORT", ???);
+    }
+#endif
+#if ENABLE_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP
+    if (!(opt & OPT_INETD))
+        sighup_handler(0);
+    else /* do not install HUP handler in inetd mode */
+#endif
+        parse_conf(default_path_httpd_conf, FIRST_PARSE);
+    xfunc_error_retval = 0;
+    if (opt & OPT_INETD)
+        mini_httpd_inetd();
+#if BB_MMU
+    if (!(opt & OPT_FOREGROUND))
+        bb_daemonize(0); /* don't change current directory */
+    mini_httpd(server_socket); /* never returns */
 #else
+  parse_conf(default_path_httpd_conf, FIRST_PARSE);
+#endif
+#ifdef CONFIG_FEATURE_HTTPD_WITHOUT_INETD
+# if !DEBUG
+  bb_xdaemon(1, 0);     /* don`t change curent directory */
+# endif
+  return miniHttpd(server);
+#else
+  return miniHttpd();
+#endif
+}
+    mini_httpd_nommu(server_socket, argc, argv); /* never returns */
+#endif
+    /* return 0; */
+}

branches/stable/mindi-busybox/networking/ifconfig.c

-              r821
+              r1770
  */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>     /* strcmp and friends */
-#include <ctype.h>      /* isdigit and friends */
-#include <stddef.h>     /* offsetof */
-#include <unistd.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <netinet/in.h>
 #if __GLIBC__ >=2 && __GLIBC_MINOR >= 1
+#if defined(__GLIBC__) && __GLIBC__ >=2 && __GLIBC_MINOR__ >= 1
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 …
 #endif
 #include "inet_common.h"
 #include "busybox.h"
 #ifdef CONFIG_FEATURE_IFCONFIG_SLIP
+#include "libbb.h"
+#if ENABLE_FEATURE_IFCONFIG_SLIP
 # include <net/if_slip.h>
 #endif
 …
 #endif
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
 struct in6_ifreq {
     struct in6_addr ifr6_addr;
 …
 #define A_SET_AFTER      0x40   /* Set a flag at the end. */
 #define A_COLON_CHK      0x80   /* Is this needed?  See below. */
 #ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+#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. */
 …
 struct options {
     const char *name;
 #ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
     const unsigned int flags:6;
     const unsigned int arg_flags:10;
 …
     {"SIOCSIFNETMASK", SIOCSIFNETMASK, ifreq_offsetof(ifr_netmask)},
     {"SIOCSIFBRDADDR", SIOCSIFBRDADDR, ifreq_offsetof(ifr_broadaddr)},
 #ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
     {"SIOCSIFHWADDR",  SIOCSIFHWADDR,  ifreq_offsetof(ifr_hwaddr)},
 #endif
 …
     {"SIOCSOUTFILL",   SIOCSOUTFILL,   ifreq_offsetof(ifr_data)},
 #endif
 #ifdef CONFIG_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+#if ENABLE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
     {"SIOCSIFMAP",     SIOCSIFMAP,     ifreq_offsetof(ifr_map.mem_start)},
     {"SIOCSIFMAP",     SIOCSIFMAP,     ifreq_offsetof(ifr_map.base_addr)},
 …
 #endif
     /* Last entry if for unmatched (possibly hostname) arg. */
 #ifdef CONFIG_FEATURE_IPV6
+#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 */
 …
     {"netmask",     N_ARG,         ARG_NETMASK,     0},
     {"broadcast",   N_ARG | M_CLR, ARG_BROADCAST,   IFF_BROADCAST},
 #ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
     {"hw",          N_ARG, ARG_HW,                  0},
 #endif
 …
     {"outfill",     N_ARG,         ARG_OUTFILL,     0},
 #endif
 #ifdef CONFIG_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+#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
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     {"add",         N_ARG,         ARG_ADD_DEL,     0},
     {"del",         N_ARG,         ARG_ADD_DEL,     0},
 …
  */
+#ifdef CONFIG_FEATURE_IFCONFIG_HW
+static int in_ether(char *bufp, struct sockaddr *sap);
+#endif
+#ifdef CONFIG_FEATURE_IFCONFIG_STATUS
+extern int interface_opt_a;
+extern int display_interfaces(char *ifname);
+#if ENABLE_FEATURE_IFCONFIG_HW
+static int in_ether(const char *bufp, struct sockaddr *sap);
 #endif
 …
  */
+int ifconfig_main(int argc, char **argv);
 int ifconfig_main(int argc, char **argv)
+{
     struct ifreq ifr;
     struct sockaddr_in sai;
+#ifdef CONFIG_FEATURE_IPV6
+    struct sockaddr_in6 sai6;
+#endif
+#ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
     struct sockaddr sa;
 #endif
 …
     const struct options *op;
     int sockfd;         /* socket fd we use to manipulate stuff with */
-    int goterr;
     int selector;
 #ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
     unsigned int mask;
     unsigned int did_flags;
 …
 #endif
     char *p;
     char host[128];
+    goterr = 0;
+    /*char host[128];*/
+    const char *host = NULL; /* make gcc happy */
     did_flags = 0;
 #ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
     sai_hostname = 0;
     sai_netmask = 0;
 …
     --argc;
 #ifdef CONFIG_FEATURE_IFCONFIG_STATUS
     if ((argc > 0) && (((*argv)[0] == '-') && ((*argv)[1] == 'a') && !(*argv)[2])) {
+#if ENABLE_FEATURE_IFCONFIG_STATUS
+    if (argc > 0 && (argv[0][0] == '-' && argv[0][1] == 'a' && !argv[0][2])) {
         interface_opt_a = 1;
         --argc;
 …
     if (argc <= 1) {
 #ifdef CONFIG_FEATURE_IFCONFIG_STATUS
+#if ENABLE_FEATURE_IFCONFIG_STATUS
         return display_interfaces(argc ? *argv : NULL);
 #else
+        bb_error_msg_and_die
+            ("ifconfig was not compiled with interface status display support.");
+        bb_error_msg_and_die("no support for status display");
 #endif
+    }
     /* Create a channel to the NET kernel. */
     sockfd = bb_xsocket(AF_INET, SOCK_DGRAM, 0);
+    sockfd = xsocket(AF_INET, SOCK_DGRAM, 0);
     /* get interface name */
 …
         for (op = OptArray; op->name; op++) {   /* Find table entry. */
             if (strcmp(p, op->name) == 0) { /* If name matches... */
+                if ((mask &= op->flags)) {  /* set the mask and go. */
+                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. */
+                ++goterr;
+                goto LOOP;
+                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;
+        a1op = Arg1Opt + ARRAY_SIZE(Arg1Opt) - 1;
         mask = op->arg_flags;
         goto HOSTNAME;
       FOUND_ARG:
+ FOUND_ARG:
         if (mask & ARG_MASK) {
             mask = op->arg_flags;
             a1op = Arg1Opt + (op - OptArray);
             if (mask & A_NETMASK & did_flags) {
+            if (mask & A_NETMASK & did_flags)
                 bb_show_usage();
+            }
             if (*++argv == NULL) {
                 if (mask & A_ARG_REQ) {
+                if (mask & A_ARG_REQ)
                     bb_show_usage();
+                } else {
+                    --argv;
+                    mask &= A_SET_AFTER;    /* just for broadcast */
+                }
+                --argv;
+                mask &= A_SET_AFTER;    /* just for broadcast */
             } else {    /* got an arg so process it */
               HOSTNAME:
+ HOSTNAME:
                 did_flags |= (mask & (A_NETMASK|A_HOSTNAME));
                 if (mask & A_CAST_HOST_COPY) {
 #ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
                     if (mask & A_CAST_RESOLVE) {
 #endif
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
                         char *prefix;
                         int prefix_len = 0;
 #endif
+                        safe_strncpy(host, *argv, (sizeof host));
+#ifdef CONFIG_FEATURE_IPV6
+                        if ((prefix = strchr(host, '/'))) {
+                            if (safe_strtoi(prefix + 1, &prefix_len) ||
+                                (prefix_len < 0) || (prefix_len > 128))
+                            {
+                                ++goterr;
+                                goto LOOP;
+                            }
+                            *prefix = 0;
+                        /*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_INET_default)) {
+                        if (!strcmp(host, bb_str_default)) {
                             /* Default is special, meaning 0.0.0.0. */
                             sai.sin_addr.s_addr = INADDR_ANY;
+#ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
+                        } else if (((host[0] == '+') && !host[1]) && (mask & A_BROADCAST) &&
+                                   (did_flags & (A_NETMASK|A_HOSTNAME)) == (A_NETMASK|A_HOSTNAME)) {
+                        }
+#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
+#ifdef CONFIG_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. */
+                            if ((sockfd6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
+                                bb_perror_msg_and_die("socket6");
+                            }
+                            if (ioctl(sockfd6, SIOGIFINDEX, &ifr) < 0) {
+                                perror("SIOGIFINDEX");
+                                ++goterr;
+                        }
+#endif
+                        else {
+                            len_and_sockaddr *lsa;
+                            if (strcmp(host, "inet") == 0)
+                                continue; /* compat stuff */
+                            lsa = xhost2sockaddr(host, 0);
+#if ENABLE_FEATURE_IPV6
+                            if (lsa->sa.sa_family == AF_INET6) {
+                                int sockfd6;
+                                struct in6_ifreq ifr6;
+                                memcpy((char *) &ifr6.ifr6_addr,
+                                        (char *) &(lsa->sin6.sin6_addr),
+                                        sizeof(struct in6_addr));
+                                /* Create a channel to the NET kernel. */
+                                sockfd6 = xsocket(AF_INET6, SOCK_DGRAM, 0);
+                                xioctl(sockfd6, SIOGIFINDEX, &ifr);
+                                ifr6.ifr6_ifindex = ifr.ifr_ifindex;
+                                ifr6.ifr6_prefixlen = prefix_len;
+                                ioctl_or_perror_and_die(sockfd6, a1op->selector, &ifr6, "%s", a1op->name);
+                                if (ENABLE_FEATURE_CLEAN_UP)
+                                    free(lsa);
                                 continue;
+                            }
+                            ifr6.ifr6_ifindex = ifr.ifr_ifindex;
+                            ifr6.ifr6_prefixlen = prefix_len;
+                            if (ioctl(sockfd6, a1op->selector, &ifr6) < 0) {
+                                perror(a1op->name);
+                                ++goterr;
+                            }
+                            continue;
+#endif
+                        } else if (inet_aton(host, &sai.sin_addr) == 0) {
+                            /* It's not a dotted quad. */
+                            struct hostent *hp;
+                            if ((hp = gethostbyname(host)) == (struct hostent *)NULL) {
+                                ++goterr;
+                                continue;
+                            }
+                            memcpy((char *) &sai.sin_addr, (char *) hp->h_addr_list[0],
+                            sizeof(struct in_addr));
+#endif
+                            sai.sin_addr = lsa->sin.sin_addr;
+                            if (ENABLE_FEATURE_CLEAN_UP)
+                                free(lsa);
+                        }
 #ifdef CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS
                         if (mask & A_HOSTNAME) {
+#if ENABLE_FEATURE_IFCONFIG_BROADCAST_PLUS
+                        if (mask & A_HOSTNAME)
                             sai_hostname = sai.sin_addr.s_addr;
+                        }
+                        if (mask & A_NETMASK) {
+                        if (mask & A_NETMASK)
                             sai_netmask = sai.sin_addr.s_addr;
+                        }
 #endif
                         p = (char *) &sai;
 #ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
                     } else {    /* A_CAST_HOST_COPY_IN_ETHER */
                         /* This is the "hw" arg case. */
                         if (strcmp("ether", *argv) || (*++argv == NULL)) {
+                        if (strcmp("ether", *argv) || !*++argv)
                             bb_show_usage();
+                        }
+                        safe_strncpy(host, *argv, (sizeof host));
+                        if (in_ether(host, &sa)) {
+                            bb_error_msg("invalid hw-addr %s", host);
+                            ++goterr;
+                            continue;
+                        }
+                        /*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),
+                    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;
+#ifdef CONFIG_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
+                    p = ((char *)&ifr) + a1op->ifr_offset;
+#if ENABLE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ
                     if (mask & A_MAP_TYPE) {
+                        if (ioctl(sockfd, SIOCGIFMAP, &ifr) < 0) {
+                            ++goterr;
+                            continue;
+                        }
+                        if ((mask & A_MAP_UCHAR) == A_MAP_UCHAR) {
+                        xioctl(sockfd, SIOCGIFMAP, &ifr);
+                        if ((mask & A_MAP_UCHAR) == A_MAP_UCHAR)
                             *((unsigned char *) p) = i;
                         } else if (mask & A_MAP_USHORT) {
+                        else if (mask & A_MAP_USHORT)
                             *((unsigned short *) p) = i;
                         } else {
+                        else
                             *((unsigned long *) p) = i;
+                        }
                     } else
 #endif
                     if (mask & A_CAST_CHAR_PTR) {
+                    if (mask & A_CAST_CHAR_PTR)
                         *((caddr_t *) p) = (caddr_t) i;
                     } else {    /* A_CAST_INT */
+                    else    /* A_CAST_INT */
                         *((int *) p) = i;
+                    }
+                }
+                if (ioctl(sockfd, a1op->selector, &ifr) < 0) {
+                    perror(a1op->name);
+                    ++goterr;
+                    continue;
+                }
+                ioctl_or_perror_and_die(sockfd, a1op->selector, &ifr, "%s", 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
+                     * a '-' at the end, since it's deleted already! - Roman
+                     *
                      * Should really use regex.h here, not sure though how well
 …
                     char *ptr;
                     short int found_colon = 0;
+                    for (ptr = ifr.ifr_name; *ptr; ptr++) {
+                        if (*ptr == ':') {
+                    for (ptr = ifr.ifr_name; *ptr; ptr++)
+                        if (*ptr == ':')
                             found_colon++;
+                        }
+                    }
+                    if (found_colon && *(ptr - 1) == '-') {
+                    if (found_colon && ptr[-1] == '-')
                         continue;
+                    }
+                }
 #endif
+            }
             if (!(mask & A_SET_AFTER)) {
+            if (!(mask & A_SET_AFTER))
                 continue;
+            }
             mask = N_SET;
+        }
+        if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
+            perror("SIOCGIFFLAGS");
+            ++goterr;
+        } else {
+            selector = op->selector;
+            if (mask & SET_MASK) {
+                ifr.ifr_flags |= selector;
+            } else {
+                ifr.ifr_flags &= ~selector;
+            }
+            if (ioctl(sockfd, SIOCSIFFLAGS, &ifr) < 0) {
+                perror("SIOCSIFFLAGS");
+                ++goterr;
+            }
+        }
+      LOOP:
+        continue;
+    }                   /* end of while-loop */
+    if (ENABLE_FEATURE_CLEAN_UP) close(sockfd);
+    return goterr;
+        xioctl(sockfd, SIOCGIFFLAGS, &ifr);
+        selector = op->selector;
+        if (mask & SET_MASK)
+            ifr.ifr_flags |= selector;
+        else
+            ifr.ifr_flags &= ~selector;
+        xioctl(sockfd, SIOCSIFFLAGS, &ifr);
+    } /* while () */
+    if (ENABLE_FEATURE_CLEAN_UP)
+        close(sockfd);
+    return 0;
+}
 #ifdef CONFIG_FEATURE_IFCONFIG_HW
+#if ENABLE_FEATURE_IFCONFIG_HW
 /* Input an Ethernet address and convert to binary. */
 static int in_ether(char *bufp, struct sockaddr *sap)
+static int in_ether(const char *bufp, struct sockaddr *sap)
+{
     char *ptr;
 …
     } while (++i < ETH_ALEN);
     return (int) (*bufp);   /* Error if we don't end at end of string. */
+    return *bufp; /* Error if we don't end at end of string. */
+}
 #endif

branches/stable/mindi-busybox/networking/ifupdown.c

-              r821
+              r1770
  *  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.
+ *  To adhere to the FHS, the default state file is /var/run/ifstate
+ *  (defined via CONFIG_IFUPDOWN_IFSTATE_PATH) and can be overridden by build
+ *  configuration.
+ *
  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  */
-/* TODO: standardise execute() return codes to return 0 for success and 1 for failure */
-#include <sys/stat.h>
 #include <sys/utsname.h>
-#include <sys/wait.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
 #include <fnmatch.h>
 #include <getopt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "busybox.h"
+#include "libbb.h"
 #define MAX_OPT_DEPTH 10
 …
 #define EUNBALPER   10000
 #ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+#if ENABLE_FEATURE_IFUPDOWN_MAPPING
 #define MAX_INTERFACE_LENGTH 10
 #endif
+#if 0
+#define debug_noise(fmt, args...) printf(fmt, ## args)
+#else
+#define debug_noise(fmt, args...)
+#endif
+#define debug_noise(args...) /*fprintf(stderr, args)*/
 /* Forward declaration */
 struct interface_defn_t;
+typedef int (execfn)(char *command);
+struct method_t
+{
+    char *name;
+typedef int execfn(char *command);
+struct method_t {
+    const char *name;
     int (*up)(struct interface_defn_t *ifd, execfn *e);
     int (*down)(struct interface_defn_t *ifd, execfn *e);
 };
+struct address_family_t
+{
+    char *name;
+struct address_family_t {
+    const char *name;
     int n_methods;
     struct method_t *method;
+    const struct method_t *method;
 };
+struct mapping_defn_t
+{
+struct mapping_defn_t {
     struct mapping_defn_t *next;
 …
 };
+struct variable_t
+{
+struct variable_t {
     char *name;
     char *value;
 };
+struct interface_defn_t
+{
+    struct address_family_t *address_family;
+    struct method_t *method;
+struct interface_defn_t {
+    const struct address_family_t *address_family;
+    const struct method_t *method;
     char *iface;
 …
 };
+struct interfaces_file_t
+{
+struct interfaces_file_t {
     llist_t *autointerfaces;
     llist_t *ifaces;
 …
 };
+static char no_act = 0;
+static char verbose = 0;
+static char **__myenviron = NULL;
+#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 **my_environ;
+static const char *startup_PATH;
 #if ENABLE_FEATURE_IFUPDOWN_IPV4 || ENABLE_FEATURE_IFUPDOWN_IPV6
+#ifdef CONFIG_FEATURE_IFUPDOWN_IP
+static unsigned int count_bits(unsigned int a)
+{
+    unsigned int 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 int 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;
+    result = count_bits(a);
+    result += count_bits(b);
+    result += count_bits(c);
+    result += count_bits(d);
+    return ((int)result);
+}
+#endif
+static void addstr(char **buf, size_t *len, size_t *pos, char *str, size_t str_length)
+{
+    if (*pos + str_length >= *len) {
+        char *newbuf;
+        newbuf = xrealloc(*buf, *len * 2 + str_length + 1);
+        *buf = newbuf;
+        *len = *len * 2 + str_length + 1;
+    }
+    while (str_length-- >= 1) {
+        (*buf)[(*pos)++] = *str;
+        str++;
+    }
+    (*buf)[*pos] = '\0';
+}
+static int strncmpz(char *l, char *r, size_t llen)
+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]);
+    } else {
+        return(i);
+    }
+}
+static char *get_var(char *id, size_t idlen, struct interface_defn_t *ifd)
+    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;
 …
         char *result;
         static char label_buf[20];
+        strncpy(label_buf, ifd->iface, 19);
+        label_buf[19]=0;
+        safe_strncpy(label_buf, ifd->iface, sizeof(label_buf));
         result = strchr(label_buf, ':');
         if (result) {
+            *result=0;
+        }
+        return( label_buf);
+    } else if (strncmpz(id, "label", idlen) == 0) {
+        return (ifd->iface);
+    } else {
+        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(char *command, struct interface_defn_t *ifd)
+{
+    char *result = NULL;
+    size_t pos = 0, len = 0;
+            *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;
+}
+#if ENABLE_FEATURE_IFUPDOWN_IP
+static int count_netmask_bits(const char *dotted_quad)
+{
+//  int result;
+//  unsigned 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;
+//  if ((a|b|c|d) >> 8)
+//      return -1; /* one of numbers is >= 256 */
+//  d |= (a << 24) | (b << 16) | (c << 8); /* IP */
+//  d = ~d; /* 11110000 -> 00001111 */
+    /* Shorter version */
+    int result;
+    struct in_addr ip;
+    unsigned d;
+    if (inet_aton(dotted_quad, &ip) == 0)
+        return -1; /* malformed dotted IP */
+    d = ntohl(ip.s_addr); /* IP in host order */
+    d = ~d; /* 11110000 -> 00001111 */
+    if (d & (d+1)) /* check that it is in 00001111 form */
+        return -1; /* no it is not */
+    result = 32;
+    while (d) {
+        d >>= 1;
+        result--;
+    }
+    return result;
+}
+#endif
+static char *parse(const char *command, struct interface_defn_t *ifd)
+{
     size_t old_pos[MAX_OPT_DEPTH] = { 0 };
     int okay[MAX_OPT_DEPTH] = { 1 };
     int opt_depth = 1;
+    char *result = NULL;
     while (*command) {
         switch (*command) {
+            default:
+                addstr(&result, &len, &pos, command, 1);
+        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]) {
+                    addstr(&result, &len, &pos, command + 1, 1);
+                    command += 2;
+            }
+            break;
+        case '[':
+            if (command[1] == '[' && opt_depth < MAX_OPT_DEPTH) {
+                old_pos[opt_depth] = result ? strlen(result) : 0;
+                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 {
+                    addstr(&result, &len, &pos, command, 1);
+                    command++;
+                }
+                break;
+            case '[':
+                if (command[1] == '[' && opt_depth < MAX_OPT_DEPTH) {
+                    old_pos[opt_depth] = pos;
+                    okay[opt_depth] = 1;
+                    opt_depth++;
+                    command += 2;
+                } else {
+                    addstr(&result, &len, &pos, "[", 1);
+                    command++;
+                }
+                break;
+            case ']':
+                if (command[1] == ']' && opt_depth > 1) {
+                    opt_depth--;
+                    if (!okay[opt_depth]) {
+                        pos = old_pos[opt_depth];
+                        result[pos] = '\0';
+                    }
+                    command += 2;
+                } else {
+                    addstr(&result, &len, &pos, "]", 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, &len, &pos, 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) {
+                            int res;
+                            varvalue = get_var("netmask", 7, ifd);
+                            if (varvalue && (res=count_netmask_bits(varvalue)) > 0) {
+                                char argument[255];
+                                sprintf(argument, "%d", res);
+                                addstr(&result, &len, &pos, argument, strlen(argument));
+#if ENABLE_FEATURE_IFUPDOWN_IP
+                    /* Sigh...  Add a special case for 'ip' to convert from
+                     * dotted quad to bit count style netmasks.  */
+                    if (strncmp(command, "bnmask", 6) == 0) {
+                        unsigned res;
+                        varvalue = get_var("netmask", 7, ifd);
+                        if (varvalue) {
+                            res = count_netmask_bits(varvalue);
+                            if (res > 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;
+#endif
+                    okay[opt_depth - 1] = 0;
+                }
+                command = nextpercent + 1;
+            }
+            break;
+        }
+    }
 …
         errno = EUNBALBRACK;
         free(result);
         return(NULL);
+        return NULL;
+    }
 …
         errno = EUNDEFVAR;
         free(result);
+        return(NULL);
+    }
+    return(result);
+}
+static int execute(char *command, struct interface_defn_t *ifd, execfn *exec)
+        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;
 …
     out = parse(command, ifd);
     if (!out) {
+        return(0);
+    }
+    ret = (*exec) (out);
+        /* parse error? */
+        return 0;
+    }
+    /* out == "": parsed ok but not all needed variables known, skip */
+    ret = out[0] ? (*exec)(out) : 1;
     free(out);
     if (ret != 1) {
         return(0);
+    }
     return(1);
+}
 #endif
 #ifdef CONFIG_FEATURE_IFUPDOWN_IPV6
+        return 0;
+    }
+    return 1;
+}
+#endif
+#if ENABLE_FEATURE_IFUPDOWN_IPV6
 static int loopback_up6(struct interface_defn_t *ifd, execfn *exec)
+{
 #ifdef CONFIG_FEATURE_IFUPDOWN_IP
+#if ENABLE_FEATURE_IFUPDOWN_IP
     int result;
     result =execute("ip addr add ::1 dev %iface%", ifd, exec);
+    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));
+    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));
+#if ENABLE_FEATURE_IFUPDOWN_IP
+    return execute("ip link set %iface% down", ifd, exec);
 #else
     return(execute("ifconfig %iface% del ::1", ifd, exec));
+    return execute("ifconfig %iface% del ::1", ifd, exec);
 #endif
+}
 …
+{
     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);
+#if ENABLE_FEATURE_IFUPDOWN_IP
+    result = execute("ip addr add %address%/%netmask% dev %iface%[[ label %label%]]", ifd, exec);
+    result += execute("ip link set[[ mtu %mtu%]][[ address %hwaddress%]] %iface% up", ifd, exec);
+    /* Was: "[[ ip ....%gateway% ]]". Removed extra spaces w/o checking */
+    result += execute("[[ip route add ::/0 via %gateway%]]", ifd, exec);
 #else
     result = execute("ifconfig %iface% [[media %media%]] [[hw %hwaddress%]] [[mtu %mtu%]] up", ifd, exec);
+    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);
+    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));
+#if ENABLE_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
+    return execute("ifconfig %iface% down", ifd, exec);
+#endif
+}
+#if ENABLE_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);
+            "%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);
+    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 struct method_t methods6[] = {
 #ifdef CONFIG_FEATURE_IFUPDOWN_IP
+    return execute("ip tunnel del %iface%", ifd, exec);
+}
+#endif
+static const struct method_t methods6[] = {
+#if ENABLE_FEATURE_IFUPDOWN_IP
     { "v4tunnel", v4tunnel_up, v4tunnel_down, },
 #endif
 …
 };
 static struct address_family_t addr_inet6 = {
+static const struct address_family_t addr_inet6 = {
     "inet6",
     sizeof(methods6) / sizeof(struct method_t),
+    ARRAY_SIZE(methods6),
     methods6
 };
 #endif /* CONFIG_FEATURE_IFUPDOWN_IPV6 */
 #ifdef CONFIG_FEATURE_IFUPDOWN_IPV4
+#endif /* FEATURE_IFUPDOWN_IPV6 */
+#if ENABLE_FEATURE_IFUPDOWN_IPV4
 static int loopback_up(struct interface_defn_t *ifd, execfn *exec)
+{
 #ifdef CONFIG_FEATURE_IFUPDOWN_IP
+#if ENABLE_FEATURE_IFUPDOWN_IP
     int result;
     result = execute("ip addr add 127.0.0.1/8 dev %iface%", ifd, exec);
 …
     return ((result == 2) ? 2 : 0);
 #else
     return( execute("ifconfig %iface% 127.0.0.1 up", ifd, exec));
+    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
+#if ENABLE_FEATURE_IFUPDOWN_IP
     int result;
     result = execute("ip addr flush dev %iface%", ifd, exec);
 …
     return ((result == 2) ? 2 : 0);
 #else
     return( execute("ifconfig %iface% 127.0.0.1 down", ifd, exec));
+    return execute("ifconfig %iface% 127.0.0.1 down", ifd, exec);
 #endif
+}
 …
+{
     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);
+#if ENABLE_FEATURE_IFUPDOWN_IP
+    result = execute("ip addr add %address%/%bnmask%[[ broadcast %broadcast%]] "
+            "dev %iface%[[ peer %pointopoint%]][[ label %label%]]", ifd, exec);
+    result += execute("ip link set[[ mtu %mtu%]][[ address %hwaddress%]] %iface% up", ifd, exec);
+    result += execute("[[ip route add default via %gateway% dev %iface%]]", ifd, exec);
     return ((result == 3) ? 3 : 0);
 #else
     result = execute("ifconfig %iface% %address% netmask %netmask% "
                 "[[broadcast %broadcast%]] [[pointopoint %pointopoint%]] "
                 "[[media %media%]] [[mtu %mtu%]] [[hw %hwaddress%]] up",
+    /* 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("[[ route add default gw %gateway% %iface% ]]", ifd, exec);
+    return ((result == 2) ? 2 : 0);
+    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
+}
 …
+{
     int result;
 #ifdef CONFIG_FEATURE_IFUPDOWN_IP
+#if ENABLE_FEATURE_IFUPDOWN_IP
     result = execute("ip addr flush dev %iface%", ifd, exec);
     result += execute("ip link set %iface% down", ifd, exec);
 #else
     result = execute("[[ route del default gw %gateway% %iface% ]]", ifd, exec);
+    result = execute("[[route del default gw %gateway% %iface%]]", ifd, exec);
     result += execute("ifconfig %iface% down", ifd, exec);
 #endif
 …
+}
+static int execable(char *program)
+{
+    struct stat buf;
+    if (0 == stat(program, &buf)) {
+        if (S_ISREG(buf.st_mode) && (S_IXUSR & buf.st_mode)) {
+            return(1);
+        }
+    }
+    return(0);
+}
+#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+struct dhcp_client_t
+{
+    const char *name;
+    const char *startcmd;
+    const char *stopcmd;
+};
+static const struct dhcp_client_t ext_dhcp_clients[] = {
+    { "dhcpcd",
+        "dhcpcd[[ -h %hostname%]][[ -i %vendor%]][[ -I %clientid%]][[ -l %leasetime%]] %iface%",
+        "dhcpcd -k %iface%",
+    },
+    { "dhclient",
+        "dhclient -pf /var/run/dhclient.%iface%.pid %iface%",
+        "kill -9 `cat /var/run/dhclient.%iface%.pid` 2>/dev/null",
+    },
+    { "pump",
+        "pump -i %iface%[[ -h %hostname%]][[ -l %leasehours%]]",
+        "pump -i %iface% -k",
+    },
+    { "udhcpc",
+        "udhcpc -R -n -p /var/run/udhcpc.%iface%.pid -i %iface%[[ -H %hostname%]][[ -c %clientid%]][[ -s %script%]]",
+        "kill `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null",
+    },
+};
+#endif /* ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCPC */
 static int dhcp_up(struct interface_defn_t *ifd, execfn *exec)
+{
+    if (execable("/sbin/udhcpc")) {
+        return( execute("udhcpc -n -p /var/run/udhcpc.%iface%.pid -i "
+                    "%iface% [[-H %hostname%]] [[-c %clientid%]]", ifd, exec));
+    } else if (execable("/sbin/pump")) {
+        return( execute("pump -i %iface% [[-h %hostname%]] [[-l %leasehours%]]", ifd, exec));
+    } else if (execable("/sbin/dhclient")) {
+        return( execute("dhclient -pf /var/run/dhclient.%iface%.pid %iface%", ifd, exec));
+    } else if (execable("/sbin/dhcpcd")) {
+        return( execute("dhcpcd [[-h %hostname%]] [[-i %vendor%]] [[-I %clientid%]] "
+                    "[[-l %leasetime%]] %iface%", ifd, exec));
+    }
+    return(0);
+#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+    int i;
+#if ENABLE_FEATURE_IFUPDOWN_IP
+    /* ip doesn't up iface when it configures it (unlike ifconfig) */
+    if (!execute("ip link set %iface% up", ifd, exec))
+        return 0;
+#endif
+    for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
+        if (exists_execable(ext_dhcp_clients[i].name))
+            return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
+    }
+    bb_error_msg("no dhcp clients found");
+    return 0;
+#elif ENABLE_APP_UDHCPC
+#if ENABLE_FEATURE_IFUPDOWN_IP
+    /* ip doesn't up iface when it configures it (unlike ifconfig) */
+    if (!execute("ip link set %iface% up", ifd, exec))
+        return 0;
+#endif
+    return execute("udhcpc -R -n -p /var/run/udhcpc.%iface%.pid "
+            "-i %iface%[[ -H %hostname%]][[ -c %clientid%]][[ -s %script%]]",
+            ifd, exec);
+#else
+    return 0; /* no dhcp support */
+#endif
+}
 static int dhcp_down(struct interface_defn_t *ifd, execfn *exec)
+{
+    int result = 0;
+    if (execable("/sbin/udhcpc")) {
+        /* SIGUSR2 forces udhcpc to release the current lease and go inactive,
+         * and SIGTERM causes udhcpc to exit.  Signals are queued and processed
+         * sequentially so we don't need to sleep */
+        result = execute("kill -USR2 `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", ifd, exec);
+        result += execute("kill -TERM `cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", ifd, exec);
+    } else if (execable("/sbin/pump")) {
+        result = execute("pump -i %iface% -k", ifd, exec);
+    } else if (execable("/sbin/dhclient")) {
+        result = execute("kill -9 `cat /var/run/dhclient.%iface%.pid` 2>/dev/null", ifd, exec);
+    } else if (execable("/sbin/dhcpcd")) {
+        result = execute("dhcpcd -k %iface%", ifd, exec);
+    }
+    return (result || static_down(ifd, exec));
+#if ENABLE_FEATURE_IFUPDOWN_EXTERNAL_DHCP
+    int i;
+    for (i = 0; i < ARRAY_SIZE(ext_dhcp_clients); i++) {
+        if (exists_execable(ext_dhcp_clients[i].name))
+            return execute(ext_dhcp_clients[i].stopcmd, ifd, exec);
+    }
+    bb_error_msg("no dhcp clients found, using static interface shutdown");
+    return static_down(ifd, exec);
+#elif ENABLE_APP_UDHCPC
+    return execute("kill "
+                   "`cat /var/run/udhcpc.%iface%.pid` 2>/dev/null", ifd, exec);
+#else
+    return 0; /* no dhcp support */
+#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));
+    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));
+    return execute("pon[[ %provider%]]", ifd, exec);
+}
 static int ppp_down(struct interface_defn_t *ifd, execfn *exec)
+{
     return( execute("poff [[%provider%]]", ifd, 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));
+    return execute("start-stop-daemon --start -x wvdial "
+        "-p /var/run/wvdial.%iface% -b -m --[[ %provider%]]", ifd, exec);
+}
 static int wvdial_down(struct interface_defn_t *ifd, execfn *exec)
+{
     return( execute("/sbin/start-stop-daemon --stop -x /usr/bin/wvdial "
                 "-p /var/run/wvdial.%iface% -s 2", ifd, exec));
+}
 static struct method_t methods[] =
+{
+    return execute("start-stop-daemon --stop -x wvdial "
+            "-p /var/run/wvdial.%iface% -s 2", ifd, exec);
+}
+static const struct method_t methods[] = {
+    { "manual", manual_up_down, manual_up_down, },
     { "wvdial", wvdial_up, wvdial_down, },
     { "ppp", ppp_up, ppp_down, },
 …
 };
+static struct address_family_t addr_inet =
+{
+static const struct address_family_t addr_inet = {
     "inet",
     sizeof(methods) / sizeof(struct method_t),
+    ARRAY_SIZE(methods),
     methods
 };
 #endif  /* ifdef CONFIG_FEATURE_IFUPDOWN_IPV4 */
+#endif  /* if ENABLE_FEATURE_IFUPDOWN_IPV4 */
 static char *next_word(char **buf)
 …
     char *word;
     if ((buf == NULL) || (*buf == NULL) || (**buf == '\0')) {
+    if (!buf || !*buf || !**buf) {
         return NULL;
+    }
     /* Skip over leading whitespace */
+    word = *buf;
+    while (isspace(*word)) {
+        ++word;
+    }
+    word = skip_whitespace(*buf);
     /* Skip over comments */
     if (*word == '#') {
         return(NULL);
+        return NULL;
+    }
 …
     length = strcspn(word, " \t\n");
     if (length == 0) {
         return(NULL);
+        return NULL;
+    }
     *buf = word + length;
 …
+}
 static struct address_family_t *get_address_family(struct address_family_t *af[], char *name)
+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++) {
 …
+}
 static struct method_t *get_method(struct address_family_t *af, char *name)
+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++) {
 …
+        }
+    }
     return(NULL);
+    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);
+            return list;
+        }
         list = list->link;
+    }
     return(NULL);
+    return NULL;
+}
 static struct interfaces_file_t *read_interfaces(const char *filename)
+{
 #ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+#if ENABLE_FEATURE_IFUPDOWN_MAPPING
     struct mapping_defn_t *currmap = NULL;
 #endif
 …
     defn = xzalloc(sizeof(struct interfaces_file_t));
     f = bb_xfopen(filename, "r");
     while ((buf = bb_get_chomped_line_from_file(f)) != NULL) {
+    f = xfopen(filename, "r");
+    while ((buf = xmalloc_getline(f)) != NULL) {
         char *buf_ptr = buf;
 …
         if (strcmp(firstword, "mapping") == 0) {
 #ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+#if ENABLE_FEATURE_IFUPDOWN_MAPPING
             currmap = xzalloc(sizeof(struct mapping_defn_t));
 …
+                }
                 currmap->match[currmap->n_matches++] = bb_xstrdup(firstword);
+                currmap->match[currmap->n_matches++] = xstrdup(firstword);
+            }
             currmap->max_mappings = 0;
 …
             currently_processing = MAPPING;
         } else if (strcmp(firstword, "iface") == 0) {
+            {
+                char *iface_name;
+                char *address_family_name;
+                char *method_name;
+                struct address_family_t *addr_fams[] = {
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV4
+                    &addr_inet,
+#endif
+#ifdef CONFIG_FEATURE_IFUPDOWN_IPV6
+                    &addr_inet6,
+#endif
+                    NULL
+                };
+                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);
+            static const struct address_family_t *const addr_fams[] = {
+#if ENABLE_FEATURE_IFUPDOWN_IPV4
+                &addr_inet,
+#endif
+#if ENABLE_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;
+                }
+                /* ship any trailing whitespace */
+                while (isspace(*buf_ptr)) {
+                    ++buf_ptr;
+                }
+                if (buf_ptr[0] != '\0') {
+                    bb_error_msg("too many parameters \"%s\"", buf);
+                    return NULL;
+                }
+                currif->iface = bb_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;
+                }
+                {
+                    llist_t *iface_list;
+                    for (iface_list = defn->ifaces; iface_list; iface_list = iface_list->link) {
+                        struct interface_defn_t *tmp = (struct interface_defn_t *) iface_list->data;
+                        if ((strcmp(tmp->iface, currif->iface) == 0) &&
+                            (tmp->address_family == currif->address_family)) {
+                            bb_error_msg("duplicate interface \"%s\"", tmp->iface);
+                            return NULL;
+                        }
+                    }
+                    llist_add_to_end(&(defn->ifaces), (char*)currif);
+                }
+                debug_noise("iface %s %s %s\n", currif->iface, address_family_name, method_name);
+            }
+            }
+            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) {
 …
                 /* Add the interface to the list */
                 llist_add_to_end(&(defn->autointerfaces), bb_xstrdup(firstword));
+                llist_add_to_end(&(defn->autointerfaces), xstrdup(firstword));
                 debug_noise("\nauto %s\n", firstword);
+            }
 …
         } 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;
+                                }
+            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;
+                }
+                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:
+#if ENABLE_FEATURE_IFUPDOWN_MAPPING
+                if (strcmp(firstword, "script") == 0) {
+                    if (currmap->script != NULL) {
+                        bb_error_msg("duplicate script in mapping \"%s\"", buf);
+                        return NULL;
+                    } else {
+                        currmap->script = xstrdup(next_word(&buf_ptr));
+                    }
+                    currif->option[currif->n_options].name = bb_xstrdup(firstword);
+                    currif->option[currif->n_options].value = bb_xstrdup(buf_ptr);
+                    if (!currif->option[currif->n_options].name) {
+                        perror(filename);
+                        return NULL;
+                } 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);
+                    }
+                    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 = bb_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] = bb_xstrdup(next_word(&buf_ptr));
+                        currmap->n_mappings++;
+                    } else {
+                        bb_error_msg("misplaced option \"%s\"", buf);
+                        return NULL;
+                    }
+#endif
+                    break;
+                case NONE:
+                default:
+                    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;
+            }
+        }
 …
+    }
     if (ferror(f) != 0) {
+        bb_perror_msg_and_die("%s", filename);
+        /* ferror does NOT set errno! */
+        bb_error_msg_and_die("%s: I/O error", filename);
+    }
     fclose(f);
 …
+}
 static char *setlocalenv(char *format, const char *name, const char *value)
+static char *setlocalenv(const char *format, const char *name, const char *value)
+{
     char *result;
 …
     char *there;
     result = bb_xasprintf(format, name, value);
+    result = xasprintf(format, name, value);
     for (here = there = result; *there != '=' && *there; there++) {
 …
     char **ppch;
     if (__myenviron != NULL) {
         for (ppch = __myenviron; *ppch; ppch++) {
+    if (my_environ != NULL) {
+        for (ppch = my_environ; *ppch; ppch++) {
             free(*ppch);
             *ppch = NULL;
+        }
         free(__myenviron);
+    }
     __myenviron = xzalloc(sizeof(char *) * (n_env_entries + 1 /* for final NULL */ ));
     environend = __myenviron;
+        free(my_environ);
+    }
+    my_environ = xzalloc(sizeof(char *) * (n_env_entries + 1 /* for final NULL */ ));
+    environend = my_environ;
     for (i = 0; i < iface->n_options; i++) {
         if (strcmp(iface->option[i].name, "up") == 0
+                || strcmp(iface->option[i].name, "down") == 0
+                || strcmp(iface->option[i].name, "pre-up") == 0
+                || strcmp(iface->option[i].name, "post-down") == 0) {
+         || 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("%s=%s", "METHOD", iface->method->name);
     *(environend++) = setlocalenv("%s=%s", "MODE", mode);
     *(environend++) = setlocalenv("%s=%s", "PATH", "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
+    *(environend++) = setlocalenv("%s=%s", "PATH", startup_PATH);
+}
 static int doit(char *str)
+{
     if (verbose || no_act) {
         printf("%s\n", str);
+    }
     if (!no_act) {
+    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);
+        child = fork();
+        switch (child) {
+        case -1: /* failure */
+            return 0;
+        case 0: /* child */
+            execle(DEFAULT_SHELL, DEFAULT_SHELL, "-c", str, NULL, my_environ);
+            exit(127);
+        }
         waitpid(child, &status, 0);
 …
+        }
+    }
     return (1);
+    return 1;
+}
 …
+    }
+    buf = bb_xasprintf("run-parts /etc/network/if-%s.d", opt);
+    if (doit(buf) != 1) {
+        return 0;
+    }
+    return 1;
+}
+static int check(char *str) {
+    buf = xasprintf("run-parts /etc/network/if-%s.d", opt);
+    /* heh, we don't bother free'ing it */
+    return doit(buf);
+}
+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;
+    if (!iface->method->up(iface, check)) return -1;
     set_environ(iface, "start");
     if (!execute_all(iface, "pre-up")) return 0;
 …
+}
 #ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+#if ENABLE_FEATURE_IFUPDOWN_MAPPING
 static int popen2(FILE **in, FILE **out, char *command, ...)
+{
 …
     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;
+    case -1:            /* failure */
+        close(infd[0]);
+        close(infd[1]);
+        close(outfd[0]);
+        close(outfd[1]);
+        return 0;
+    case 0:         /* child */
+        dup2(infd[0], 0);
+        dup2(outfd[1], 1);
+        close(infd[0]);
+        close(infd[1]);
+        close(outfd[0]);
+        close(outfd[1]);
+        BB_EXECVP(command, argv);
+        exit(127);
+    default:            /* parent */
+        *in = fdopen(infd[1], "w");
+        *out = fdopen(outfd[0], "r");
+        close(infd[0]);
+        close(outfd[1]);
+        return pid;
+    }
     /* unreached */
 …
     pid_t pid;
     char *logical = bb_xstrdup(physical);
+    char *logical = xstrdup(physical);
     /* Run the mapping script. */
 …
          * grab a line of output and use that as the name of the
          * logical interface. */
         char *new_logical = (char *)xmalloc(MAX_INTERFACE_LENGTH);
+        char *new_logical = xmalloc(MAX_INTERFACE_LENGTH);
         if (fgets(new_logical, MAX_INTERFACE_LENGTH, out)) {
 …
     return logical;
+}
 #endif /* CONFIG_FEATURE_IFUPDOWN_MAPPING */
+#endif /* FEATURE_IFUPDOWN_MAPPING */
 static llist_t *find_iface_state(llist_t *state_list, const char *iface)
 …
     while (search) {
         if ((strncmp(search->data, iface, iface_len) == 0) &&
                 (search->data[iface_len] == '=')) {
             return(search);
+        if ((strncmp(search->data, iface, iface_len) == 0)
+         && (search->data[iface_len] == '=')) {
+            return search;
+        }
         search = search->link;
+    }
+    return(NULL);
+}
+    return NULL;
+}
+/* read the previous state from the state file */
+static llist_t *read_iface_state(void)
+{
+    llist_t *state_list = NULL;
+    FILE *state_fp = fopen(CONFIG_IFUPDOWN_IFSTATE_PATH, "r");
+    if (state_fp) {
+        char *start, *end_ptr;
+        while ((start = xmalloc_fgets(state_fp)) != NULL) {
+            /* We should only need to check for a single character */
+            end_ptr = start + strcspn(start, " \t\n");
+            *end_ptr = '\0';
+            llist_add_to(&state_list, start);
+        }
+        fclose(state_fp);
+    }
+    return state_list;
+}
+int ifupdown_main(int argc, char **argv);
 int ifupdown_main(int argc, char **argv)
+{
     int (*cmds) (struct interface_defn_t *) = NULL;
+    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";
+    const char *statefile = "/var/run/ifstate";
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+    int run_mappings = 1;
+#endif
+    int do_all = 0;
+    int force = 0;
+    int any_failures = 0;
+    int i;
+    if (bb_applet_name[2] == 'u') {
+    bool any_failures = 0;
+    cmds = iface_down;
+    if (applet_name[2] == 'u') {
         /* ifup command */
         cmds = iface_up;
+    }
+    getopt32(argv, OPTION_STR, &interfaces);
+    if (argc - optind > 0) {
+        if (DO_ALL) bb_show_usage();
     } else {
+        /* ifdown command */
+        cmds = iface_down;
+    }
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+    while ((i = getopt(argc, argv, "i:hvnamf")) != -1)
+#else
+        while ((i = getopt(argc, argv, "i:hvnaf")) != -1)
+#endif
+        {
+            switch (i) {
+                case 'i':   /* interfaces */
+                    interfaces = optarg;
+                    break;
+                case 'v':   /* verbose */
+                    verbose = 1;
+                    break;
+                case 'a':   /* all */
+                    do_all = 1;
+                    break;
+                case 'n':   /* no-act */
+                    no_act = 1;
+                    break;
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+                case 'm':   /* no-mappings */
+                    run_mappings = 0;
+                    break;
+#endif
+                case 'f':   /* force */
+                    force = 1;
+                    break;
+                default:
+                    bb_show_usage();
+                    break;
+            }
+        }
+    if (argc - optind > 0) {
+        if (do_all) {
+            bb_show_usage();
+        }
+    } else {
+        if (!do_all) {
+            bb_show_usage();
+        }
+        if (!DO_ALL) bb_show_usage();
+    }
 …
     if (!defn) {
+        exit(EXIT_FAILURE);
+    }
+        return 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, bb_xstrdup(list->data));
+                list = list->link;
+            }
+            target_list = defn->autointerfaces;
+        }
+    if (DO_ALL) {
+        target_list = defn->autointerfaces;
     } else {
         llist_add_to_end(&target_list, argv[optind]);
+    }
     /* Update the interfaces */
 …
         char *liface;
         char *pch;
         int okay = 0;
         int cmds_ret;
         iface = bb_xstrdup(target_list->data);
+        bool okay = 0;
+        unsigned cmds_ret;
+        iface = xstrdup(target_list->data);
         target_list = target_list->link;
 …
         if (pch) {
             *pch = '\0';
             liface = bb_xstrdup(pch + 1);
+            liface = xstrdup(pch + 1);
         } else {
+            liface = bb_xstrdup(iface);
+        }
+        if (!force) {
+            liface = xstrdup(iface);
+        }
+        if (!FORCE) {
+            llist_t *state_list = read_iface_state();
             const llist_t *iface_state = find_iface_state(state_list, iface);
 …
             } else {
                 /* ifdown */
                 if (iface_state) {
+                if (!iface_state) {
                     bb_error_msg("interface %s not configured", iface);
                     continue;
+                }
+            }
+        }
+#ifdef CONFIG_FEATURE_IFUPDOWN_MAPPING
+        if ((cmds == iface_up) && run_mappings) {
+            llist_free(state_list, free);
+        }
+#if ENABLE_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) {
+                    if (VERBOSE) {
                         printf("Running mapping script %s on %s\n", currmap->script, liface);
+                    }
 …
+        }
 #endif
         iface_list = defn->ifaces;
 …
                 cmds_ret = cmds(currif);
                 if (cmds_ret == -1) {
                     bb_error_msg("Don't seem to have all the variables for %s/%s.",
+                    bb_error_msg("don't seem to have all the variables for %s/%s",
                             liface, currif->address_family->name);
                     any_failures += 1;
+                    any_failures = 1;
                 } else if (cmds_ret == 0) {
                     any_failures += 1;
+                    any_failures = 1;
+                }
 …
             iface_list = iface_list->link;
+        }
+        if (verbose) {
+            printf("\n");
+        }
+        if (!okay && !force) {
+            bb_error_msg("Ignoring unknown interface %s", liface);
+            any_failures += 1;
+        } else {
+        if (VERBOSE) {
+            puts("");
+        }
+        if (!okay && !FORCE) {
+            bb_error_msg("ignoring unknown interface %s", liface);
+            any_failures = 1;
+        } else if (!NO_ACT) {
+            /* update the state file */
+            FILE *state_fp;
+            llist_t *state;
+            llist_t *state_list = read_iface_state();
             llist_t *iface_state = find_iface_state(state_list, iface);
             if (cmds == iface_up) {
                 char *newiface = bb_xasprintf("%s=%s", iface, liface);
+                char * const newiface = xasprintf("%s=%s", iface, liface);
                 if (iface_state == NULL) {
                     llist_add_to_end(&state_list, newiface);
 …
+                }
             } else {
+                /* Remove an interface from the linked list */
+                /* Remove an interface from state_list */
+                llist_unlink(&state_list, iface_state);
                 free(llist_pop(&iface_state));
+            }
+        }
+    }
+    /* Actually write the new state */
+    if (!no_act) {
+        FILE *state_fp = NULL;
+        state_fp = bb_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;
+}
+            /* Actually write the new state */
+            state_fp = xfopen(CONFIG_IFUPDOWN_IFSTATE_PATH, "w");
+            state = state_list;
+            while (state) {
+                if (state->data) {
+                    fprintf(state_fp, "%s\n", state->data);
+                }
+                state = state->link;
+            }
+            fclose(state_fp);
+            llist_free(state_list, free);
+        }
+    }
+    return any_failures;
+}

branches/stable/mindi-busybox/networking/inetd.c

-              r821
+              r1770
+/* 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 $      */
 …
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * 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
 …
  */
+/*
+ * Inetd - Internet super-server
+/* Inetd - Internet super-server
+ *
  * This program invokes all internet services as needed.
 …
  * 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'',
+ * 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''.
+ * 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
+ * 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.
 …
  */
+/*
+ * Here's the scoop concerning the user[.:]group feature:
+/* inetd rules for passing file descriptors to children
+ * (http://www.freebsd.org/cgi/man.cgi?query=inetd):
+ *
+ * The wait/nowait entry specifies whether the server that is invoked by
+ * inetd will take over the socket associated with the service access point,
+ * and thus whether inetd should wait for the server to exit before listen-
+ * ing for new service requests.  Datagram servers must use "wait", as
+ * they are always invoked with the original datagram socket bound to the
+ * specified service address.  These servers must read at least one datagram
+ * from the socket before exiting.  If a datagram server connects to its
+ * peer, freeing the socket so inetd can receive further messages on the
+ * socket, it is said to be a "multi-threaded" server; it should read one
+ * datagram from the socket and create a new socket connected to the peer.
+ * It should fork, and the parent should then exit to allow inetd to check
+ * for new service requests to spawn new servers.  Datagram servers which
+ * process all incoming datagrams on a socket and eventually time out are
+ * said to be "single-threaded".  The comsat(8), (biff(1)) and talkd(8)
+ * utilities are both examples of the latter type of datagram server.  The
+ * tftpd(8) utility is an example of a multi-threaded datagram server.
+ *
+ * Servers using stream sockets generally are multi-threaded and use the
+ * "nowait" entry. Connection requests for these services are accepted by
+ * inetd, and the server is given only the newly-accepted socket connected
+ * to a client of the service.  Most stream-based services operate in this
+ * manner.  Stream-based servers that use "wait" are started with the lis-
+ * tening service socket, and must accept at least one connection request
+ * before exiting.  Such a server would normally accept and process incoming
+ * connection requests until a timeout.
+ */
+/* Here's the scoop concerning the user[.:]group feature:
+ *
  * 1) set-group-option off.
 …
  *                      initgroups(name, specified group)
  *                      setuid()
+ *
  */
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include "libbb.h"
+#include <syslog.h>
 #include <sys/un.h>
+#include <sys/file.h>
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <signal.h>
+#include <netdb.h>
+#include <syslog.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include "busybox.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
+//#define ENABLE_FEATURE_INETD_RPC 1
+//#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO 1
+//#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD 1
+//#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME 1
+//#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME 1
+//#define ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN 1
+//#define ENABLE_FEATURE_IPV6 1
+#if ENABLE_FEATURE_INETD_RPC
 #include <rpc/rpc.h>
 #include <rpc/pmap_clnt.h>
 #endif
+#define _PATH_INETDCONF "/etc/inetd.conf"
+extern char **environ;
 #define _PATH_INETDPID  "/var/run/inetd.pid"
-#define TOOMANY         0               /* don't start more than TOOMANY */
 #define CNT_INTVL       60              /* servers in CNT_INTVL sec. */
 …
 /* Reserve some descriptors, 3 stdio + at least: 1 log, 1 conf. file */
 #define FD_MARGIN       (8)
+#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
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO || \
+    ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD || \
+    ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME || \
+    ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME || \
+    ENABLE_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
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO || \
+    ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD || \
+    ENABLE_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 */
+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 */
+#if ENABLE_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 */
+    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 */
+    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 */
+    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;
+#if ENABLE_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;
+    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;
 …
 #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 *);
+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 */
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
+static void echo_stream(int, servtab_t *);
+static void echo_dg(int, servtab_t *);
+#endif
+        /* Internet /dev/null */
+#if ENABLE_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 */
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
+static void machtime_stream(int, servtab_t *);
+static void machtime_dg(int, servtab_t *);
+#endif
+        /* Return human-readable time */
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
+static void daytime_stream(int, servtab_t *);
+static void daytime_dg(int, servtab_t *);
+#endif
+        /* Familiar character generator */
+#if ENABLE_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[] = {
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO
     /* 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
+    {"echo", SOCK_STREAM, 1, 0, echo_stream,},
+    {"echo", SOCK_DGRAM, 0, 0, echo_dg,},
+#endif
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD
     /* 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
+    {"discard", SOCK_STREAM, 1, 0, discard_stream,},
+    {"discard", SOCK_DGRAM, 0, 0, discard_dg,},
+#endif
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
     /* 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
+    {"time", SOCK_STREAM, 0, 0, machtime_stream,},
+    {"time", SOCK_DGRAM, 0, 0, machtime_dg,},
+#endif
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME
     /* 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
+    {"daytime", SOCK_STREAM, 0, 0, daytime_stream,},
+    {"daytime", SOCK_DGRAM, 0, 0, daytime_dg,},
+#endif
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
     /* 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}
+    {"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 nsock, maxsock;
 static fd_set allsock;
 static int toomany = TOOMANY;
+static int toomany;
 static int timingout;
 static struct servent *sp;
 static uid_t uid;
 static char *CONFIG = _PATH_INETDCONF;
+static const char *config_filename = "/etc/inetd.conf";
 static FILE *fconfig;
-static char line[1024];
 static char *defhost;
+static char *newstr (char *cp)
+{
+  if ((cp = strdup (cp ? cp : "")))
+    return (cp);
+  syslog (LOG_ERR, "strdup: %m");
+  exit (1);
+}
+static int setconfig (void)
+{
+  free (defhost);
+  defhost = newstr ("*");
+  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) {
+    syslog (LOG_ERR, "%s: getproto: %m", sep->se_proto);
+    return;
+  }
+  size = sizeof ir_sin;
+  if (getsockname (sep->se_fd, (struct sockaddr *) &ir_sin, &size) < 0) {
+    syslog (LOG_ERR, "%s/%s: getsockname: %m",
+            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)))
+      syslog (LOG_ERR, "%s %s: pmap_set: %u %u %u %u: %m",
+              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))
+      syslog (LOG_ERR, "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)
+/* 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_filename, "r");
+    return (fconfig != NULL);
+}
+static void endconfig(void)
+{
+    if (fconfig) {
+        (void) fclose(fconfig);
+        fconfig = NULL;
+    }
+    free(defhost);
+    defhost = 0;
+}
+#if ENABLE_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 /* 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) {
+    syslog (LOG_ERR, "getrlimit: %m");
+    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) {
+    syslog (LOG_ERR, "bump_nofile: cannot extend file limit, max = %d",
+            (int) rl.rlim_cur);
+    return -1;
+  }
+  if (setrlimit (RLIMIT_NOFILE, &rl) < 0) {
+    syslog (LOG_ERR, "setrlimit: %m");
+    return -1;
+  }
+  rlim_ofile_cur = rl.rlim_cur;
+  return 0;
+}
+static void setup (servtab_t *sep)
+{
+  int on = 1;
+  int r;
+  if ((sep->se_fd = socket (sep->se_family, sep->se_socktype, 0)) < 0) {
+    syslog (LOG_ERR, "%s/%s: socket: %m", sep->se_service, sep->se_proto);
+    return;
+  }
+#define turnon(fd, opt) \
+setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on))
+  if (turnon (sep->se_fd, SO_REUSEADDR) < 0)
+    syslog (LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
+#undef turnon
+#ifdef CONFIG_FEATURE_INETD_RPC
+  if (isrpcservice (sep)) {
+    struct passwd *pwd;
+    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;
+    }
+    setsockopt_reuseaddr(sep->se_fd);
+#if ENABLE_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)
+{
+#define line bb_common_bufsiz1
+    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);
+        ungetc(c, fconfig);
+        if (c == ' ' || c == '\t') {
+            cp = nextline();
+            if (cp)
+                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);
+#if ENABLE_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')
+#if ENABLE_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) {
+#if ENABLE_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;
     /*
+     * 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.
+     * 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.
      */
+    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) {
+    syslog (LOG_ERR, "%s/%s (%d): bind: %m",
+            sep->se_service, sep->se_proto, sep->se_ctrladdr.sa_family);
+    close (sep->se_fd);
+    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 (LONE_CHAR(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;
+    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) */
+    /* syslog(LOG_ERR, "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)
+{
+  servtab_t *sep;
+  sep = (servtab_t *) malloc (sizeof (servtab_t));
+  if (sep == NULL) {
+    syslog (LOG_ERR, bb_msg_memory_exhausted);
+    exit (1);
+  }
+  return sep;
+}
+static servtab_t *dupconfig (servtab_t *sep)
+{
+  servtab_t *newtab;
+  int argc;
+  newtab = new_servtab();
+  memset (newtab, 0, sizeof (servtab_t));
+  newtab->se_service = sep->se_service ? newstr (sep->se_service) : NULL;
+  newtab->se_socktype = sep->se_socktype;
+  newtab->se_family = sep->se_family;
+  newtab->se_proto = sep->se_proto ? newstr (sep->se_proto) : NULL;
+#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 = sep->se_user ? newstr (sep->se_user) : NULL;
+  newtab->se_group = sep->se_group ? newstr (sep->se_group) : NULL;
+#if ENABLE_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;
+#if ENABLE_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_filename);
+        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
+  newtab->se_bi = sep->se_bi;
+#endif
+  newtab->se_server = sep->se_server ? newstr (sep->se_server) : 0;
+  for (argc = 0; argc <= MAXARGV; argc++)
+    newtab->se_argv[argc] = sep->se_argv[argc] ?
+      newstr (sep->se_argv[argc]) : NULL;
+  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 == '#');
+  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 = newstr (arg);
+    arg = hostdelim + 1;
+                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
+#if ENABLE_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;
+#if ENABLE_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
+            {
+                uint16_t 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;
+#if ENABLE_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;
+#if ENABLE_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
+            {
+                uint16_t 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 /* 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();
     /*
+     * If the line is of the form `host:', then just change the
+     * default host for the following lines.
+     * Purge anything not looked at above.
      */
+    if (*arg == '\0') {
+      arg = skip (&cp);
+      if (cp == NULL) {
+        free (defhost);
+        defhost = sep->se_hostaddr;
+        goto more;
+      }
+    }
+  } else
+    sep->se_hostaddr = newstr (defhost);
+  sep->se_service = newstr (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 = newstr (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
+      syslog (LOG_ERR, "%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) {
+        syslog (LOG_ERR, "%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:
+        syslog (LOG_ERR, "%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
+    syslog (LOG_ERR, "%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 = atoi (s);
+    } else
+      sep->se_max = toomany;
+  }
+  sep->se_wait = strcmp (arg, "wait") == 0;
+  /* if ((arg = skip(&cp, 1)) == NULL) */
+  /* goto more; */
+  sep->se_user = newstr (skip (&cp));
+  arg = strchr (sep->se_user, '.');
+  if (arg == NULL)
+    arg = strchr (sep->se_user, ':');
+  if (arg) {
+    *arg++ = '\0';
+    sep->se_group = newstr (arg);
+  }
+  /* if ((arg = skip(&cp, 1)) == NULL) */
+  /* goto more; */
+  sep->se_server = newstr (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) {
+      syslog (LOG_ERR, "internal service %s unknown", sep->se_service);
+      goto more;
+    }
+    sep->se_bi = bi;
+    sep->se_wait = bi->bi_wait;
+#else
+    syslog (LOG_ERR, "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++] = newstr (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 = newstr (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) {
+          syslog (LOG_ERR, "%s: unknown host", nsep->se_hostaddr);
+          nsep->se_checked = 0;
+          goto skip;
+        } else if (hp->h_addrtype != AF_INET) {
+          syslog (LOG_ERR,
+                  "%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 = newstr (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;
+          }
+    Block_Using_Signals(omask);
+    sepp = &servtab;
+    while ((sep = *sepp)) {
+        if (sep->se_checked) {
+            sepp = &sep->se_next;
+            continue;
+        }
+      }
+    }
+/* 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;
+  int add;
+  size_t n;
+  char protoname[10];
+  if (!setconfig ()) {
+    syslog (LOG_ERR, "%s: %m", 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;
+    add = 0;
+    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);
+      add = 1;
+    } 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;
+        sep->se_rpcprog = atoi (sep->se_service);
+        if (sep->se_rpcprog == 0) {
+          rp = getrpcbyname (sep->se_service);
+          if (rp == 0) {
+            syslog (LOG_ERR, "%s: unknown rpc service", sep->se_service);
+            goto serv_unknown;
+          }
+          sep->se_rpcprog = rp->r_number;
+        *sepp = sep->se_next;
+        if (sep->se_fd != -1) {
+            FD_CLR(sep->se_fd, &allsock);
+            nsock--;
+            (void) close(sep->se_fd);
+        }
+#if ENABLE_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:
+#if ENABLE_FEATURE_IPV6
+            case AF_INET6:
+#endif
+                setup(sep);
+#if ENABLE_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)
+          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) {
+            syslog (LOG_ERR,
+                    "%s/%s: unknown service", sep->se_service, sep->se_proto);
+            goto serv_unknown;
+          }
+          port = sp->s_port;
+            continue;
+        switch (sep->se_family) {
+        case AF_UNIX:
+            (void) unlink(sep->se_service);
+            break;
+        case AF_INET:
+#if ENABLE_FEATURE_IPV6
+        case AF_INET6:
+#endif
+#if ENABLE_FEATURE_INETD_RPC
+            if (sep->se_wait == 1 && isrpcservice(sep))
+                unregister_rpc(sep);   /* XXX signal race */
+#endif
+            break;
+        }
+        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) {
+            syslog (LOG_ERR, "%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) {
+            syslog (LOG_ERR,
+                    "%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))
+          syslog (LOG_WARNING,
+                  "%s: exit status 0x%x",
+                  sep->se_server, WEXITSTATUS (status));
+        else if (WIFSIGNALED (status))
+          syslog (LOG_WARNING,
+                  "%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);
+        (void) close(sep->se_fd);
+    }
+    remove_pidfile(_PATH_INETDPID);
+    exit(0);
+}
 …
 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;
+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);
+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 (bb_applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
+  opt = bb_getopt_ulflags (argc, argv, "R:f", &stoomany);
+  if(opt & 1) {
+    char *e;
+    toomany = strtoul (stoomany, &e, 0);
+    if (!(toomany >= 0 && *e == '\0')) {
+        toomany = TOOMANY;
+        syslog (LOG_ERR, "-R %s: bad value for service invocation rate", 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
+    bb_xdaemon (0, 0);
+#endif
+  } else {
+    setsid ();
+  }
+  if (uid == 0) {
+    gid_t gid = getgid ();
+    /* If run by hand, ensure groups vector gets trashed */
+    setgroups (1, &gid);
+  }
+  {
+    FILE *fp;
+    if ((fp = fopen (_PATH_INETDPID, "w")) != NULL) {
+        fprintf (fp, "%u\n", getpid ());
+        (void) fclose (fp);
+    }
+  }
+  if (getrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0) {
+    syslog (LOG_ERR, "getrlimit: %m");
+  } 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);
+  /* doconfig(); */
+  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 */
+    char **envp = environ;
+    Argv = argv;
+    if (envp == 0 || *envp == 0)
+        envp = argv;
+    while (*envp)
+        envp++;
+    LastArg = envp[-1] + strlen(envp[-1]);
+#endif
+    uid = getuid();
+    if (uid != 0)
+        config_filename = NULL;
+    opt = getopt32(argv, "R:f", &stoomany);
+    if (opt & 1)
+        toomany = xatoi_u(stoomany);
+    argv += optind;
+    argc -= optind;
+    if (argc)
+        config_filename = argv[0];
+    if (config_filename == NULL)
+        bb_error_msg_and_die("non-root must specify a config file");
+    if (!(opt & 2))
+        bb_daemonize_or_rexec(0, argv - optind);
+    else
+        bb_sanitize_stdio();
+    openlog(applet_name, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
+    logmode = LOGMODE_SYSLOG;
+    if (uid == 0) {
+        /* If run by hand, ensure groups vector gets trashed */
+        gid_t gid = getgid();
+        setgroups(1, &gid);
+    }
+    write_pidfile(_PATH_INETDPID);
+    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;
+    if ((n = select (maxsock + 1, &readable, NULL, NULL, NULL)) <= 0) {
+      if (n < 0 && errno != EINTR) {
+        syslog (LOG_WARNING, "select: %m");
+        sleep (1);
+      }
+      continue;
+    }
+    for (sep = servtab; n && sep; sep = sep->se_next)
+      if (sep->se_fd != -1 && FD_ISSET (sep->se_fd, &readable)) {
+        n--;
+        if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) {
+          ctrl = accept (sep->se_fd, NULL, NULL);
+          if (ctrl < 0) {
+            if (errno == EINTR)
+              continue;
+            syslog (LOG_WARNING, "accept (for %s): %m", sep->se_service);
+        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;
+          }
+          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) {
+              syslog (LOG_WARNING, "could not getpeername");
+              close (ctrl);
+              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 (ntohs (peer.sin_port) == 20) {
+              /* XXX ftp bounce */
+              close (ctrl);
+              continue;
+            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;
+            }
+          }
+        } else
+          ctrl = sep->se_fd;
+        Block_Using_Signals(omask);
+        pid = 0;
+            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 == 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;
+              }
+              syslog (LOG_ERR,
+                      "%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;
+                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);
+                }
+            }
+          }
+          pid = fork ();
+        }
+        if (pid < 0) {
+          syslog (LOG_ERR, "fork: %m");
+          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
+            {
+            if ((pwd = getpwnam (sep->se_user)) == NULL) {
+              syslog (LOG_ERR, "getpwnam: %s: No such user", sep->se_user);
+              if (sep->se_socktype != SOCK_STREAM)
+                recv (0, buf, sizeof (buf), 0);
+              _exit (1);
+            }
+            if (setsid () < 0)
+              syslog (LOG_ERR, "%s: setsid: %m", sep->se_service);
+            if (sep->se_group && (grp = getgrnam (sep->se_group)) == NULL) {
+              syslog (LOG_ERR, "getgrnam: %s: No such group", sep->se_group);
+              if (sep->se_socktype != SOCK_STREAM)
+                recv (0, buf, sizeof (buf), 0);
+              _exit (1);
+            }
+            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);
+            close (ctrl);
+            dup2 (0, 1);
+            dup2 (0, 2);
+            if (rlim_ofile.rlim_cur != rlim_ofile_cur)
+              if (setrlimit (RLIMIT_NOFILE, &rlim_ofile) < 0)
+                syslog (LOG_ERR, "setrlimit: %m");
+            closelog ();
+            for (tmpint = rlim_ofile_cur - 1; --tmpint > 2;)
+              (void) close (tmpint);
+            sigaction (SIGPIPE, &sapipe, NULL);
+            execv (sep->se_server, sep->se_argv);
+            if (sep->se_socktype != SOCK_STREAM)
+              recv (0, buf, sizeof (buf), 0);
+            syslog (LOG_ERR, "execv %s: %m", sep->se_server);
+            _exit (1);
+          }
+        }
+        if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+          close (ctrl);
+      }
+  }
+            if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
+                close(ctrl);
+        } /* for (sep = servtab...) */
+    } /* for (;;) */
+}
 …
 #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
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_ECHO || \
+    ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN || \
+    ENABLE_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
+#if ENABLE_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 ((i = read (s, buffer, sizeof (buffer))) > 0 &&
+         write (s, buffer, i) > 0);
+  exit (0);
+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);
+}
 …
 /* 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);
+  if ((i = recvfrom (s, buffer, sizeof (buffer), 0, &sa, &size)) < 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
+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  /* FEATURE_INETD_SUPPORT_BUILTIN_ECHO */
+#if ENABLE_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 ((errno = 0, read (s, buffer, sizeof (buffer)) > 0) ||
+         errno == EINTR);
+  exit (0);
+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);
+    }
+}
 …
 /* 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
+discard_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+    char buffer[BUFSIZE];
+    (void) read(s, buffer, sizeof(buffer));
+}
+#endif /* FEATURE_INETD_SUPPORT_BUILTIN_DISCARD */
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN
 #define LINESIZ 72
 static char ring[128];
 …
 static void
 initring (void)
+{
   int i;
   endring = ring;
   for (i = 0; i <= 128; ++i)
     if (isprint (i))
       *endring++ = i;
+initring(void)
+{
+    int i;
+    endring = ring;
+    for (i = 0; i <= 128; ++i)
+        if (isprint(i))
+            *endring++ = i;
+}
 …
 /* 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 ();
+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;
+  }
+  text[LINESIZ] = '\r';
+  text[LINESIZ + 1] = '\n';
+  for (rs = ring;;) {
+    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;
+    if (write (s, text, sizeof (text)) != sizeof (text))
+      break;
+  }
+  exit (0);
+    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);
+}
 …
 /* 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
+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 /* FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN */
+#if ENABLE_FEATURE_INETD_SUPPORT_BUILTIN_TIME
 /*
  * Return a machine readable date and time, in the form of the
 …
  */
 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));
+static unsigned machtime(void)
+{
+    struct timeval tv;
+    if (gettimeofday(&tv, NULL) < 0) {
+        fprintf(stderr, "Unable to get time of day\n");
+        return 0L;
+    }
+    return htonl((unsigned) 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));
+machtime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+    unsigned 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
+machtime_dg(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+    unsigned 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 /* FEATURE_INETD_SUPPORT_BUILTIN_TIME */
+#if ENABLE_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));
+static void daytime_stream(int s, servtab_t *sep ATTRIBUTE_UNUSED)
+{
+    char buffer[32];
+    time_t t;
+    t = time(NULL);
+// fdprintf instead?
+    (void) sprintf(buffer, "%.24s\r\n", ctime(&t));
+    (void) write(s, buffer, strlen(buffer));
+}
 …
 /* 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 ((time_t *) 0);
+  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 */
+/* vi: set sw=4 ts=4: */
+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 /* FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME */

branches/stable/mindi-busybox/networking/interface.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * stolen from net-tools-1.59 and stripped down for busybox by
 …
  *              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>
 …
  */
-#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
+#include "inet_common.h"
+#include "libbb.h"
+#if ENABLE_FEATURE_IPV6
 # define HAVE_AFINET6 1
 #else
 …
 #define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
 #if HAVE_AFINET6
+#ifdef HAVE_AFINET6
 #ifndef _LINUX_IN6_H
 …
 #endif
 #endif                          /* HAVE_AFINET6 */
+#endif /* HAVE_AFINET6 */
 /* Defines for glibc2.0 users. */
 …
 #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];
+static const char *INET_sprint(struct sockaddr *sap, int numeric)
+{
+    static char *buff;
+    free(buff);
     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 = {
+        return "[NONE SET]";
+    buff = INET_rresolve((struct sockaddr_in *) sap, numeric, 0xffffff00);
+    return buff;
+}
+#ifdef UNUSED_AND_BUGGY
+static int INET_getsock(char *bufp, struct sockaddr *sap)
+{
+    char *sp = bufp, *bp;
+    unsigned int i;
+    unsigned val;
+    struct sockaddr_in *sock_in;
+    sock_in = (struct sockaddr_in *) sap;
+    sock_in->sin_family = AF_INET;
+    sock_in->sin_port = 0;
+    val = 0;
+    bp = (char *) &val;
+    for (i = 0; i < sizeof(sock_in->sin_addr.s_addr); i++) {
+        *sp = toupper(*sp);
+        if ((unsigned)(*sp - 'A') <= 5)
+            bp[i] |= (int) (*sp - ('A' - 10));
+        else if (isdigit(*sp))
+            bp[i] |= (int) (*sp - '0');
+        else
+            return -1;
+        bp[i] <<= 4;
+        sp++;
+        *sp = toupper(*sp);
+        if ((unsigned)(*sp - 'A') <= 5)
+            bp[i] |= (int) (*sp - ('A' - 10));
+        else if (isdigit(*sp))
+            bp[i] |= (int) (*sp - '0');
+        else
+            return -1;
+        sp++;
+    }
+    sock_in->sin_addr.s_addr = htonl(val);
+    return (sp - bufp);
+}
+#endif
+static int INET_input(/*int type,*/ const char *bufp, struct sockaddr *sap)
+{
+    return INET_resolve(bufp, (struct sockaddr_in *) sap, 0);
+/*
+    switch (type) {
+    case 1:
+        return (INET_getsock(bufp, sap));
+    case 256:
+        return (INET_resolve(bufp, (struct sockaddr_in *) sap, 1));
+    default:
+        return (INET_resolve(bufp, (struct sockaddr_in *) sap, 0));
+    }
+*/
+}
+static const struct aftype inet_aftype = {
     .name =     "inet",
     .title =    "DARPA Internet",
 …
     .alen =     4,
     .sprint =   INET_sprint,
     .fd =       -1
 };
 #if HAVE_AFINET6
+    .input =    INET_input,
+};
+#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];
+static const char *INET6_sprint(struct sockaddr *sap, int numeric)
+{
+    static char *buff;
+    free(buff);
     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 = {
+        return "[NONE SET]";
+    buff = INET6_rresolve((struct sockaddr_in6 *) sap, numeric);
+    return buff;
+}
+#ifdef UNUSED
+static int INET6_getsock(char *bufp, struct sockaddr *sap)
+{
+    struct sockaddr_in6 *sin6;
+    sin6 = (struct sockaddr_in6 *) sap;
+    sin6->sin6_family = AF_INET6;
+    sin6->sin6_port = 0;
+    if (inet_pton(AF_INET6, bufp, sin6->sin6_addr.s6_addr) <= 0)
+        return -1;
+    return 16;          /* ?;) */
+}
+#endif
+static int INET6_input(/*int type,*/ const char *bufp, struct sockaddr *sap)
+{
+    return INET6_resolve(bufp, (struct sockaddr_in6 *) sap);
+/*
+    switch (type) {
+    case 1:
+        return (INET6_getsock(bufp, sap));
+    default:
+        return (INET6_resolve(bufp, (struct sockaddr_in6 *) sap));
+    }
+*/
+}
+static const struct aftype inet6_aftype = {
     .name =     "inet6",
     .title =    "IPv6",
 …
     .alen =     sizeof(struct in6_addr),
     .sprint =   INET6_sprint,
     .fd =       -1
 };
 #endif                          /* HAVE_AFINET6 */
+    .input =    INET6_input,
+};
+#endif /* HAVE_AFINET6 */
 /* Display an UNSPEC address. */
 static char *UNSPEC_print(unsigned char *ptr)
+{
+    static char buff[sizeof(struct sockaddr) * 3 + 1];
+    static char *buff;
     char *pos;
     unsigned int i;
+    if (!buff);
+        buff = xmalloc(sizeof(struct sockaddr) * 3 + 1);
     pos = buff;
     for (i = 0; i < sizeof(struct sockaddr); i++) {
 …
     /* Erase trailing "-".  Works as long as sizeof(struct sockaddr) != 0 */
     *--pos = '\0';
     return (buff);
+    return buff;
+}
 /* Display an UNSPEC socket address. */
+static char *UNSPEC_sprint(struct sockaddr *sap, int numeric)
+{
+    static char buf[64];
+static const char *UNSPEC_sprint(struct sockaddr *sap, int numeric)
+{
     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[] = {
+        return "[NONE SET]";
+    return UNSPEC_print((unsigned char *)sap->sa_data);
+}
+static const struct aftype unspec_aftype = {
+    .name   = "unspec",
+    .title  = "UNSPEC",
+    .af     = AF_UNSPEC,
+    .alen    = 0,
+    .print  = UNSPEC_print,
+    .sprint = UNSPEC_sprint,
+};
+static const struct aftype *const aftypes[] = {
     &inet_aftype,
 #if HAVE_AFINET6
+#ifdef HAVE_AFINET6
     &inet6_aftype,
 #endif
 …
 /* Check our protocol family table for this family. */
+static struct aftype *get_afntype(int af)
+{
+    struct aftype * const *afp;
+const struct aftype *get_aftype(const char *name)
+{
+    const struct aftype *const *afp;
+    afp = aftypes;
+    while (*afp != NULL) {
+        if (!strcmp((*afp)->name, name))
+            return (*afp);
+        afp++;
+    }
+    return NULL;
+}
+/* Check our protocol family table for this family. */
+static const struct aftype *get_afntype(int af)
+{
+    const struct aftype *const *afp;
     afp = aftypes;
     while (*afp != NULL) {
         if ((*afp)->af == af)
             return (*afp);
+            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;
+    return NULL;
+}
 …
 int interface_opt_a = 0;    /* show all interfaces          */
+smallint 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)
+{
 …
     if (isdigit(*a) && isdigit(*b)) {
         return atoi(a_ptr) > atoi(b_ptr) ? 1 : -1;
+        return xatoul(a_ptr) > xatoul(b_ptr) ? 1 : -1;
+    }
     return *a - *b;
+}
+#endif
 static struct interface *add_interface(char *name)
 …
     for (ife = int_last; ife; ife = ife->prev) {
         int n = nstrcmp(ife->name, name);
+        int n = /*n*/strcmp(ife->name, name);
         if (n == 0)
 …
     *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;
+}
 …
  * args. */
 /* static const char * const ss_fmt[] = { */
+/* 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", */
 …
     /* Lie about the size of the int pointed to for %n. */
 #if INT_MAX == LONG_MAX
 static const char * const ss_fmt[] = {
+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",
 …
 };
 #else
 static const char * const ss_fmt[] = {
+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",
 …
+}
+static int if_readconf(void)
+{
+    int numreqs = 30;
+    struct ifconf ifc;
+    struct ifreq *ifr;
+    int n, err = -1;
+    int skfd;
+    ifc.ifc_buf = NULL;
+    /* SIOCGIFCONF currently seems to only work properly on AF_INET sockets
+       (as of 2.1.128) */
+    skfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (skfd < 0) {
+        bb_perror_msg("error: no inet socket available");
+        return -1;
+    }
+    for (;;) {
+        ifc.ifc_len = sizeof(struct ifreq) * numreqs;
+        ifc.ifc_buf = xrealloc(ifc.ifc_buf, ifc.ifc_len);
+        if (ioctl_or_warn(skfd, SIOCGIFCONF, &ifc) < 0) {
+            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:
+    close(skfd);
+    free(ifc.ifc_buf);
+    return err;
+}
 static int if_readlist_proc(char *target)
+{
+    static int proc_read;
+    static smallint proc_read;
     FILE *fh;
     char buf[512];
 …
     fh = fopen(_PATH_PROCNET_DEV, "r");
     if (!fh) {
         bb_perror_msg("Warning: cannot open %s. Limited output.", _PATH_PROCNET_DEV);
+        bb_perror_msg("warning: cannot open %s, limiting output", _PATH_PROCNET_DEV);
         return if_readconf();
+    }
 …
+    }
     if (ferror(fh)) {
         perror(_PATH_PROCNET_DEV);
+        bb_perror_msg(_PATH_PROCNET_DEV);
         err = -1;
         proc_read = 0;
 …
+{
     int err = if_readlist_proc(NULL);
+    /* Needed in order to get ethN:M aliases */
     if (!err)
         err = if_readconf();
 …
+}
-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;
+    strcpy(ifr.ifr_name, ifname);
+    if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0)
+        return (-1);
+    int skfd;
+    skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0) {
+        close(skfd);
+        return -1;
+    }
     ife->flags = ifr.ifr_flags;
+    strcpy(ifr.ifr_name, ifname);
+    if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
+        memset(ife->hwaddr, 0, 32);
+    else
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    memset(ife->hwaddr, 0, 32);
+    if (ioctl(skfd, SIOCGIFHWADDR, &ifr) >= 0)
         memcpy(ife->hwaddr, ifr.ifr_hwaddr.sa_data, 8);
     ife->type = ifr.ifr_hwaddr.sa_family;
+    strcpy(ifr.ifr_name, ifname);
+    if (ioctl(skfd, SIOCGIFMETRIC, &ifr) < 0)
+        ife->metric = 0;
+    else
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    ife->metric = 0;
+    if (ioctl(skfd, SIOCGIFMETRIC, &ifr) >= 0)
         ife->metric = ifr.ifr_metric;
+    strcpy(ifr.ifr_name, ifname);
+    if (ioctl(skfd, SIOCGIFMTU, &ifr) < 0)
+        ife->mtu = 0;
+    else
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    ife->mtu = 0;
+    if (ioctl(skfd, SIOCGIFMTU, &ifr) >= 0)
         ife->mtu = ifr.ifr_mtu;
+    memset(&ife->map, 0, sizeof(struct ifmap));
 #ifdef SIOCGIFMAP
     strcpy(ifr.ifr_name, ifname);
+    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));
+#endif
 #ifdef HAVE_TXQUEUELEN
+    strcpy(ifr.ifr_name, ifname);
+    if (ioctl(skfd, SIOCGIFTXQLEN, &ifr) < 0)
+        ife->tx_queue_len = -1; /* unknown value */
+    else
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    ife->tx_queue_len = -1; /* unknown value */
+    if (ioctl(skfd, SIOCGIFTXQLEN, &ifr) >= 0)
         ife->tx_queue_len = ifr.ifr_qlen;
 #else
 …
 #endif
+    /* IPv4 address? */
+    fd = get_socket_for_af(AF_INET);
+    if (fd >= 0) {
+        strcpy(ifr.ifr_name, ifname);
+        ifr.ifr_addr.sa_family = AF_INET;
+        if (ioctl(fd, SIOCGIFADDR, &ifr) == 0) {
+            ife->has_ip = 1;
+            ife->addr = ifr.ifr_addr;
+            strcpy(ifr.ifr_name, ifname);
+            if (ioctl(fd, SIOCGIFDSTADDR, &ifr) < 0)
+                memset(&ife->dstaddr, 0, sizeof(struct sockaddr));
+            else
+                ife->dstaddr = ifr.ifr_dstaddr;
+            strcpy(ifr.ifr_name, ifname);
+            if (ioctl(fd, SIOCGIFBRDADDR, &ifr) < 0)
+                memset(&ife->broadaddr, 0, sizeof(struct sockaddr));
+            else
+                ife->broadaddr = ifr.ifr_broadaddr;
+            strcpy(ifr.ifr_name, ifname);
+            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));
+    }
+    strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+    ifr.ifr_addr.sa_family = AF_INET;
+    memset(&ife->addr, 0, sizeof(struct sockaddr));
+    if (ioctl(skfd, SIOCGIFADDR, &ifr) == 0) {
+        ife->has_ip = 1;
+        ife->addr = ifr.ifr_addr;
+        strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+        memset(&ife->dstaddr, 0, sizeof(struct sockaddr));
+        if (ioctl(skfd, SIOCGIFDSTADDR, &ifr) >= 0)
+            ife->dstaddr = ifr.ifr_dstaddr;
+        strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+        memset(&ife->broadaddr, 0, sizeof(struct sockaddr));
+        if (ioctl(skfd, SIOCGIFBRDADDR, &ifr) >= 0)
+            ife->broadaddr = ifr.ifr_broadaddr;
+        strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+        memset(&ife->netmask, 0, sizeof(struct sockaddr));
+        if (ioctl(skfd, SIOCGIFNETMASK, &ifr) >= 0)
+            ife->netmask = ifr.ifr_netmask;
+    }
+    close(skfd);
     return 0;
+}
 …
+{
     if (if_fetch(ife) < 0) {
         char *errmsg;
+        const char *errmsg;
         if (errno == ENODEV) {
 …
+}
-/* 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",
 …
 #include <net/if_arp.h>
 #if (__GLIBC__ >=2 && __GLIBC_MINOR >= 1) || defined(_NEWLIB_VERSION)
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
 #include <net/ethernet.h>
 #else
 …
 static char *pr_ether(unsigned char *ptr)
+{
+    static char buff[64];
+    snprintf(buff, sizeof(buff), "%02X:%02X:%02X:%02X:%02X:%02X",
+    static char *buff;
+    free(buff);
+    buff = xasprintf("%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);
+}
+    return buff;
+}
+static int in_ether(const char *bufp, struct sockaddr *sap);
 static const struct hwtype ether_hwtype = {
 …
     .type =     ARPHRD_ETHER,
     .alen =     ETH_ALEN,
+    .print =    pr_ether
+};
+    .print =    pr_ether,
+    .input =    in_ether
+};
+static unsigned hexchar2int(char c)
+{
+    if (isdigit(c))
+        return c - '0';
+    c &= ~0x20; /* a -> A */
+    if ((unsigned)(c - 'A') <= 5)
+        return c - ('A' - 10);
+    return ~0U;
+}
+/* Input an Ethernet address and convert to binary. */
+static int in_ether(const char *bufp, struct sockaddr *sap)
+{
+    unsigned char *ptr;
+    char c;
+    int i;
+    unsigned val;
+    sap->sa_family = ether_hwtype.type;
+    ptr = (unsigned char*) sap->sa_data;
+    i = 0;
+    while ((*bufp != '\0') && (i < ETH_ALEN)) {
+        val = hexchar2int(*bufp++) * 0x10;
+        if (val > 0xff) {
+            errno = EINVAL;
+            return -1;
+        }
+        c = *bufp;
+        if (c == ':' || c == 0)
+            val >>= 4;
+        else {
+            val |= hexchar2int(c);
+            if (val > 0xff) {
+                errno = EINVAL;
+                return -1;
+            }
+        }
+        if (c != 0)
+            bufp++;
+        *ptr++ = (unsigned char) val;
+        i++;
+        /* We might get a semicolon here - not required. */
+        if (*bufp == ':') {
+            bufp++;
+        }
+    }
+    return 0;
+}
 #include <net/if_arp.h>
 …
 };
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
 static const struct hwtype sit_hwtype = {
     .name =         "sit",
 …
     .print =        UNSPEC_print,
     .suppress_null_addr =   1
 } ;
 #endif
 static const struct hwtype * const hwtypes[] = {
+};
+#endif
+static const struct hwtype *const hwtypes[] = {
     &loop_hwtype,
     &ether_hwtype,
     &ppp_hwtype,
     &unspec_hwtype,
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     &sit_hwtype,
 #endif
 …
 #ifdef IFF_PORTSEL
 static const char * const if_port_text[] = {
+static const char *const if_port_text[] = {
     /* Keep in step with <linux/netdevice.h> */
     "unknown",
 …
 /* Check our hardware type table for this type. */
+static const struct hwtype *get_hwntype(int type)
+{
+    const struct hwtype * const *hwp;
+const struct hwtype *get_hwtype(const char *name)
+{
+    const struct hwtype *const *hwp;
+    hwp = hwtypes;
+    while (*hwp != NULL) {
+        if (!strcmp((*hwp)->name, name))
+            return (*hwp);
+        hwp++;
+    }
+    return NULL;
+}
+/* Check our hardware type table for this type. */
+const struct hwtype *get_hwntype(int type)
+{
+    const struct hwtype *const *hwp;
     hwp = hwtypes;
     while (*hwp != NULL) {
         if ((*hwp)->type == type)
             return (*hwp);
+            return *hwp;
         hwp++;
+    }
     return (NULL);
+    return NULL;
+}
 …
+}
 static const char TRext[] = "\0\0\0Ki\0Mi\0Gi\0Ti";
+static const char TRext[] ALIGN1 = "\0\0\0Ki\0Mi\0Gi\0Ti";
 static void print_bytes_scaled(unsigned long long ull, const char *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
-};
 static void ife_print(struct interface *ptr)
+{
     struct aftype *ap;
+    const struct aftype *ap;
     const struct hwtype *hw;
     int hf;
     int can_compress = 0;
 #if HAVE_AFINET6
+#ifdef HAVE_AFINET6
     FILE *f;
     char addr6[40], devname[20];
 …
+    }
 #endif
     printf("\n");
+    puts("");
     if (ptr->has_ip) {
 …
+    }
 #if HAVE_AFINET6
+#ifdef HAVE_AFINET6
 #define IPV6_ADDR_ANY           0x0000U
 …
 #define IPV6_ADDR_RESERVED      0x2000U /* reserved address space */
+    if ((f = fopen(_PATH_PROCNET_IFINET6, "r")) != NULL) {
+    f = fopen(_PATH_PROCNET_IFINET6, "r");
+    if (f != NULL) {
         while (fscanf
                (f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
+               (f, "%4s%4s%4s%4s%4s%4s%4s%4s %08x %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) {
+                &dad_status, devname) != EOF
+        ) {
             if (!strcmp(devname, ptr->name)) {
                 sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
 …
                 sap.sin6_family = AF_INET6;
                 printf("          inet6 addr: %s/%d",
                        inet6_aftype.sprint((struct sockaddr *) &sap, 1),
+                       INET6_sprint((struct sockaddr *) &sap, 1),
                        plen);
                 printf(" Scope:");
                 switch (scope & IPV6_ADDR_SCOPE_MASK) {
                 case 0:
                     printf("Global");
+                    puts("Global");
                     break;
                 case IPV6_ADDR_LINKLOCAL:
                     printf("Link");
+                    puts("Link");
                     break;
                 case IPV6_ADDR_SITELOCAL:
                     printf("Site");
+                    puts("Site");
                     break;
                 case IPV6_ADDR_COMPATv4:
                     printf("Compat");
+                    puts("Compat");
                     break;
                 case IPV6_ADDR_LOOPBACK:
                     printf("Host");
+                    puts("Host");
                     break;
                 default:
                     printf("Unknown");
+                    puts("Unknown");
+                }
-                printf("\n");
+            }
+        }
 …
         printf("[NO FLAGS] ");
     } else {
+        int i = 0;
+        static const char ife_print_flags_strs[] ALIGN1 =
+            "UP\0"
+            "BROADCAST\0"
+            "DEBUG\0"
+            "LOOPBACK\0"
+            "POINTOPOINT\0"
+            "NOTRAILERS\0"
+            "RUNNING\0"
+            "NOARP\0"
+            "PROMISC\0"
+            "ALLMULTI\0"
+            "SLAVE\0"
+            "MASTER\0"
+            "MULTICAST\0"
+#ifdef HAVE_DYNAMIC
+            "DYNAMIC\0"
+#endif
+            ;
+        static const unsigned short ife_print_flags_mask[] ALIGN2 = {
+            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
+        };
+        const unsigned short *mask = ife_print_flags_mask;
+        const char *str = ife_print_flags_strs;
         do {
             if (ptr->flags & ife_print_flags_mask[i]) {
                 printf(ife_print_flags_strs[i]);
+            if (ptr->flags & *mask) {
+                printf("%s ", str);
+            }
+        } while (ife_print_flags_mask[++i]);
+            mask++;
+            str += strlen(str) + 1;
+        } while (*str);
+    }
 …
         printf("  Outfill:%d  Keepalive:%d", ptr->outfill, ptr->keepalive);
 #endif
     printf("\n");
+    puts("");
     /* If needed, display the interface statistics. */
 …
         if (ptr->map.dma)
             printf("DMA chan:%x ", ptr->map.dma);
+        printf("\n");
+    }
+    printf("\n");
+}
+static int do_if_print(struct interface *ife, void *cookie)
+{
+    int *opt_a = (int *) cookie;
+        puts("");
+    }
+    puts("");
+}
+static int do_if_print(struct interface *ife) /*, int *opt_a)*/
+{
     int res;
     res = do_if_fetch(ife);
     if (res >= 0) {
         if ((ife->flags & IFF_UP) || *opt_a)
+        if ((ife->flags & IFF_UP) || interface_opt_a)
             ife_print(ife);
+    }
 …
+}
+#ifdef UNUSED
+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;
+}
+#endif
 /* for ipv4 add/del modes */
 static int if_print(char *ifname)
+{
+    struct interface *ife;
     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);
+    }
+        /*res = for_all_interfaces(do_if_print, &interface_opt_a);*/
+        if (!int_list && (if_readlist() < 0))
+            return -1;
+        for (ife = int_list; ife; ife = ife->next) {
+            int err = do_if_print(ife); /*, &interface_opt_a);*/
+            if (err)
+                return err;
+        }
+        return 0;
+    }
+    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);
+}
+    return (status < 0); /* status < 0 == 1 -- error */
+}

branches/stable/mindi-busybox/networking/ip.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ip.c     "ip" utility frontend.
 …
+ *
  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * Bernhard Fischer rewrote to use index_in_substr_array
  */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <string.h>
+#include "libbb.h"
 #include "libiproute/utils.h"
 #include "libiproute/ip_common.h"
+#include "busybox.h"
+#if ENABLE_FEATURE_IP_ADDRESS \
+ || ENABLE_FEATURE_IP_ROUTE \
+ || ENABLE_FEATURE_IP_LINK \
+ || ENABLE_FEATURE_IP_TUNNEL \
+ || ENABLE_FEATURE_IP_RULE
+#if 0
+int preferred_family = AF_UNSPEC;
 int oneline = 0;
+char * _SL_ = NULL;
+static int ATTRIBUTE_NORETURN ip_print_help(int ATTRIBUTE_UNUSED ac, char ATTRIBUTE_UNUSED **av)
+{
+    bb_show_usage();
+}
+void ip_parse_common_args(int *argcp, char ***argvp)
+static int (*ip_func)(int argc, char **argv) = ip_print_help;
+static int ip_do(int argc, char **argv)
+{
+    int argc = *argcp;
+    char **argv = *argvp;
+    ip_parse_common_args(&argc, &argv);
+    return ip_func(argc-1, argv+1);
+}
+    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 (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(bb_msg_invalid_arg, argv[1], "-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" ;
+#if ENABLE_FEATURE_IP_ADDRESS
+int ipaddr_main(int argc, char **argv);
+int ipaddr_main(int argc, char **argv)
+{
+    ip_func = do_ipaddr;
+    return ip_do(argc, argv);
+}
+#endif
+#if ENABLE_FEATURE_IP_LINK
+int iplink_main(int argc, char **argv);
+int iplink_main(int argc, char **argv)
+{
+    ip_func = do_iplink;
+    return ip_do(argc, argv);
+}
+#endif
+#if ENABLE_FEATURE_IP_ROUTE
+int iproute_main(int argc, char **argv);
+int iproute_main(int argc, char **argv)
+{
+    ip_func = do_iproute;
+    return ip_do(argc, argv);
+}
+#endif
+#if ENABLE_FEATURE_IP_RULE
+int iprule_main(int argc, char **argv);
+int iprule_main(int argc, char **argv)
+{
+    ip_func = do_iprule;
+    return ip_do(argc, argv);
+}
+#endif
+#if ENABLE_FEATURE_IP_TUNNEL
+int iptunnel_main(int argc, char **argv);
+int iptunnel_main(int argc, char **argv)
+{
+    ip_func = do_iptunnel;
+    return ip_do(argc, argv);
+}
 #endif
+int ip_main(int argc, char **argv);
 int ip_main(int argc, char **argv)
+{
+    int ret = EXIT_FAILURE;
+    static const char keywords[] ALIGN1 =
+        USE_FEATURE_IP_ADDRESS("address\0")
+        USE_FEATURE_IP_ROUTE("route\0")
+        USE_FEATURE_IP_LINK("link\0")
+        USE_FEATURE_IP_TUNNEL("tunnel\0" "tunl\0")
+        USE_FEATURE_IP_RULE("rule\0")
+        ;
+    enum {
+        USE_FEATURE_IP_ADDRESS(IP_addr,)
+        USE_FEATURE_IP_ROUTE(IP_route,)
+        USE_FEATURE_IP_LINK(IP_link,)
+        USE_FEATURE_IP_TUNNEL(IP_tunnel, IP_tunl,)
+        USE_FEATURE_IP_RULE(IP_rule,)
+        IP_none
+    };
     ip_parse_common_args(&argc, &argv);
     if (argc > 1) {
+#ifdef CONFIG_FEATURE_IP_ADDRESS
+        if (matches(argv[1], "address") == 0) {
+            ret = do_ipaddr(argc-2, argv+2);
+        }
+        int key = index_in_substrings(keywords, argv[1]);
+        argc -= 2;
+        argv += 2;
+#if ENABLE_FEATURE_IP_ADDRESS
+        if (key == IP_addr)
+            ip_func = do_ipaddr;
 #endif
+#ifdef CONFIG_FEATURE_IP_ROUTE
+        if (matches(argv[1], "route") == 0) {
+            ret = do_iproute(argc-2, argv+2);
+        }
+#if ENABLE_FEATURE_IP_ROUTE
+        if (key == IP_route)
+            ip_func = do_iproute;
 #endif
+#ifdef CONFIG_FEATURE_IP_LINK
+        if (matches(argv[1], "link") == 0) {
+            ret = do_iplink(argc-2, argv+2);
+        }
+#if ENABLE_FEATURE_IP_LINK
+        if (key == IP_link)
+            ip_func = do_iplink;
 #endif
+#ifdef CONFIG_FEATURE_IP_TUNNEL
+        if (matches(argv[1], "tunnel") == 0 || strcmp(argv[1], "tunl") == 0) {
+            ret = do_iptunnel(argc-2, argv+2);
+        }
+#if ENABLE_FEATURE_IP_TUNNEL
+        if (key == IP_tunnel || key == IP_tunl)
+            ip_func = do_iptunnel;
+#endif
+#if ENABLE_FEATURE_IP_RULE
+        if (key == IP_rule)
+            ip_func = do_iprule;
 #endif
+    }
+    if (ret) {
+        bb_show_usage();
+    }
+    return(EXIT_SUCCESS);
+    return ip_func(argc, argv);
+}
+#endif /* any of ENABLE_FEATURE_IP_xxx is 1 */

branches/stable/mindi-busybox/networking/ipcalc.c

-              r821
+              r1770
 /* vi: set sw=4 ts=4 ai: */
+/* vi: set sw=4 ts=4: */
 /*
  * Mini ipcalc implementation for busybox
 …
  */
-#include "busybox.h"
-#include <ctype.h>
 #include <getopt.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #define IPCALC_MSG(CMD,ALTCMD) if (mode & SILENT) {ALTCMD;} else {CMD;}
+#include "libbb.h"
 #define CLASS_A_NETMASK ntohl(0xFF000000)
 …
+}
 #ifdef CONFIG_FEATURE_IPCALC_FANCY
+#if ENABLE_FEATURE_IPCALC_FANCY
 static int get_prefix(unsigned long netmask)
+{
 …
     netmask = htonl(netmask);
     while(msk) {
+    while (msk) {
         if (netmask & msk)
             ret++;
 …
 #endif
 #define NETMASK   0x01
 #define BROADCAST 0x02
 …
 #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'},
+#ifdef CONFIG_FEATURE_IPCALC_FANCY
+        {"prefix",      no_argument, NULL, 'p'},
+        {"hostname",    no_argument, NULL, 'h'},
+        {"silent",      no_argument, NULL, 's'},
+#endif
+        {NULL, 0, NULL, 0}
+    };
+#else
+#define long_options 0
+    static const char ipcalc_longopts[] ALIGN1 =
+        "netmask\0"   No_argument "m"
+        "broadcast\0" No_argument "b"
+        "network\0"   No_argument "n"
+# if ENABLE_FEATURE_IPCALC_FANCY
+        "prefix\0"    No_argument "p"
+        "hostname\0"  No_argument "h"
+        "silent\0"    No_argument "s"
+# endif
+        ;
 #endif
+int ipcalc_main(int argc, char **argv);
 int ipcalc_main(int argc, char **argv)
+{
     unsigned long mode;
+    unsigned opt;
     int have_netmask = 0;
     in_addr_t netmask, broadcast, network, ipaddr;
 …
     char *ipstr;
+    if (ENABLE_FEATURE_IPCALC_LONG_OPTIONS)
+        bb_applet_long_options = long_options;
+    mode = bb_getopt_ulflags(argc, argv, "mbn" USE_FEATURE_IPCALC_FANCY("phs"));
+#if ENABLE_FEATURE_IPCALC_LONG_OPTIONS
+    applet_long_options = ipcalc_longopts;
+#endif
+    opt = getopt32(argv, "mbn" USE_FEATURE_IPCALC_FANCY("phs"));
     argc -= optind;
     argv += optind;
     if (mode & (BROADCAST | NETWORK | NETPREFIX)) {
+    if (opt & (BROADCAST | NETWORK | NETPREFIX)) {
         if (argc > 2 || argc <= 0)
             bb_show_usage();
 …
             bb_show_usage();
+    }
+    if (opt & SILENT)
+        logmode = LOGMODE_NONE; /* Suppress error_msg() output */
     ipstr = argv[0];
 …
         prefixstr = ipstr;
         while(*prefixstr) {
+        while (*prefixstr) {
             if (*prefixstr == '/') {
                 *prefixstr = (char)0;
                 prefixstr++;
                 if (*prefixstr) {
+                    unsigned int msk;
+                    if (safe_strtoul(prefixstr, &netprefix) || netprefix > 32) {
+                        IPCALC_MSG(bb_error_msg_and_die("bad IP prefix: %s\n", prefixstr),
+                                exit(EXIT_FAILURE));
+                    }
+                    unsigned msk;
+                    netprefix = xatoul_range(prefixstr, 0, 32);
                     netmask = 0;
                     msk = 0x80000000;
 …
     if (ipaddr == 0) {
+        IPCALC_MSG(bb_error_msg_and_die("bad IP address: %s", argv[0]),
+                exit(EXIT_FAILURE));
+        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) {
+            IPCALC_MSG(bb_error_msg_and_die("Use prefix or netmask, not both.\n"),
+                    exit(EXIT_FAILURE));
+            bb_error_msg_and_die("use prefix or netmask, not both");
+        }
         netmask = inet_aton(argv[1], &a);
         if (netmask == 0) {
+            IPCALC_MSG(bb_error_msg_and_die("bad netmask: %s", argv[1]),
+                    exit(EXIT_FAILURE));
+            bb_error_msg_and_die("bad netmask: %s", argv[1]);
+        }
         netmask = a.s_addr;
 …
+    }
     if (mode & NETMASK) {
+    if (opt & NETMASK) {
         printf("NETMASK=%s\n", inet_ntoa((*(struct in_addr *) &netmask)));
+    }
     if (mode & BROADCAST) {
+    if (opt & BROADCAST) {
         broadcast = (ipaddr & netmask) | ~netmask;
         printf("BROADCAST=%s\n", inet_ntoa((*(struct in_addr *) &broadcast)));
+    }
     if (mode & NETWORK) {
+    if (opt & NETWORK) {
         network = ipaddr & netmask;
         printf("NETWORK=%s\n", inet_ntoa((*(struct in_addr *) &network)));
 …
     if (ENABLE_FEATURE_IPCALC_FANCY) {
         if (mode & NETPREFIX) {
+        if (opt & NETPREFIX) {
             printf("PREFIX=%i\n", get_prefix(netmask));
+        }
         if (mode & HOSTNAME) {
+        if (opt & HOSTNAME) {
             struct hostent *hostinfo;
             int x;
 …
             hostinfo = gethostbyaddr((char *) &ipaddr, sizeof(ipaddr), AF_INET);
             if (!hostinfo) {
+                IPCALC_MSG(bb_herror_msg_and_die(
+                            "cannot find hostname for %s", argv[0]),);
+                exit(EXIT_FAILURE);
+                bb_herror_msg_and_die("cannot find hostname for %s", argv[0]);
+            }
             for (x = 0; hostinfo->h_name[x]; x++) {

branches/stable/mindi-busybox/networking/libiproute/ip_common.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 #ifndef _IP_COMMON_H
 #define _IP_COMMON_H 1
 #include "busybox.h"
+#include "libbb.h"
 #include <asm/types.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
+extern int preferred_family;
+extern char * _SL_;
+#if !defined IFA_RTA
+#include <linux/if_addr.h>
+#endif
+#if !defined IFLA_RTA
+#include <linux/if_link.h>
+#endif
 extern void ip_parse_common_args(int *argcp, char ***argvp);
 …
 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);

branches/stable/mindi-busybox/networking/libiproute/ip_parse_common_args.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ip.c     "ip" utility frontend.
 …
  */
+#include <string.h>
+#include "libbb.h"
+#include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "utils.h"
-#include "ip_common.h"
 int preferred_family = AF_UNSPEC;
 int oneline = 0;
 char * _SL_ = NULL;
+smallint oneline;
+char _SL_;
 void ip_parse_common_args(int *argcp, char ***argvp)
 …
     int argc = *argcp;
     char **argv = *argvp;
+    static const char ip_common_commands[] ALIGN1 =
+        "-family\0""inet\0""inet6\0""link\0"
+        "-4\0""-6\0""-0\0""-oneline\0";
+    enum {
+        ARG_family = 1,
+        ARG_inet,
+        ARG_inet6,
+        ARG_link,
+        ARG_IPv4,
+        ARG_IPv6,
+        ARG_packet,
+        ARG_oneline
+    };
+    smalluint arg;
     while (argc > 1) {
 …
         if (strcmp(opt,"--") == 0) {
+            argc--; argv++;
+            argc--;
+            argv++;
             break;
+        }
         if (opt[0] != '-')
             break;
         if (opt[1] == '-')
             opt++;
         if (matches(opt, "-family") == 0) {
+        arg = index_in_strings(ip_common_commands, opt) + 1;
+        if (arg == ARG_family) {
             argc--;
             argv++;
+            if (! argv[1])
+                bb_show_usage();
+            if (strcmp(argv[1], "inet") == 0)
+            if (!argv[1])
+                bb_show_usage();
+            arg = index_in_strings(ip_common_commands, argv[1]) + 1;
+            if (arg == ARG_inet)
                 preferred_family = AF_INET;
             else if (strcmp(argv[1], "inet6") == 0)
+            else if (arg == ARG_inet6)
                 preferred_family = AF_INET6;
             else if (strcmp(argv[1], "link") == 0)
+            else if (arg == ARG_link)
                 preferred_family = AF_PACKET;
             else
                 invarg(argv[1], "protocol family");
         } else if (strcmp(opt, "-4") == 0) {
+        } else if (arg == ARG_IPv4) {
             preferred_family = AF_INET;
         } else if (strcmp(opt, "-6") == 0) {
+        } else if (arg == ARG_IPv6) {
             preferred_family = AF_INET6;
         } else if (strcmp(opt, "-0") == 0) {
+        } else if (arg == ARG_packet) {
             preferred_family = AF_PACKET;
         } else if (matches(opt, "-oneline") == 0) {
+        } else if (arg == ARG_oneline) {
             ++oneline;
         } else {
             bb_show_usage();
+        }
+        argc--; argv++;
+        argc--;
+        argv++;
+    }
     _SL_ = oneline ? "\\" : "\n" ;
+    _SL_ = oneline ? '\\' : '\n';
     *argcp = argc;
     *argvp = argv;

branches/stable/mindi-busybox/networking/libiproute/ipaddress.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ipaddress.c      "ip address".
 …
  */
+#include "libbb.h"
+#include <sys/socket.h>
+#include <sys/ioctl.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 "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
+#include "ip_common.h"
+static struct
+{
+typedef struct filter_t {
     int ifindex;
     int family;
 …
     int flushe;
     struct rtnl_handle *rth;
+} filter;
+} filter_t;
+#define filter (*(filter_t*)&bb_common_bufsiz1)
 static void print_link_flags(FILE *fp, unsigned flags, unsigned mdown)
 …
     flags &= ~IFF_RUNNING;
 #define _PF(f) if (flags&IFF_##f) { \
           flags &= ~IFF_##f ; \
+          flags &= ~IFF_##f; \
           fprintf(fp, #f "%s", flags ? "," : ""); }
     _PF(LOOPBACK);
 …
     memset(&ifr, 0, sizeof(ifr));
+    strcpy(ifr.ifr_name, name);
+    if (ioctl(s, SIOCGIFTXQLEN, &ifr) < 0) {
+        perror("SIOCGIFXQLEN");
+    strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
+    if (ioctl_or_warn(s, SIOCGIFTXQLEN, &ifr) < 0) {
         close(s);
         return;
 …
 static int print_linkinfo(struct sockaddr_nl ATTRIBUTE_UNUSED *who,
         struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
+        const struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
+{
     FILE *fp = (FILE*)arg;
 …
         return -1;
+    }
+    if (filter.label &&
+        (!filter.family || filter.family == AF_PACKET) &&
+        fnmatch(filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0))
+        return 0;
+    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)
 …
     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)));
+        fprintf(fp, "%c    link/%s ", _SL_, ll_type_n2a(ifi->ifi_type, b1, sizeof(b1)));
         if (tb[IFLA_ADDRESS]) {
 …
+        }
+    }
     fprintf(fp, "\n");
+    fputc('\n', fp);
     fflush(fp);
     return 0;
 …
+{
     if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
         perror("Failed to send flush request\n");
+        bb_perror_msg("failed to send flush request");
         return -1;
+    }
 …
         struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
         char buf[128];
         fprintf(fp, "%s", _SL_);
+        fputc(_SL_, fp);
         if (ci->ifa_valid == 0xFFFFFFFFU)
             sprintf(buf, "valid_lft forever");
 …
         fprintf(fp, "       %s", buf);
+    }
     fprintf(fp, "\n");
+    fputc('\n', fp);
     fflush(fp);
     return 0;
 …
 static int print_selected_addrinfo(int ifindex, struct nlmsg_list *ainfo, FILE *fp)
+{
     for ( ;ainfo ;  ainfo = ainfo->next) {
+    for (; ainfo; ainfo = ainfo->next) {
         struct nlmsghdr *n = &ainfo->h;
         struct ifaddrmsg *ifa = NLMSG_DATA(n);
 …
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 int ipaddr_list_or_flush(int argc, char **argv, int flush)
+{
     static const char *const option[] = { "to", "scope", "up", "label", "dev", 0 };
+    static const char option[] ALIGN1 = "to\0""scope\0""up\0""label\0""dev\0";
     struct nlmsg_list *linfo = NULL;
 …
     if (flush) {
         if (argc <= 0) {
+            bb_error_msg(bb_msg_requires_arg, "flush");
+            return -1;
+            bb_error_msg_and_die(bb_msg_requires_arg, "flush");
+        }
         if (filter.family == AF_PACKET) {
+            bb_error_msg("Cannot flush link addresses.");
+            return -1;
+            bb_error_msg_and_die("cannot flush link addresses");
+        }
+    }
     while (argc > 0) {
         const int option_num = compare_string_array(option, *argv);
+        const int option_num = index_in_strings(option, *argv);
         switch (option_num) {
             case 0: /* to */
 …
+    }
+    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");
+    }
+    xrtnl_open(&rth);
+    xrtnl_wilddump_request(&rth, preferred_family, RTM_GETLINK);
+    xrtnl_dump_filter(&rth, store_nlmsg, &linfo);
     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;
+        }
+        filter.ifindex = xll_name_to_index(filter_dev);
+    }
 …
         for (;;) {
+            if (rtnl_wilddump_request(&rth, filter.family, RTM_GETADDR) < 0) {
+                perror("Cannot send dump request");
+                exit(1);
+            }
+            xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);
             filter.flushed = 0;
+            if (rtnl_dump_filter(&rth, print_addrinfo, stdout, NULL, NULL) < 0) {
+                fprintf(stderr, "Flush terminated\n");
+                exit(1);
+            }
+            xrtnl_dump_filter(&rth, print_addrinfo, stdout);
             if (filter.flushed == 0) {
-                fflush(stdout);
                 return 0;
+            }
             if (flush_update() < 0)
                 exit(1);
+                return 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");
+        }
+        xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);
+        xrtnl_dump_filter(&rth, store_nlmsg, &ainfo);
+    }
 …
+    }
     for (l=linfo; l; l = 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);
 …
                 print_selected_addrinfo(ifi->ifi_index, ainfo, stdout);
+        }
         fflush(stdout);
+    }
     exit(0);
+        fflush(stdout); /* why? */
+    }
+    return 0;
+}
 …
+{
     if (lcl->family == AF_INET) {
         if (lcl->bytelen >= 1 && *(__u8*)&lcl->data == 127)
+        if (lcl->bytelen >= 1 && *(uint8_t*)&lcl->data == 127)
             return RT_SCOPE_HOST;
+    }
 …
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 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
+    };
+    static const char option[] ALIGN1 =
+        "peer\0""remote\0""broadcast\0""brd\0"
+        "anycast\0""scope\0""dev\0""label\0""local\0";
     struct rtnl_handle rth;
     struct {
         struct nlmsghdr     n;
         struct ifaddrmsg    ifa;
         char            buf[256];
+        struct nlmsghdr  n;
+        struct ifaddrmsg ifa;
+        char             buf[256];
     } req;
     char  *d = NULL;
     char  *l = NULL;
+    char *d = NULL;
+    char *l = NULL;
     inet_prefix lcl;
     inet_prefix peer;
 …
     int brd_len = 0;
     int any_len = 0;
     int scoped = 0;
+    bool scoped = 0;
     memset(&req, 0, sizeof(req));
 …
     while (argc > 0) {
         const int option_num = compare_string_array(option, *argv);
+        const int option_num = index_in_strings(option, *argv);
         switch (option_num) {
             case 0: /* peer */
 …
                     duparg("broadcast", *argv);
+                }
                 if (strcmp(*argv, "+") == 0) {
+                if (LONE_CHAR(*argv, '+')) {
                     brd_len = -1;
+                }
                 else if (strcmp(*argv, "-") == 0) {
+                else if (LONE_DASH(*argv)) {
                     brd_len = -2;
                 } else {
 …
         return -1;
+    }
     if (l && matches(d, l) != 0) {
+    if (l && strncmp(d, l, strlen(d)) != 0) {
         bb_error_msg_and_die("\"dev\" (%s) must match \"label\" (%s)", d, l);
+    }
 …
         int i;
         if (req.ifa.ifa_family != AF_INET) {
+            bb_error_msg("Broadcast can be set only for IPv4 addresses");
+            return -1;
+            bb_error_msg_and_die("broadcast can be set only for IPv4 addresses");
+        }
         brd = peer;
 …
         req.ifa.ifa_scope = default_scope(&lcl);
+    if (rtnl_open(&rth, 0) < 0)
+        exit(1);
+    xrtnl_open(&rth);
     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;
+    }
+    req.ifa.ifa_index = xll_name_to_index(d);
     if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+        exit(2);
+    exit(0);
+}
+        return 2;
+    return 0;
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 int do_ipaddr(int argc, char **argv)
+{
+    static const char *const commands[] = {
+        "add", "delete", "list", "show", "lst", "flush", 0
+    };
+    int command_num = 2;
+    static const char commands[] ALIGN1 =
+        "add\0""delete\0""list\0""show\0""lst\0""flush\0";
+    int command_num = 2; /* default command is list */
     if (*argv) {
+        command_num = compare_string_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);
+}
+        command_num = index_in_substrings(commands, *argv);
+    }
+    if (command_num < 0 || command_num > 5)
+        bb_error_msg_and_die("unknown command %s", *argv);
+    --argc;
+    ++argv;
+    if (command_num == 0) /* add */
+        return ipaddr_modify(RTM_NEWADDR, argc, argv);
+    else if (command_num == 1) /* delete */
+        return ipaddr_modify(RTM_DELADDR, argc, argv);
+    else if (command_num == 5) /* flush */
+        return ipaddr_list_or_flush(argc, argv, 1);
+    else /* 2 == list, 3 == show, 4 == lst */
+        return ipaddr_list_or_flush(argc, argv, 0);
+}

branches/stable/mindi-busybox/networking/libiproute/iplink.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * iplink.c     "ip link".
+ * iplink.c "ip link".
+ *
  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * 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 <sys/ioctl.h>
+//#include <sys/socket.h>
 #include <net/if.h>
 #include <net/if_packet.h>
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
+#include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
+#include "ip_common.h"
+/* take from linux/sockios.h */
+/* taken from linux/sockios.h */
 #define SIOCSIFNAME 0x8923      /* set interface name */
+static int do_link;
+static int on_off(char *msg)
+{
+    bb_error_msg("Error: argument of \"%s\" must be \"on\" or \"off\"", msg);
+    return -1;
+}
+static void on_off(const char *msg) ATTRIBUTE_NORETURN;
+static void on_off(const char *msg)
+{
+    bb_error_msg_and_die("error: argument of \"%s\" must be \"on\" or \"off\"", msg);
+}
+/* Exits on error */
 static int get_ctl_fd(void)
+{
-    int s_errno;
     int fd;
 …
     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)
+    return xsocket(PF_INET6, SOCK_DGRAM, 0);
+}
+/* Exits on error */
+static void do_chflags(char *dev, uint32_t flags, uint32_t mask)
+{
     struct ifreq ifr;
     int fd;
+    int err;
+    strcpy(ifr.ifr_name, dev);
+    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) {
+    xioctl(fd, SIOCGIFFLAGS, &ifr);
+    if ((ifr.ifr_flags ^ flags) & mask) {
         ifr.ifr_flags &= ~mask;
+        ifr.ifr_flags |= mask&flags;
+        err = ioctl(fd, SIOCSIFFLAGS, &ifr);
+        if (err)
+            perror("SIOCSIFFLAGS");
+        ifr.ifr_flags |= mask & flags;
+        xioctl(fd, SIOCSIFFLAGS, &ifr);
+    }
     close(fd);
+    return err;
+}
 static int do_changename(char *dev, char *newdev)
+}
+/* Exits on error */
+static void do_changename(char *dev, char *newdev)
+{
     struct ifreq ifr;
     int fd;
+    int err;
+    strcpy(ifr.ifr_name, dev);
+    strcpy(ifr.ifr_newname, newdev);
+    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;
+    }
+    xioctl(fd, SIOCSIFNAME, &ifr);
     close(fd);
+    return err;
+}
 static int set_qlen(char *dev, int qlen)
+}
+/* Exits on error */
+static void set_qlen(char *dev, int qlen)
+{
     struct ifreq ifr;
 …
     s = get_ctl_fd();
-    if (s < 0)
-        return -1;
     memset(&ifr, 0, sizeof(ifr));
     strcpy(ifr.ifr_name, dev);
+    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)
+    xioctl(s, SIOCSIFTXQLEN, &ifr);
+    close(s);
+}
+/* Exits on error */
+static void set_mtu(char *dev, int mtu)
+{
     struct ifreq ifr;
 …
     s = get_ctl_fd();
-    if (s < 0)
-        return -1;
     memset(&ifr, 0, sizeof(ifr));
     strcpy(ifr.ifr_name, dev);
+    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;
+}
+    xioctl(s, SIOCSIFMTU, &ifr);
+    close(s);
+}
+/* Exits on error */
 static int get_address(char *dev, int *htype)
+{
 …
     int s;
+    s = socket(PF_PACKET, SOCK_DGRAM, 0);
+    if (s < 0) {
+        perror("socket(PF_PACKET)");
+        return -1;
+    }
+    s = xsocket(PF_PACKET, SOCK_DGRAM, 0);
     memset(&ifr, 0, sizeof(ifr));
+    strcpy(ifr.ifr_name, dev);
+    if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
+        perror("SIOCGIFINDEX");
+        close(s);
+        return -1;
+    }
+    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    xioctl(s, SIOCGIFINDEX, &ifr);
     memset(&me, 0, sizeof(me));
 …
     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;
+    }
+    xbind(s, (struct sockaddr*)&me, sizeof(me));
     alen = sizeof(me);
     if (getsockname(s, (struct sockaddr*)&me, &alen) == -1) {
+        perror("getsockname");
+        close(s);
+        return -1;
+        bb_perror_msg_and_die("getsockname");
+    }
     close(s);
 …
+}
+static int parse_address(char *dev, int hatype, int halen, char *lla, struct ifreq *ifr)
+/* Exits on error */
+static void parse_address(char *dev, int hatype, int halen, char *lla, struct ifreq *ifr)
+{
     int alen;
     memset(ifr, 0, sizeof(*ifr));
     strcpy(ifr->ifr_name, dev);
+    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;
+        exit(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)
+        bb_error_msg_and_die("wrong address (%s) length: expected %d bytes", lla, halen);
+    }
+}
+/* Exits on error */
+static void 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;
+}
+    if (brd)
+        xioctl(s, SIOCSIFHWBROADCAST, ifr);
+    else
+        xioctl(s, SIOCSIFHWADDR, ifr);
+    close(s);
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int do_set(int argc, char **argv)
+{
     char *dev = NULL;
     __u32 mask = 0;
     __u32 flags = 0;
+    uint32_t mask = 0;
+    uint32_t flags = 0;
     int qlen = -1;
     int mtu = -1;
 …
     char *newname = NULL;
     int htype, halen;
+    static const char keywords[] ALIGN1 =
+        "up\0""down\0""name\0""mtu\0""multicast\0""arp\0""addr\0""dev\0"
+        "on\0""off\0";
+    enum { ARG_up = 1, ARG_down, ARG_name, ARG_mtu, ARG_multicast, ARG_arp,
+        ARG_addr, ARG_dev, PARM_on, PARM_off };
+    smalluint key;
     while (argc > 0) {
+        if (strcmp(*argv, "up") == 0) {
+        key = index_in_strings(keywords, *argv) + 1;
+        if (key == ARG_up) {
             mask |= IFF_UP;
             flags |= IFF_UP;
         } else if (strcmp(*argv, "down") == 0) {
+        } else if (key == ARG_down) {
             mask |= IFF_UP;
             flags &= ~IFF_UP;
         } else if (strcmp(*argv, "name") == 0) {
+        } else if (key == ARG_name) {
             NEXT_ARG();
             newname = *argv;
         } else if (strcmp(*argv, "mtu") == 0) {
+        } else if (key == ARG_mtu) {
             NEXT_ARG();
             if (mtu != -1)
 …
             if (get_integer(&mtu, *argv, 0))
                 invarg(*argv, "mtu");
         } else if (strcmp(*argv, "multicast") == 0) {
+        } else if (key == ARG_multicast) {
             NEXT_ARG();
             mask |= IFF_MULTICAST;
+            if (strcmp(*argv, "on") == 0) {
+            key = index_in_strings(keywords, *argv) + 1;
+            if (key == PARM_on) {
                 flags |= IFF_MULTICAST;
             } else if (strcmp(*argv, "off") == 0) {
+            } else if (key == PARM_off) {
                 flags &= ~IFF_MULTICAST;
             } else
                 return on_off("multicast");
         } else if (strcmp(*argv, "arp") == 0) {
+                on_off("multicast");
+        } else if (key == ARG_arp) {
             NEXT_ARG();
             mask |= IFF_NOARP;
+            if (strcmp(*argv, "on") == 0) {
+            key = index_in_strings(keywords, *argv) + 1;
+            if (key == PARM_on) {
                 flags &= ~IFF_NOARP;
             } else if (strcmp(*argv, "off") == 0) {
+            } else if (key == PARM_off) {
                 flags |= IFF_NOARP;
             } else
                 return on_off("noarp");
         } else if (strcmp(*argv, "addr") == 0) {
+                on_off("arp");
+        } else if (key == ARG_addr) {
             NEXT_ARG();
             newaddr = *argv;
         } else {
             if (strcmp(*argv, "dev") == 0) {
+            if (key == ARG_dev) {
                 NEXT_ARG();
+            }
 …
     if (!dev) {
+        bb_error_msg(bb_msg_requires_arg, "\"dev\"");
+        exit(-1);
+        bb_error_msg_and_die(bb_msg_requires_arg, "\"dev\"");
+    }
     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;
+            parse_address(dev, htype, halen, newaddr, &ifr0);
+        }
         if (newbrd) {
+            if (parse_address(dev, htype, halen, newbrd, &ifr1) < 0)
+                return -1;
+            parse_address(dev, htype, halen, newbrd, &ifr1);
+        }
+    }
     if (newname && strcmp(dev, newname)) {
+        if (do_changename(dev, newname) < 0)
+            return -1;
+        do_changename(dev, newname);
         dev = newname;
+    }
     if (qlen != -1) {
+        if (set_qlen(dev, qlen) < 0)
+            return -1;
+        set_qlen(dev, qlen);
+    }
     if (mtu != -1) {
+        if (set_mtu(dev, mtu) < 0)
+            return -1;
+        set_mtu(dev, mtu);
+    }
     if (newaddr || newbrd) {
         if (newbrd) {
+            if (set_address(&ifr1, 1) < 0)
+                return -1;
+            set_address(&ifr1, 1);
+        }
         if (newaddr) {
+            if (set_address(&ifr0, 0) < 0)
+                return -1;
+            set_address(&ifr0, 0);
+        }
+    }
     if (mask)
         return do_chflags(dev, flags, mask);
+        do_chflags(dev, flags, mask);
     return 0;
+}
 …
+{
     preferred_family = AF_PACKET;
-    do_link = 1;
     return ipaddr_list_or_flush(argc, argv, 0);
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 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
+    static const char keywords[] ALIGN1 =
+        "set\0""show\0""lst\0""list\0";
+    smalluint key;
+    if (argc <= 0)
         return ipaddr_list_link(0, NULL);
+    bb_error_msg("Command \"%s\" is unknown.", *argv);
+    exit(-1);
+}
+    key = index_in_substrings(keywords, *argv) + 1;
+    if (key == 0)
+        bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+    argc--; argv++;
+    if (key == 1) /* set */
+        return do_set(argc, argv);
+    else /* show, lst, list */
+        return ipaddr_list_link(argc, argv);
+}

branches/stable/mindi-busybox/networking/libiproute/iproute.c

-              r821
+              r1770
  */
+#include "libbb.h"
+#include <sys/socket.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
-#include "ip_common.h"
 #ifndef RTAX_RTTVAR
 …
+static struct
+{
+typedef struct filter_t {
     int tb;
     int flushed;
 …
     inet_prefix rsrc;
     inet_prefix msrc;
+} filter;
+} filter_t;
+#define filter (*(filter_t*)&bb_common_bufsiz1)
 static int flush_update(void)
+{
     if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
         perror("Failed to send flush request\n");
+        bb_perror_msg("failed to send flush request");
         return -1;
+    }
     filter.flushp = 0;
     return 0;
+}
+static unsigned get_hz(void)
+{
+    static unsigned hz_internal;
+    FILE *fp;
+    if (hz_internal)
+        return hz_internal;
+    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_internal = denom;
+        fclose(fp);
+    }
+    if (!hz_internal)
+        hz_internal = sysconf(_SC_CLK_TCK);
+    return hz_internal;
+}
 …
         return 0;
     len -= NLMSG_LENGTH(sizeof(*r));
+    if (len < 0) {
+        bb_error_msg("wrong nlmsg len %d", len);
+        return -1;
+    }
+    if (len < 0)
+        bb_error_msg_and_die("wrong nlmsg len %d", len);
     if (r->rtm_family == AF_INET6)
 …
         if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
             if (flush_update())
                 return -1;
+                bb_error_msg_and_die("flush");
+        }
         fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
 …
+    }
     if (tb[RTA_PRIORITY]) {
         fprintf(fp, " metric %d ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY]));
+        fprintf(fp, " metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
+    }
     if (r->rtm_family == AF_INET6) {
 …
+        }
         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_);
+                fprintf(fp, "%c    cache ", _SL_);
+            }
             if (ci->rta_expires) {
                 fprintf(fp, " expires %dsec", ci->rta_expires/hz);
+                fprintf(fp, " expires %dsec", ci->rta_expires / get_hz());
+            }
             if (ci->rta_error != 0) {
 …
         fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
+    }
     fprintf(fp, "\n");
+    fputc('\n', fp);
     fflush(fp);
     return 0;
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int iproute_modify(int cmd, unsigned flags, int argc, char **argv)
+{
+    static const char keywords[] ALIGN1 =
+        "src\0""via\0""mtu\0""lock\0""protocol\0"USE_FEATURE_IP_RULE("table\0")
+        "dev\0""oif\0""to\0";
+    enum {
+        ARG_src,
+        ARG_via,
+        ARG_mtu, PARM_lock,
+        ARG_protocol,
+USE_FEATURE_IP_RULE(ARG_table,)
+        ARG_dev,
+        ARG_oif,
+        ARG_to
+    };
+    enum {
+        gw_ok = 1 << 0,
+        dst_ok = 1 << 1,
+        proto_ok = 1 << 2,
+        type_ok = 1 << 3
+    };
     struct rtnl_handle rth;
     struct {
 …
         char            buf[1024];
     } req;
     char  mxbuf[256];
+    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;
+    char *d = NULL;
+    smalluint ok = 0;
+    int arg;
     memset(&req, 0, sizeof(req));
 …
     while (argc > 0) {
+        if (strcmp(*argv, "src") == 0) {
+        arg = index_in_substrings(keywords, *argv);
+        if (arg == ARG_src) {
             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 (arg == ARG_via) {
+            inet_prefix addr;
+            ok |= gw_ok;
             NEXT_ARG();
             get_addr(&addr, *argv, req.r.rtm_family);
 …
                 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) {
+        } else if (arg == ARG_mtu) {
             unsigned mtu;
             NEXT_ARG();
             if (strcmp(*argv, "lock") == 0) {
+            if (index_in_strings(keywords, *argv) == PARM_lock) {
                 mxlock |= (1<<RTAX_MTU);
                 NEXT_ARG();
+            }
             if (get_unsigned(&mtu, *argv, 0)) {
+            if (get_unsigned(&mtu, *argv, 0))
                 invarg(*argv, "mtu");
+            }
             rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
         } else if (matches(*argv, "protocol") == 0) {
+        } else if (arg == ARG_protocol) {
             uint32_t prot;
             NEXT_ARG();
 …
                 invarg(*argv, "protocol");
             req.r.rtm_protocol = prot;
+            proto_ok =1;
+        } else if (strcmp(*argv, "dev") == 0 ||
+               strcmp(*argv, "oif") == 0) {
+            ok |= proto_ok;
+#if ENABLE_FEATURE_IP_RULE
+        } else if (arg == ARG_table) {
+            uint32_t tid;
+            NEXT_ARG();
+            if (rtnl_rttable_a2n(&tid, *argv))
+                invarg(*argv, "table");
+            req.r.rtm_table = tid;
+#endif
+        } else if (arg == ARG_dev || arg == ARG_oif) {
             NEXT_ARG();
             d = *argv;
 …
             inet_prefix dst;
             if (strcmp(*argv, "to") == 0) {
                 NEXT_ARG();
+            }
             if ((**argv < '0' || **argv > '9') &&
                 rtnl_rtntype_a2n(&type, *argv) == 0) {
+            if (arg == ARG_to) {
+                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) {
+                ok |= type_ok;
+            }
+            if (ok & dst_ok) {
                 duparg2("to", *argv);
+            }
 …
+            }
             req.r.rtm_dst_len = dst.bitlen;
             dst_ok = 1;
+            ok |= dst_ok;
             if (dst.bytelen) {
                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 …
+    }
+    if (rtnl_open(&rth, 0) < 0) {
+        exit(1);
+    }
+    xrtnl_open(&rth);
     if (d)  {
 …
         if (d) {
+            if ((idx = ll_name_to_index(d)) == 0) {
+                bb_error_msg("Cannot find device \"%s\"", d);
+                return -1;
+            }
+            idx = xll_name_to_index(d);
             addattr32(&req.n, sizeof(req), RTA_OIF, idx);
+        }
 …
+    }
+    if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
+        req.r.rtm_scope = RT_SCOPE_HOST;
+    else if (req.r.rtm_type == RTN_BROADCAST ||
+            req.r.rtm_type == RTN_MULTICAST ||
+            req.r.rtm_type == RTN_ANYCAST)
+        req.r.rtm_scope = RT_SCOPE_LINK;
+    else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
+        if (cmd == RTM_DELROUTE)
+            req.r.rtm_scope = RT_SCOPE_NOWHERE;
+        else if (!(ok & gw_ok))
+            req.r.rtm_scope = RT_SCOPE_LINK;
+    }
     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 2;
+    }
 …
     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";
+    return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
+static void iproute_flush_cache(void)
+{
+    static const char fn[] ALIGN1 = "/proc/sys/net/ipv4/route/flush";
+    int flush_fd = open_or_warn(fn, O_WRONLY);
     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;
+        return;
+    }
+    if (write(flush_fd, "-1", 2) < 2) {
+        bb_perror_msg("cannot flush routing cache");
+        return;
+    }
     close(flush_fd);
-    return 0;
+}
 …
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int iproute_list_or_flush(int argc, char **argv, int flush)
+{
 …
     char *id = NULL;
     char *od = NULL;
+    static const char keywords[] ALIGN1 =
+        "protocol\0""all\0""dev\0""oif\0""iif\0""via\0""table\0""cache\0" /*all*/
+        "from\0""root\0""match\0""exact\0""to\0"/*root match exact*/;
+    enum {
+        ARG_proto, PARM_all,
+        ARG_dev,
+        ARG_oif,
+        ARG_iif,
+        ARG_via,
+        ARG_table, PARM_cache, /*PARM_all,*/
+        ARG_from, PARM_root, PARM_match, PARM_exact,
+        ARG_to  /*PARM_root, PARM_match, PARM_exact*/
+    };
+    int arg, parm;
     iproute_reset_filter();
     filter.tb = RT_TABLE_MAIN;
+    if (flush && argc <= 0) {
+        bb_error_msg(bb_msg_requires_arg, "\"ip route flush\"");
+        return -1;
+    }
+    if (flush && argc <= 0)
+        bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
     while (argc > 0) {
+        if (matches(*argv, "protocol") == 0) {
+        arg = index_in_substrings(keywords, *argv);
+        if (arg == ARG_proto) {
             uint32_t prot = 0;
             NEXT_ARG();
             filter.protocolmask = -1;
             if (rtnl_rtprot_a2n(&prot, *argv)) {
                 if (strcmp(*argv, "all") != 0) {
+                if (index_in_strings(keywords, *argv) != PARM_all)
                     invarg(*argv, "protocol");
+                }
                 prot = 0;
                 filter.protocolmask = 0;
+            }
             filter.protocol = prot;
+        } else if (strcmp(*argv, "dev") == 0 ||
+               strcmp(*argv, "oif") == 0) {
+        } else if (arg == ARG_dev || arg == ARG_oif) {
             NEXT_ARG();
             od = *argv;
         } else if (strcmp(*argv, "iif") == 0) {
+        } else if (arg == ARG_iif) {
             NEXT_ARG();
             id = *argv;
+        } else if (matches(*argv, "from") == 0) {
+            NEXT_ARG();
+            if (matches(*argv, "root") == 0) {
+        } else if (arg == ARG_via) {
+            NEXT_ARG();
+            get_prefix(&filter.rvia, *argv, do_ipv6);
+        } else if (arg == ARG_table) {
+            NEXT_ARG();
+            parm = index_in_substrings(keywords, *argv);
+            if (parm == PARM_cache)
+                filter.tb = -1;
+            else if (parm == PARM_all)
+                filter.tb = 0;
+            else
+                invarg(*argv, "table");
+        } else if (arg == ARG_from) {
+            NEXT_ARG();
+            parm = index_in_substrings(keywords, *argv);
+            if (parm == PARM_root) {
                 NEXT_ARG();
                 get_prefix(&filter.rsrc, *argv, do_ipv6);
             } else if (matches(*argv, "match") == 0) {
+            } else if (parm == PARM_match) {
                 NEXT_ARG();
                 get_prefix(&filter.msrc, *argv, do_ipv6);
             } else {
                 if (matches(*argv, "exact") == 0) {
+                if (parm == PARM_exact)
                     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) {
+            /* parm = arg; // would be more plausible, we reuse arg here */
+            if (arg == ARG_to) {
+                NEXT_ARG();
+                arg = index_in_substrings(keywords, *argv);
+            }
+            if (arg == PARM_root) {
                 NEXT_ARG();
                 get_prefix(&filter.rdst, *argv, do_ipv6);
             } else if (matches(*argv, "match") == 0) {
+            } else if (arg == PARM_match) {
                 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) {
+                if (arg == PARM_exact)
                     NEXT_ARG();
+                }
                 get_prefix(&filter.mdst, *argv, do_ipv6);
                 filter.rdst = filter.mdst;
+            }
+        }
+        argc--; argv++;
+        argc--;
+        argv++;
+    }
 …
+    }
+    if (rtnl_open(&rth, 0) < 0) {
+        exit(1);
+    }
+    xrtnl_open(&rth);
     ll_init_map(&rth);
 …
         if (id) {
+            if ((idx = ll_name_to_index(id)) == 0) {
+                bb_error_msg("Cannot find device \"%s\"", id);
+                return -1;
+            }
+            idx = xll_name_to_index(id);
             filter.iif = idx;
             filter.iifmask = -1;
+        }
         if (od) {
+            if ((idx = ll_name_to_index(od)) == 0) {
+                bb_error_msg("Cannot find device \"%s\"", od);
+            }
+            idx = xll_name_to_index(od);
             filter.oif = idx;
             filter.oifmask = -1;
 …
         for (;;) {
+            if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
+                perror("Cannot send dump request");
+                return -1;
+            }
+            xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
             filter.flushed = 0;
+            if (rtnl_dump_filter(&rth, print_route, stdout, NULL, NULL) < 0) {
+                bb_error_msg("Flush terminated\n");
+                return -1;
+            }
+            if (filter.flushed == 0) {
+                fflush(stdout);
+            xrtnl_dump_filter(&rth, print_route, stdout);
+            if (filter.flushed == 0)
                 return 0;
+            }
+            if (flush_update() < 0)
+                exit(1);
+            if (flush_update())
+                return 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);
+}
+        xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
+    } else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
+        bb_perror_msg_and_die("cannot send dump request");
+    }
+    xrtnl_dump_filter(&rth, print_route, stdout);
+    return 0;
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int iproute_get(int argc, char **argv)
+{
     struct rtnl_handle rth;
     struct {
         struct nlmsghdr     n;
         struct rtmsg        r;
         char            buf[1024];
+        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 };
+    char *idev = NULL;
+    char *odev = NULL;
+    bool connected = 0;
+    bool from_ok = 0;
+    static const char options[] ALIGN1 =
+        "from\0""iif\0""oif\0""dev\0""notify\0""connected\0""to\0";
     memset(&req, 0, sizeof(req));
 …
     while (argc > 0) {
         switch (compare_string_array(options, *argv)) {
+        switch (index_in_strings(options, *argv)) {
             case 0: /* from */
+            {
 …
+    }
+    if (rtnl_open(&rth, 0) < 0)
+        exit(1);
+    xrtnl_open(&rth);
     ll_init_map(&rth);
 …
         if (idev) {
+            if ((idx = ll_name_to_index(idev)) == 0) {
+                bb_error_msg("Cannot find device \"%s\"", idev);
+                return -1;
+            }
+            idx = xll_name_to_index(idev);
             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;
+            }
+            idx = xll_name_to_index(odev);
             addattr32(&req.n, sizeof(req), RTA_OIF, idx);
+        }
 …
     if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
         exit(2);
+        return 2;
+    }
 …
         struct rtattr * tb[RTA_MAX+1];
+        if (print_route(NULL, &req.n, (void*)stdout) < 0) {
+            bb_error_msg_and_die("An error :-)");
+        }
+        print_route(NULL, &req.n, (void*)stdout);
         if (req.n.nlmsg_type != RTM_NEWROUTE) {
+            bb_error_msg("Not a route?");
+            return -1;
+            bb_error_msg_and_die("not a route?");
+        }
         len -= NLMSG_LENGTH(sizeof(*r));
         if (len < 0) {
+            bb_error_msg("Wrong len %d", len);
+            return -1;
+            bb_error_msg_and_die("wrong len %d", len);
+        }
 …
             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;
+            bb_error_msg_and_die("failed to connect the route");
+        }
         if (!odev && tb[RTA_OIF]) {
 …
         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);
+}
+            return 2;
+        }
+    }
+    print_route(NULL, &req.n, (void*)stdout);
+    return 0;
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 int do_iproute(int argc, char **argv)
+{
+    static const char * const ip_route_commands[] =
+        { "add", "append", "change", "chg", "delete", "del", "get",
+        "list", "show", "prepend", "replace", "test", "flush", 0 };
+    int command_num = 7;
+    unsigned int flags = 0;
+    static const char ip_route_commands[] ALIGN1 =
+    /*0-3*/ "add\0""append\0""change\0""chg\0"
+    /*4-7*/ "delete\0""get\0""list\0""show\0"
+    /*8..*/ "prepend\0""replace\0""test\0""flush\0";
+    int command_num = 6;
+    unsigned 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 = compare_string_array(ip_route_commands, *argv);
+    }
     switch(command_num) {
         case 0: /* add*/
+        command_num = index_in_substrings(ip_route_commands, *argv);
+    }
+    switch (command_num) {
+        case 0: /* add */
             flags = NLM_F_CREATE|NLM_F_EXCL;
             break;
 …
             break;
         case 4: /* delete */
-        case 5: /* del */
             cmd = RTM_DELROUTE;
             break;
         case 6: /* get */
+        case 5: /* get */
             return iproute_get(argc-1, argv+1);
         case 7: /* list */
         case 8: /* show */
+        case 6: /* list */
+        case 7: /* show */
             return iproute_list_or_flush(argc-1, argv+1, 0);
         case 9: /* prepend */
+        case 8: /* prepend */
             flags = NLM_F_CREATE;
         case 10: /* replace */
+        case 9: /* replace */
             flags = NLM_F_CREATE|NLM_F_REPLACE;
         case 11: /* test */
+        case 10: /* test */
             flags = NLM_F_EXCL;
         case 12: /* flush */
+        case 11: /* flush */
             return iproute_list_or_flush(argc-1, argv+1, 1);
         default:
             bb_error_msg_and_die("Unknown command %s", *argv);
+            bb_error_msg_and_die("unknown command %s", *argv);
+    }

branches/stable/mindi-busybox/networking/libiproute/iptunnel.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * iptunnel.c          "ip tunnel"
 …
  */
-#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
 …
 #include <linux/if_tunnel.h>
+#include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
+#include "ip_common.h"
+/* Dies on error */
 static int do_ioctl_get_ifindex(char *dev)
+{
 …
     int fd;
+    strcpy(ifr.ifr_name, dev);
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (ioctl(fd, SIOCGIFINDEX, &ifr)) {
+        bb_perror_msg("ioctl");
+        return 0;
+    }
+    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    xioctl(fd, SIOCGIFINDEX, &ifr);
     close(fd);
     return ifr.ifr_ifindex;
 …
 static int do_ioctl_get_iftype(char *dev)
+{
-    struct ifreq ifr;
-    int fd;
-    strcpy(ifr.ifr_name, dev);
-    fd = socket(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 = socket(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 err;
+    strcpy(ifr.ifr_name, basedev);
+    ifr.ifr_ifru.ifru_data = (void*)p;
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl(fd, SIOCGETTUNNEL, &ifr);
+    if (err) {
+        bb_perror_msg("ioctl");
+    }
+    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr);
     close(fd);
     return err;
+}
 static int do_add_ioctl(int cmd, char *basedev, struct ip_tunnel_parm *p)
+    return err ? -1 : ifr.ifr_addr.sa_family;
+}
+static char *do_ioctl_get_ifname(int idx)
+{
     struct ifreq ifr;
 …
     int err;
+    if (cmd == SIOCCHGTUNNEL && p->name[0]) {
+        strcpy(ifr.ifr_name, p->name);
+    } else {
+        strcpy(ifr.ifr_name, basedev);
+    }
+    ifr.ifr_ifru.ifru_data = (void*)p;
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl(fd, cmd, &ifr);
+    if (err) {
+        bb_perror_msg("ioctl");
+    }
+    ifr.ifr_ifindex = idx;
+    fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl_or_warn(fd, SIOCGIFNAME, &ifr);
     close(fd);
     return err;
+}
 static int do_del_ioctl(char *basedev, struct ip_tunnel_parm *p)
+    return err ? NULL : xstrndup(ifr.ifr_name, sizeof(ifr.ifr_name));
+}
+static int do_get_ioctl(const char *basedev, struct ip_tunnel_parm *p)
+{
     struct ifreq ifr;
 …
     int err;
+    if (p->name[0]) {
+        strcpy(ifr.ifr_name, p->name);
+    } else {
+        strcpy(ifr.ifr_name, basedev);
+    }
+    strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
     ifr.ifr_ifru.ifru_data = (void*)p;
+    fd = socket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl(fd, SIOCDELTUNNEL, &ifr);
+    if (err) {
+        bb_perror_msg("ioctl");
+    }
+    fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    err = ioctl_or_warn(fd, SIOCGETTUNNEL, &ifr);
     close(fd);
     return err;
+}
+static int parse_args(int argc, char **argv, int cmd, struct ip_tunnel_parm *p)
+{
+/* Dies on error, otherwise returns 0 */
+static int do_add_ioctl(int cmd, const char *basedev, struct ip_tunnel_parm *p)
+{
+    struct ifreq ifr;
+    int fd;
+    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);
+#if ENABLE_IOCTL_HEX2STR_ERROR
+    /* #define magic will turn ioctl# into string */
+    if (cmd == SIOCCHGTUNNEL)
+        xioctl(fd, SIOCCHGTUNNEL, &ifr);
+    else
+        xioctl(fd, SIOCADDTUNNEL, &ifr);
+#else
+    xioctl(fd, cmd, &ifr);
+#endif
+    close(fd);
+    return 0;
+}
+/* Dies on error, otherwise returns 0 */
+static int do_del_ioctl(const char *basedev, struct ip_tunnel_parm *p)
+{
+    struct ifreq ifr;
+    int fd;
+    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);
+    xioctl(fd, SIOCDELTUNNEL, &ifr);
+    close(fd);
+    return 0;
+}
+/* Dies on error */
+static void parse_args(int argc, char **argv, int cmd, struct ip_tunnel_parm *p)
+{
+    static const char keywords[] ALIGN1 =
+        "mode\0""ipip\0""ip/ip\0""gre\0""gre/ip\0""sit\0""ipv6/ip\0"
+        "key\0""ikey\0""okey\0""seq\0""iseq\0""oseq\0"
+        "csum\0""icsum\0""ocsum\0""nopmtudisc\0""pmtudisc\0"
+        "remote\0""any\0""local\0""dev\0"
+        "ttl\0""inherit\0""tos\0""dsfield\0"
+        "name\0";
+    enum {
+        ARG_mode, ARG_ipip, ARG_ip_ip, ARG_gre, ARG_gre_ip, ARG_sit, ARG_ip6_ip,
+        ARG_key, ARG_ikey, ARG_okey, ARG_seq, ARG_iseq, ARG_oseq,
+        ARG_csum, ARG_icsum, ARG_ocsum, ARG_nopmtudisc, ARG_pmtudisc,
+        ARG_remote, ARG_any, ARG_local, ARG_dev,
+        ARG_ttl, ARG_inherit, ARG_tos, ARG_dsfield,
+        ARG_name
+    };
     int count = 0;
     char medium[IFNAMSIZ];
+    int key;
     memset(p, 0, sizeof(*p));
     memset(&medium, 0, sizeof(medium));
 …
     p->iph.ihl = 5;
 #ifndef IP_DF
 #define IP_DF       0x4000      /* Flag: "Don't Fragment"   */
+#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) {
+        key = index_in_strings(keywords, *argv);
+        if (key == ARG_mode) {
+            NEXT_ARG();
+            key = index_in_strings(keywords, *argv);
+            if (key == ARG_ipip ||
+                key == ARG_ip_ip) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_IPIP) {
+                    bb_error_msg("You managed to ask for more than one tunnel mode.");
+                    exit(-1);
+                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                }
                 p->iph.protocol = IPPROTO_IPIP;
             } else if (strcmp(*argv, "gre") == 0 ||
                    strcmp(*argv, "gre/ip") == 0) {
+            } else if (key == ARG_gre ||
+                   key == ARG_gre_ip) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_GRE) {
+                    bb_error_msg("You managed to ask for more than one tunnel mode.");
+                    exit(-1);
+                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                }
                 p->iph.protocol = IPPROTO_GRE;
             } else if (strcmp(*argv, "sit") == 0 ||
                    strcmp(*argv, "ipv6/ip") == 0) {
+            } else if (key == ARG_sit ||
+                   key == ARG_ip6_ip) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_IPV6) {
+                    bb_error_msg("You managed to ask for more than one tunnel mode.");
+                    exit(-1);
+                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                }
                 p->iph.protocol = IPPROTO_IPV6;
             } else {
+                bb_error_msg("Cannot guess tunnel mode.");
+                exit(-1);
+            }
+        } else if (strcmp(*argv, "key") == 0) {
+                bb_error_msg_and_die("cannot guess tunnel mode");
+            }
+        } else if (key == ARG_key) {
             unsigned uval;
             NEXT_ARG();
 …
             else {
                 if (get_unsigned(&uval, *argv, 0)<0) {
+                    bb_error_msg("invalid value of \"key\"");
+                    exit(-1);
+                    bb_error_msg_and_die("invalid value of \"key\"");
+                }
                 p->i_key = p->o_key = htonl(uval);
+            }
         } else if (strcmp(*argv, "ikey") == 0) {
+        } else if (key == ARG_ikey) {
             unsigned uval;
             NEXT_ARG();
 …
             else {
                 if (get_unsigned(&uval, *argv, 0)<0) {
+                    bb_error_msg("invalid value of \"ikey\"");
+                    exit(-1);
+                    bb_error_msg_and_die("invalid value of \"ikey\"");
+                }
                 p->i_key = htonl(uval);
+            }
         } else if (strcmp(*argv, "okey") == 0) {
+        } else if (key == ARG_okey) {
             unsigned uval;
             NEXT_ARG();
 …
             else {
                 if (get_unsigned(&uval, *argv, 0)<0) {
+                    bb_error_msg("invalid value of \"okey\"");
+                    exit(-1);
+                    bb_error_msg_and_die("invalid value of \"okey\"");
+                }
                 p->o_key = htonl(uval);
+            }
         } else if (strcmp(*argv, "seq") == 0) {
+        } else if (key == ARG_seq) {
             p->i_flags |= GRE_SEQ;
             p->o_flags |= GRE_SEQ;
         } else if (strcmp(*argv, "iseq") == 0) {
+        } else if (key == ARG_iseq) {
             p->i_flags |= GRE_SEQ;
         } else if (strcmp(*argv, "oseq") == 0) {
+        } else if (key == ARG_oseq) {
             p->o_flags |= GRE_SEQ;
         } else if (strcmp(*argv, "csum") == 0) {
+        } else if (key == ARG_csum) {
             p->i_flags |= GRE_CSUM;
             p->o_flags |= GRE_CSUM;
         } else if (strcmp(*argv, "icsum") == 0) {
+        } else if (key == ARG_icsum) {
             p->i_flags |= GRE_CSUM;
         } else if (strcmp(*argv, "ocsum") == 0) {
+        } else if (key == ARG_ocsum) {
             p->o_flags |= GRE_CSUM;
         } else if (strcmp(*argv, "nopmtudisc") == 0) {
+        } else if (key == ARG_nopmtudisc) {
             p->iph.frag_off = 0;
         } else if (strcmp(*argv, "pmtudisc") == 0) {
+        } else if (key == ARG_pmtudisc) {
             p->iph.frag_off = htons(IP_DF);
+        } else if (strcmp(*argv, "remote") == 0) {
+            NEXT_ARG();
+            if (strcmp(*argv, "any"))
+        } else if (key == ARG_remote) {
+            NEXT_ARG();
+            key = index_in_strings(keywords, *argv);
+            if (key == ARG_any)
                 p->iph.daddr = get_addr32(*argv);
+        } else if (strcmp(*argv, "local") == 0) {
+            NEXT_ARG();
+            if (strcmp(*argv, "any"))
+        } else if (key == ARG_local) {
+            NEXT_ARG();
+            key = index_in_strings(keywords, *argv);
+            if (key == ARG_any)
                 p->iph.saddr = get_addr32(*argv);
         } else if (strcmp(*argv, "dev") == 0) {
+        } else if (key == ARG_dev) {
             NEXT_ARG();
             strncpy(medium, *argv, IFNAMSIZ-1);
         } else if (strcmp(*argv, "ttl") == 0) {
+        } else if (key == ARG_ttl) {
             unsigned uval;
             NEXT_ARG();
+            if (strcmp(*argv, "inherit") != 0) {
+            key = index_in_strings(keywords, *argv);
+            if (key != ARG_inherit) {
                 if (get_unsigned(&uval, *argv, 0))
                     invarg(*argv, "TTL");
 …
                 p->iph.ttl = uval;
+            }
+        } else if (strcmp(*argv, "tos") == 0 ||
+               matches(*argv, "dsfield") == 0) {
+            __u32 uval;
+            NEXT_ARG();
+            if (strcmp(*argv, "inherit") != 0) {
+        } else if (key == ARG_tos ||
+               key == ARG_dsfield) {
+            uint32_t uval;
+            NEXT_ARG();
+            key = index_in_strings(keywords, *argv);
+            if (key != ARG_inherit) {
                 if (rtnl_dsfield_a2n(&uval, *argv))
                     invarg(*argv, "TOS");
 …
                 p->iph.tos = 1;
         } else {
             if (strcmp(*argv, "name") == 0) {
+            if (key == ARG_name) {
                 NEXT_ARG();
+            }
 …
                 memset(&old_p, 0, sizeof(old_p));
                 if (do_get_ioctl(*argv, &old_p))
                     return -1;
+                    exit(1);
                 *p = old_p;
+            }
+        }
         count++;
         argc--; argv++;
+    }
+        argc--;
+        argv++;
+    }
     if (p->iph.protocol == 0) {
 …
     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;
+            bb_error_msg_and_die("keys are not allowed with ipip and sit");
+        }
+    }
 …
     if (medium[0]) {
         p->link = do_ioctl_get_ifindex(medium);
-        if (p->link == 0)
-            return -1;
+    }
 …
+    }
     if (IN_MULTICAST(ntohl(p->iph.daddr)) && !p->iph.saddr) {
+        bb_error_msg("Broadcast tunnel requires a source address.");
+        return -1;
+    }
+    return 0;
+}
+        bb_error_msg_and_die("broadcast tunnel requires a source address");
+    }
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 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;
+    parse_args(argc, argv, cmd, &p);
     if (p.iph.ttl && p.iph.frag_off == 0) {
+        bb_error_msg("ttl != 0 and noptmudisc are incompatible");
+        return -1;
+        bb_error_msg_and_die("ttl != 0 and noptmudisc are incompatible");
+    }
 …
         return do_add_ioctl(cmd, "sit0", &p);
     default:
+        bb_error_msg("cannot determine tunnel mode (ipip, gre or sit)");
+        return -1;
+    }
+    return -1;
+}
+        bb_error_msg_and_die("cannot determine tunnel mode (ipip, gre or sit)");
+    }
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int do_del(int argc, char **argv)
+{
     struct ip_tunnel_parm p;
+    if (parse_args(argc, argv, SIOCDELTUNNEL, &p) < 0)
+        return -1;
+    parse_args(argc, argv, SIOCDELTUNNEL, &p);
     switch (p.iph.protocol) {
 …
         return do_del_ioctl(p.name, &p);
+    }
-    return -1;
+}
 …
     if (p->link) {
         char *n = do_ioctl_get_ifname(p->link);
         if (n)
+        if (n) {
             printf(" dev %s ", n);
+            free(n);
+        }
+    }
     if (p->iph.ttl)
 …
         SPRINT_BUF(b1);
         printf(" tos");
         if (p->iph.tos&1)
+        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)))
+        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)
+    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)
+    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)
+        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)
+    if (p->i_flags & GRE_SEQ)
+        printf("%c  Drop packets out of sequence.\n", _SL_);
+    if (p->i_flags & GRE_CSUM)
+        printf("%c  Checksum in received packet is required.", _SL_);
+    if (p->o_flags & GRE_SEQ)
+        printf("%c  Sequence packets on output.", _SL_);
+    if (p->o_flags & GRE_CSUM)
+        printf("%c  Checksum output packets.", _SL_);
+}
+static void 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;
+    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");
+    FILE *fp = fopen_or_warn("/proc/net/dev", "r");
     if (fp == NULL) {
+        perror("fopen");
+        return -1;
+        return;
+    }
 …
     while (fgets(buf, sizeof(buf), fp) != NULL) {
         char *ptr;
+        buf[sizeof(buf) - 1] = 0;
+        if ((ptr = strchr(buf, ':')) == NULL ||
+        /*buf[sizeof(buf) - 1] = 0; - fgets is safe anyway */
+        ptr = strchr(buf, ':');
+        if (ptr == NULL ||
             (*ptr++ = 0, sscanf(buf, "%s", name) != 1)) {
             bb_error_msg("Wrong format of /proc/net/dev. Sorry.");
             return -1;
+            bb_error_msg("wrong format of /proc/net/dev");
+            return;
+        }
         if (sscanf(ptr, "%lu%lu%lu%lu%lu%lu%lu%*d%lu%lu%lu%lu%lu%lu%lu",
 …
         type = do_ioctl_get_iftype(name);
         if (type == -1) {
             bb_error_msg("Failed to get type of [%s]", name);
+            bb_error_msg("cannot get type of [%s]", name);
             continue;
+        }
 …
             continue;
         print_tunnel(&p1);
         printf("\n");
+    }
+    return 0;
+}
+        puts("");
+    }
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 static int do_show(int argc, char **argv)
+{
 …
     struct ip_tunnel_parm p;
+    if (parse_args(argc, argv, SIOCGETTUNNEL, &p) < 0)
+        return -1;
+    parse_args(argc, argv, SIOCGETTUNNEL, &p);
     switch (p.iph.protocol) {
 …
     print_tunnel(&p);
     printf("\n");
+    puts("");
     return 0;
+}
+/* Return value becomes exitcode. It's okay to not return at all */
 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);
+}
+    static const char keywords[] ALIGN1 =
+        "add\0""change\0""delete\0""show\0""list\0""lst\0";
+    enum { ARG_add = 0, ARG_change, ARG_del, ARG_show, ARG_list, ARG_lst };
+    int key;
+    if (argc) {
+        key = index_in_substrings(keywords, *argv);
+        if (key < 0)
+            bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        --argc;
+        ++argv;
+        if (key == ARG_add)
+            return do_add(SIOCADDTUNNEL, argc, argv);
+        if (key == ARG_change)
+            return do_add(SIOCCHGTUNNEL, argc, argv);
+        if (key == ARG_del)
+            return do_del(argc, argv);
+    }
+    return do_show(argc, argv);
+}

branches/stable/mindi-busybox/networking/libiproute/libnetlink.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * libnetlink.c RTnetlink service routines.
 …
  */
+#include <sys/socket.h>
+#include <sys/uio.h>
 #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"
 …
+}
 int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions)
+int xrtnl_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;
+    }
+    rth->fd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
     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;
+    }
+    /*rth->local.nl_groups = subscriptions;*/
+    xbind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local));
     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;
+    }
+    if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0)
+        bb_perror_msg_and_die("cannot getsockname");
+    if (addr_len != sizeof(rth->local))
+        bb_error_msg_and_die("wrong address length %d", addr_len);
+    if (rth->local.nl_family != AF_NETLINK)
+        bb_error_msg_and_die("wrong address family %d", rth->local.nl_family);
     rth->seq = time(NULL);
     return 0;
+}
 int rtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
+int xrtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
+{
     struct {
 …
     req.g.rtgen_family = family;
+    return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
+    return xsendto(rth->fd, (void*)&req, sizeof(req),
+                 (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
 …
     nladdr.nl_family = AF_NETLINK;
     return sendto(rth->fd, buf, len, 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
+    return xsendto(rth->fd, buf, len, (struct sockaddr*)&nladdr, sizeof(nladdr));
+}
 …
+}
 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];
+static 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) };
 …
                 h->nlmsg_pid != rth->local.nl_pid ||
                 h->nlmsg_seq != rth->dump) {
                 if (junk) {
+/*              if (junk) {
                     err = junk(&nladdr, h, arg2);
                     if (err < 0) {
+                    if (err < 0)
                         return err;
+                    }
+                }
+                } */
                 goto skip_it;
+            }
 …
+            }
             err = filter(&nladdr, h, arg1);
             if (err < 0) {
+            if (err < 0)
                 return err;
+            }
 skip_it:
 …
+        }
         if (msg.msg_flags & MSG_TRUNC) {
             bb_error_msg("Message truncated");
+            bb_error_msg("message truncated");
             continue;
+        }
         if (status) {
+            bb_error_msg_and_die("!!!Remnant of size %d", status);
+        }
+    }
+            bb_error_msg_and_die("remnant of size %d!", status);
+        }
+    }
+}
+int xrtnl_dump_filter(struct rtnl_handle *rth,
+        int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
+        void *arg1)
+{
+    int ret = rtnl_dump_filter(rth, filter, arg1/*, NULL, NULL*/);
+    if (ret < 0)
+        bb_error_msg_and_die("dump terminated");
+    return ret;
+}
 …
     if (status < 0) {
         bb_perror_msg("Cannot talk to rtnetlink");
+        bb_perror_msg("cannot talk to rtnetlink");
         return -1;
+    }
 …
             if (l<0 || len>status) {
                 if (msg.msg_flags & MSG_TRUNC) {
                     bb_error_msg("Truncated message");
+                    bb_error_msg("truncated message");
                     return -1;
+                }
                 bb_error_msg_and_die("!!!malformed message: len=%d", len);
+                bb_error_msg_and_die("malformed message: len=%d!", len);
+            }
 …
+            }
             bb_error_msg("Unexpected reply!!!");
+            bb_error_msg("unexpected reply!");
             status -= NLMSG_ALIGN(len);
 …
+        }
         if (msg.msg_flags & MSG_TRUNC) {
             bb_error_msg("Message truncated");
+            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)
+            bb_error_msg_and_die("remnant of size %d!", status);
+        }
+    }
+}
+int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
+{
     int len = RTA_LENGTH(4);
 …
+}
 int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data)
+int rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data)
+{
     int len = RTA_LENGTH(4);
 …
+    }
     if (len) {
         bb_error_msg("!!!Deficit %d, rta_len=%d", len, rta->rta_len);
+    }
     return 0;
+}
+        bb_error_msg("deficit %d, rta_len=%d!", len, rta->rta_len);
+    }
+    return 0;
+}

branches/stable/mindi-busybox/networking/libiproute/libnetlink.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 #ifndef __LIBNETLINK_H__
 #define __LIBNETLINK_H__ 1
+#include <asm/types.h>
+#include <linux/types.h>
+/* We need linux/types.h because older kernels use __u32 etc
+ * in linux/[rt]netlink.h. 2.6.19 seems to be ok, though */
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 …
     struct sockaddr_nl  local;
     struct sockaddr_nl  peer;
     __u32           seq;
     __u32           dump;
+    uint32_t        seq;
+    uint32_t        dump;
 };
 extern int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions);
+extern int xrtnl_open(struct rtnl_handle *rth);
 extern void rtnl_close(struct rtnl_handle *rth);
 extern int rtnl_wilddump_request(struct rtnl_handle *rth, int fam, int type);
+extern int xrtnl_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 xrtnl_dump_filter(struct rtnl_handle *rth,
+            int (*filter)(struct sockaddr_nl*, struct nlmsghdr *n, void*),
+            void *arg1);
 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);
+            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 addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t 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_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t 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__ */

branches/stable/mindi-busybox/networking/libiproute/ll_addr.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ll_addr.c
 …
  */
-#include "libbb.h"
-#include <string.h>
 #include <net/if_arp.h>
+#include "libbb.h"
 #include "rt_names.h"
 #include "utils.h"
 …
     for (i=0; i<alen; i++) {
         if (i==0) {
             snprintf(buf+l, blen, "%02x", addr[i]);
+            snprintf(buf+l, blen, ":%02x"+1, addr[i]);
             blen -= 2;
             l += 2;
 …
         inet_prefix pfx;
         if (get_addr_1(&pfx, arg, AF_INET)) {
             bb_error_msg("\"%s\" is invalid lladdr.", arg);
+            bb_error_msg("\"%s\" is invalid lladdr", arg);
             return -1;
+        }
 …
+            }
             if (sscanf(arg, "%x", &temp) != 1) {
                 bb_error_msg("\"%s\" is invalid lladdr.", arg);
+                bb_error_msg("\"%s\" is invalid lladdr", arg);
                 return -1;
+            }
             if (temp < 0 || temp > 255) {
                 bb_error_msg("\"%s\" is invalid lladdr.", arg);
+                bb_error_msg("\"%s\" is invalid lladdr", arg);
                 return -1;
+            }

branches/stable/mindi-busybox/networking/libiproute/ll_map.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ll_map.c
 …
  */
+#include <net/if.h> /* struct ifreq and co. */
 #include "libbb.h"
-#include <string.h>
 #include "libnetlink.h"
 #include "ll_map.h"
+struct idxmap
+{
+    struct idxmap * next;
+    int     index;
+    int     type;
+    int     alen;
+    unsigned    flags;
+    unsigned char   addr[8];
+    char        name[16];
+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];
+static struct idxmap *find_by_index(int idx)
+{
+    struct idxmap *im;
+    for (im = idxmap[idx & 0xF]; im; im = im->next)
+        if (im->index == idx)
+            return im;
+    return NULL;
+}
 int ll_remember_index(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
 …
         return -1;
     memset(tb, 0, sizeof(tb));
     parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
 …
         return 0;
     h = ifi->ifi_index&0xF;
+    h = ifi->ifi_index & 0xF;
     for (imp=&idxmap[h]; (im=*imp)!=NULL; imp = &im->next)
+    for (imp = &idxmap[h]; (im = *imp) != NULL; imp = &im->next)
         if (im->index == ifi->ifi_index)
             break;
+            goto found;
+    if (im == NULL) {
+        im = xmalloc(sizeof(*im));
+        im->next = *imp;
+        im->index = ifi->ifi_index;
+        *imp = im;
+    }
+    im = xmalloc(sizeof(*im));
+    im->next = *imp;
+    im->index = ifi->ifi_index;
+    *imp = im;
+ found:
     im->type = ifi->ifi_type;
     im->flags = ifi->ifi_flags;
 …
     if (idx == 0)
         return "*";
     for (im = idxmap[idx&0xF]; im; im = im->next)
         if (im->index == idx)
             return im->name;
+    im = find_by_index(idx);
+    if (im)
+        return im->name;
     snprintf(buf, 16, "if%d", idx);
     return buf;
 …
+}
+#ifdef UNUSED
 int ll_index_to_type(int idx)
+{
 …
     if (idx == 0)
         return -1;
     for (im = idxmap[idx&0xF]; im; im = im->next)
         if (im->index == idx)
             return im->type;
+    im = find_by_index(idx);
+    if (im)
+        return im->type;
     return -1;
+}
+#endif
 unsigned ll_index_to_flags(int idx)
 …
     if (idx == 0)
         return 0;
+    for (im = idxmap[idx&0xF]; im; im = im->next)
+        if (im->index == idx)
+            return im->flags;
+    im = find_by_index(idx);
+    if (im)
+        return im->flags;
     return 0;
+}
 int ll_name_to_index(char *name)
+int xll_name_to_index(const char *const name)
+{
+    int ret = 0;
+    int sock_fd;
+/* caching is not warranted - no users which repeatedly call it */
+#ifdef UNUSED
     static char ncache[16];
     static int icache;
     struct idxmap *im;
     int i;
     if (name == NULL)
+        return 0;
+    if (icache && strcmp(name, ncache) == 0)
+        return icache;
+    for (i=0; i<16; i++) {
+        goto out;
+    if (icache && strcmp(name, ncache) == 0) {
+        ret = icache;
+        goto out;
+    }
+    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;
+                ret = im->index;
+                goto out;
+            }
+        }
+    }
+    return 0;
+    /* 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 */
+#endif
+    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock_fd) {
+        struct ifreq ifr;
+        int tmp;
+        strncpy(ifr.ifr_name, name, IFNAMSIZ);
+        ifr.ifr_ifindex = -1;
+        tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
+        close(sock_fd);
+        if (tmp >= 0)
+            /* In theory, we should redump the interface list
+             * to update our cache, this is left as an exercise
+             * to the reader... Jean II */
+            ret = ifr.ifr_ifindex;
+    }
+/* out:*/
+    if (ret <= 0)
+        bb_error_msg_and_die("cannot find device \"%s\"", name);
+    return ret;
+}
 int ll_init_map(struct rtnl_handle *rth)
+{
+    if (rtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK) < 0) {
+        perror("Cannot send dump request");
+        exit(1);
+    }
+    if (rtnl_dump_filter(rth, ll_remember_index, &idxmap, NULL, NULL) < 0) {
+        fprintf(stderr, "Dump terminated\n");
+        exit(1);
+    }
+    xrtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK);
+    xrtnl_dump_filter(rth, ll_remember_index, &idxmap);
     return 0;
+}

branches/stable/mindi-busybox/networking/libiproute/ll_map.h

-              r821
+              r1770
+/* 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);
+int ll_remember_index(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg);
+int ll_init_map(struct rtnl_handle *rth);
+int xll_name_to_index(const char *const name);
+const char *ll_index_to_name(int idx);
+const char *ll_idx_n2a(int idx, char *buf);
+/* int ll_index_to_type(int idx); */
+unsigned ll_index_to_flags(int idx);
 #endif /* __LL_MAP_H__ */

branches/stable/mindi-busybox/networking/libiproute/ll_proto.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ll_proto.c
 …
 #include "libbb.h"
-#include <string.h>
 #include "rt_names.h"
 #include "utils.h"
 #if __GLIBC__ >=2 && __GLIBC_MINOR >= 1
+#if defined(__GLIBC__) && __GLIBC__ >=2 && __GLIBC_MINOR__ >= 1
 #include <net/ethernet.h>
 #else
 …
 static struct {
     int id;
     char *name;
+    const char *name;
 } llproto_names[] = {
 __PF(LOOP,loop)
 …
     id = ntohs(id);
     for (i=0; i<sizeof(llproto_names)/sizeof(llproto_names[0]); i++) {
+    for (i=0; i < ARRAY_SIZE(llproto_names); i++) {
          if (llproto_names[i].id == id)
             return llproto_names[i].name;
 …
+{
     int i;
     for (i=0; i<sizeof(llproto_names)/sizeof(llproto_names[0]); i++) {
+    for (i=0; i < ARRAY_SIZE(llproto_names); i++) {
          if (strcasecmp(llproto_names[i].name, buf) == 0) {
              *id = htons(llproto_names[i].id);

branches/stable/mindi-busybox/networking/libiproute/ll_types.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * ll_types.c
 …
  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
-#include <stdio.h>
 #include <arpa/inet.h>
 #include <linux/if_arp.h>
+#include "libbb.h"
 #include "rt_names.h"
 const char * ll_type_n2a(int type, char *buf, int len)
+const char* ll_type_n2a(int type, char *buf, int len)
+{
 #define __PF(f,n) { ARPHRD_##f, #n },
 static struct {
+static const struct {
     int type;
     char *name;
+    const char *name;
 } arphrd_names[] = {
 { 0, "generic" },
 …
     int i;
     for (i=0; i<sizeof(arphrd_names)/sizeof(arphrd_names[0]); i++) {
+    for (i = 0; i < ARRAY_SIZE(arphrd_names); i++) {
          if (arphrd_names[i].type == type)
             return arphrd_names[i].name;

branches/stable/mindi-busybox/networking/libiproute/rt_names.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * rt_names.c       rtnetlink names DB.
 …
  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "libbb.h"
 #include "rt_names.h"
 static void rtnl_tab_initialize(char *file, char **tab, int size)
+static void rtnl_tab_initialize(const char *file, const char **tab, int size)
+{
     char buf[512];
 …
         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",
+        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
+        ) {
+            bb_error_msg("database %s is corrupted at %s",
                 file, p);
             return;
+        }
         if (id<0 || id>size)
+        if (id < 0 || id > size)
             continue;
         tab[id] = strdup(namebuf);
+        tab[id] = xstrdup(namebuf);
+    }
     fclose(fp);
 …
+static char * rtnl_rtprot_tab[256] = {
+    "none",
+    "redirect",
+    "kernel",
+    "boot",
+    "static",
+    NULL,
+    NULL,
+    NULL,
+    "gated",
+    "ra",
+    "mrt",
+    "zebra",
+    "bird",
+};
+static int rtnl_rtprot_init;
+static const char **rtnl_rtprot_tab; /* [256] */
 static void rtnl_rtprot_initialize(void)
+{
+    rtnl_rtprot_init = 1;
+    static const char *const init_tab[] = {
+        "none",
+        "redirect",
+        "kernel",
+        "boot",
+        "static",
+        NULL,
+        NULL,
+        NULL,
+        "gated",
+        "ra",
+        "mrt",
+        "zebra",
+        "bird",
+    };
+    if (rtnl_rtprot_tab) return;
+    rtnl_rtprot_tab = xzalloc(256 * sizeof(rtnl_rtprot_tab[0]));
+    memcpy(rtnl_rtprot_tab, init_tab, sizeof(init_tab));
     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();
+    }
+const char* rtnl_rtprot_n2a(int id, char *buf, int len)
+{
+    if (id < 0 || id >= 256) {
+        snprintf(buf, len, "%d", id);
+        return buf;
+    }
+    rtnl_rtprot_initialize();
     if (rtnl_rtprot_tab[id])
         return rtnl_rtprot_tab[id];
 …
 int rtnl_rtprot_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_rtprot_init)
+        rtnl_rtprot_initialize();
+    for (i=0; i<256; i++) {
+    static const char *cache = NULL;
+    static unsigned long res;
+    int i;
+    if (cache && strcmp(cache, arg) == 0) {
+        *id = res;
+        return 0;
+    }
+    rtnl_rtprot_initialize();
+    for (i = 0; i < 256; i++) {
         if (rtnl_rtprot_tab[i] &&
             strcmp(rtnl_rtprot_tab[i], arg) == 0) {
 …
+    }
     res = strtoul(arg, &end, 0);
     if (!end || end == arg || *end || res > 255)
+    res = bb_strtoul(arg, NULL, 0);
+    if (errno || res > 255)
         return -1;
     *id = res;
 …
+static char * rtnl_rtscope_tab[256] = {
+    "global",
+};
+static int rtnl_rtscope_init;
+static const char **rtnl_rtscope_tab; /* [256] */
 static void rtnl_rtscope_initialize(void)
+{
+    rtnl_rtscope_init = 1;
+    if (rtnl_rtscope_tab) return;
+    rtnl_rtscope_tab = xzalloc(256 * sizeof(rtnl_rtscope_tab[0]));
+    rtnl_rtscope_tab[0] = "global";
     rtnl_rtscope_tab[255] = "nowhere";
     rtnl_rtscope_tab[254] = "host";
 …
+}
+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();
+    }
+const char* rtnl_rtscope_n2a(int id, char *buf, int len)
+{
+    if (id < 0 || id >= 256) {
+        snprintf(buf, len, "%d", id);
+        return buf;
+    }
+    rtnl_rtscope_initialize();
     if (rtnl_rtscope_tab[id])
         return rtnl_rtscope_tab[id];
 …
 int rtnl_rtscope_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_rtscope_init)
+        rtnl_rtscope_initialize();
+    for (i=0; i<256; i++) {
+    static const char *cache = NULL;
+    static unsigned long res;
+    int i;
+    if (cache && strcmp(cache, arg) == 0) {
+        *id = res;
+        return 0;
+    }
+    rtnl_rtscope_initialize();
+    for (i = 0; i < 256; i++) {
         if (rtnl_rtscope_tab[i] &&
             strcmp(rtnl_rtscope_tab[i], arg) == 0) {
 …
+    }
     res = strtoul(arg, &end, 0);
     if (!end || end == arg || *end || res > 255)
+    res = bb_strtoul(arg, NULL, 0);
+    if (errno || res > 255)
         return -1;
     *id = res;
 …
+static char * rtnl_rtrealm_tab[256] = {
+    "unknown",
+};
+static int rtnl_rtrealm_init;
+static const char **rtnl_rtrealm_tab; /* [256] */
 static void rtnl_rtrealm_initialize(void)
+{
+    rtnl_rtrealm_init = 1;
+    if (rtnl_rtrealm_tab) return;
+    rtnl_rtrealm_tab = xzalloc(256 * sizeof(rtnl_rtrealm_tab[0]));
+    rtnl_rtrealm_tab[0] = "unknown";
     rtnl_tab_initialize("/etc/iproute2/rt_realms",
                 rtnl_rtrealm_tab, 256);
+}
 int rtnl_rtrealm_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_rtrealm_init)
+        rtnl_rtrealm_initialize();
+    for (i=0; i<256; i++) {
+    static const char *cache = NULL;
+    static unsigned long res;
+    int i;
+    if (cache && strcmp(cache, arg) == 0) {
+        *id = res;
+        return 0;
+    }
+    rtnl_rtrealm_initialize();
+    for (i = 0; i < 256; i++) {
         if (rtnl_rtrealm_tab[i] &&
             strcmp(rtnl_rtrealm_tab[i], arg) == 0) {
 …
+    }
     res = strtoul(arg, &end, 0);
     if (!end || end == arg || *end || res > 255)
+    res = bb_strtoul(arg, NULL, 0);
+    if (errno || res > 255)
         return -1;
     *id = res;
 …
+}
+static char * rtnl_rtdsfield_tab[256] = {
+    "0",
+};
+static int rtnl_rtdsfield_init;
+#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;
+    }
+    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] */
 static void rtnl_rtdsfield_initialize(void)
+{
+    rtnl_rtdsfield_init = 1;
+    if (rtnl_rtdsfield_tab) return;
+    rtnl_rtdsfield_tab = xzalloc(256 * sizeof(rtnl_rtdsfield_tab[0]));
+    rtnl_rtdsfield_tab[0] = "0";
     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 (id < 0 || id >= 256) {
+        snprintf(buf, len, "%d", id);
+        return buf;
+    }
+    rtnl_rtdsfield_initialize();
     if (rtnl_rtdsfield_tab[id])
         return rtnl_rtdsfield_tab[id];
 …
 int rtnl_dsfield_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_rtdsfield_init)
+        rtnl_rtdsfield_initialize();
+    for (i=0; i<256; i++) {
+    static const char *cache = NULL;
+    static unsigned long res;
+    int i;
+    if (cache && strcmp(cache, arg) == 0) {
+        *id = res;
+        return 0;
+    }
+    rtnl_rtdsfield_initialize();
+    for (i = 0; i < 256; i++) {
         if (rtnl_rtdsfield_tab[i] &&
             strcmp(rtnl_rtdsfield_tab[i], arg) == 0) {
 …
+    }
     res = strtoul(arg, &end, 16);
     if (!end || end == arg || *end || res > 255)
+    res = bb_strtoul(arg, NULL, 16);
+    if (errno || res > 255)
         return -1;
     *id = res;
 …
+}
+#if ENABLE_FEATURE_IP_RULE
+static const char **rtnl_rttable_tab; /* [256] */
+static void rtnl_rttable_initialize(void)
+{
+    if (rtnl_rtdsfield_tab) return;
+    rtnl_rttable_tab = xzalloc(256 * sizeof(rtnl_rttable_tab[0]));
+    rtnl_rttable_tab[0] = "unspec";
+    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;
+    }
+    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;
+    int i;
+    if (cache && strcmp(cache, arg) == 0) {
+        *id = res;
+        return 0;
+    }
+    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 = bb_strtoul(arg, NULL, 0);
+    if (errno || i > 255)
+        return -1;
+    *id = i;
+    return 0;
+}
+#endif

branches/stable/mindi-busybox/networking/libiproute/rt_names.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 #ifndef RT_NAMES_H_
 #define RT_NAMES_H_ 1
 …
 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_type_n2a(int type, char *buf, int len);
 extern const char *ll_addr_n2a(unsigned char *addr, int alen, int type,
+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 const char* ll_proto_n2a(unsigned short id, char *buf, int len);
 extern int ll_proto_a2n(unsigned short *id, char *buf);
 #endif

branches/stable/mindi-busybox/networking/libiproute/rtm_map.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * rtm_map.c
 …
  */
+#include <stdlib.h>
+#include <string.h>
+#include "libbb.h"
 #include "rt_names.h"
 #include "utils.h"
 char *rtnl_rtntype_n2a(int id, char *buf, int len)
+const char *rtnl_rtntype_n2a(int id, char *buf, int len)
+{
     switch (id) {
 …
 int rtnl_rtntype_a2n(int *id, char *arg)
+{
+    static const char keywords[] ALIGN1 =
+        "local\0""nat\0""broadcast\0""brd\0""anycast\0"
+        "multicast\0""prohibit\0""unreachable\0""blackhole\0"
+        "xresolve\0""unicast\0""throw\0";
+    enum {
+        ARG_local = 1, ARG_nat, ARG_broadcast, ARG_brd, ARG_anycast,
+        ARG_multicast, ARG_prohibit, ARG_unreachable, ARG_blackhole,
+        ARG_xresolve, ARG_unicast, ARG_throw
+    };
+    const smalluint key = index_in_substrings(keywords, arg) + 1;
     char *end;
     unsigned long res;
     if (strcmp(arg, "local") == 0)
+    if (key == ARG_local)
         res = RTN_LOCAL;
     else if (strcmp(arg, "nat") == 0)
+    else if (key == ARG_nat)
         res = RTN_NAT;
+    else if (matches(arg, "broadcast") == 0 ||
+         strcmp(arg, "brd") == 0)
+    else if (key == ARG_broadcast || key == ARG_brd)
         res = RTN_BROADCAST;
     else if (matches(arg, "anycast") == 0)
+    else if (key == ARG_anycast)
         res = RTN_ANYCAST;
     else if (matches(arg, "multicast") == 0)
+    else if (key == ARG_multicast)
         res = RTN_MULTICAST;
     else if (matches(arg, "prohibit") == 0)
+    else if (key == ARG_prohibit)
         res = RTN_PROHIBIT;
     else if (matches(arg, "unreachable") == 0)
+    else if (key == ARG_unreachable)
         res = RTN_UNREACHABLE;
     else if (matches(arg, "blackhole") == 0)
+    else if (key == ARG_blackhole)
         res = RTN_BLACKHOLE;
     else if (matches(arg, "xresolve") == 0)
+    else if (key == ARG_xresolve)
         res = RTN_XRESOLVE;
     else if (matches(arg, "unicast") == 0)
+    else if (key == ARG_unicast)
         res = RTN_UNICAST;
     else if (strcmp(arg, "throw") == 0)
+    else if (key == ARG_throw)
         res = RTN_THROW;
     else {
 …
+}
 int get_rt_realms(__u32 *realms, char *arg)
+int get_rt_realms(uint32_t *realms, char *arg)
+{
     __u32 realm = 0;
+    uint32_t realm = 0;
     char *p = strchr(arg, '/');

branches/stable/mindi-busybox/networking/libiproute/rtm_map.h

-              r821
+              r1770
+/* 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);
+const 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);
+int get_rt_realms(uint32_t *realms, char *arg);

branches/stable/mindi-busybox/networking/libiproute/utils.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * utils.c
 …
 #include "libbb.h"
-#include <string.h>
-#include <unistd.h>
 #include "utils.h"
 #include "inet_common.h"
 …
     return 0;
+}
+//XXX: FIXME: use some libbb function instead
 int get_unsigned(unsigned *val, char *arg, int base)
+{
 …
+}
 int get_u32(__u32 * val, char *arg, int base)
+int get_u32(uint32_t * val, char *arg, int base)
+{
     unsigned long res;
 …
+}
 int get_u16(__u16 * val, char *arg, int base)
+int get_u16(uint16_t * val, char *arg, int base)
+{
     unsigned long res;
 …
+}
 int get_u8(__u8 * val, char *arg, int base)
+int get_u8(uint8_t * val, char *arg, int base)
+{
     unsigned long res;
 …
+}
 int get_s16(__s16 * val, char *arg, int base)
+int get_s16(int16_t * val, char *arg, int base)
+{
     long res;
 …
+}
 int get_s8(__s8 * val, char *arg, int base)
+int get_s8(int8_t * val, char *arg, int base)
+{
     long res;
 …
     memset(addr, 0, sizeof(*addr));
     if (strcmp(name, bb_INET_default) == 0 ||
+    if (strcmp(name, bb_str_default) == 0 ||
         strcmp(name, "all") == 0 || strcmp(name, "any") == 0) {
         addr->family = family;
 …
     memset(dst, 0, sizeof(*dst));
     if (strcmp(arg, bb_INET_default) == 0 || strcmp(arg, "any") == 0) {
+    if (strcmp(arg, bb_str_default) == 0 || strcmp(arg, "any") == 0) {
         dst->family = family;
         dst->bytelen = 0;
 …
     slash = strchr(arg, '/');
     if (slash)
         *slash = 0;
+        *slash = '\0';
     err = get_addr_1(dst, arg, family);
     if (err == 0) {
 …
+        }
+    }
   done:
+ done:
     if (slash)
         *slash = '/';
 …
+{
     if (family == AF_PACKET) {
         bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context.", arg);
+        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);
+        bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
+    }
     return 0;
 …
+{
     if (family == AF_PACKET) {
         bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context.", arg);
+        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)
+        bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
+    }
+    return 0;
+}
+uint32_t get_addr32(char *name)
+{
     inet_prefix addr;
 …
 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 a garbage.", key, arg);
+    exit(-1);
+}
+int matches(char *cmd, char *pattern)
+{
+    int len = strlen(cmd);
+    if (len > strlen(pattern)) {
+        return -1;
+    }
+    return memcmp(pattern, cmd, len);
+    bb_error_msg_and_die("command line is not complete, try option \"help\"");
+}
+void invarg(const char *arg, const char *opt)
+{
+    bb_error_msg_and_die(bb_msg_invalid_arg, arg, opt);
+}
+void duparg(const char *key, const char *arg)
+{
+    bb_error_msg_and_die("duplicate \"%s\": \"%s\" is the second value", key, arg);
+}
+void duparg2(const char *key, const char *arg)
+{
+    bb_error_msg_and_die("either \"%s\" is duplicate, or \"%s\" is garbage", key, arg);
+}
 int inet_addr_match(inet_prefix * a, inet_prefix * b, int bits)
+{
     __u32 *a1 = a->data;
     __u32 *a2 = b->data;
+    uint32_t *a1 = a->data;
+    uint32_t *a2 = b->data;
     int words = bits >> 0x05;
 …
     if (bits) {
         __u32 w1, w2;
         __u32 mask;
+        uint32_t w1, w2;
+        uint32_t mask;
         w1 = a1[words];
 …
     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);
+}
 …
+            }
+        }
+        if (len > 0 && (h_ent = gethostbyaddr(addr, len, af)) != NULL) {
+            snprintf(buf, buflen - 1, "%s", h_ent->h_name);
+            return buf;
+        if (len > 0) {
+            h_ent = gethostbyaddr(addr, len, af);
+            if (h_ent != NULL) {
+                safe_strncpy(buf, h_ent->h_name, buflen);
+                return buf;
+            }
+        }
+    }

branches/stable/mindi-busybox/networking/libiproute/utils.h

-              r821
+              r1770
+/* 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"
 …
 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_;
+extern smallint show_stats;    /* UNUSED */
+extern smallint show_details;  /* UNUSED */
+extern smallint show_raw;      /* UNUSED */
+extern smallint resolve_hosts; /* UNUSED */
+extern smallint oneline;
+extern char _SL_;
 #ifndef IPPROTO_ESP
 …
 extern void incomplete_command(void) ATTRIBUTE_NORETURN;
 #define NEXT_ARG() do { argv++; if (--argc <= 0) incomplete_command(); } while(0)
+#define NEXT_ARG() do { argv++; if (--argc <= 0) incomplete_command(); } while (0)
 typedef struct
+{
     __u8 family;
     __u8 bytelen;
     __s16 bitlen;
     __u32 data[4];
+    uint8_t family;
+    uint8_t bytelen;
+    int16_t bitlen;
+    uint32_t data[4];
 } inet_prefix;
 …
 #endif
+struct dn_naddr
+{
+struct dn_naddr {
     unsigned short          a_len;
     unsigned char a_addr[DN_MAXADDL];
 …
 };
 extern __u32 get_addr32(char *name);
+extern uint32_t 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);
 …
 #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 int get_u32(uint32_t *val, char *arg, int base);
+extern int get_u16(uint16_t *val, char *arg, int base);
+extern int get_s16(int16_t *val, char *arg, int base);
+extern int get_u8(uint8_t *val, char *arg, int base);
+extern int get_s8(int8_t *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);
+void invarg(const char *, const char *) ATTRIBUTE_NORETURN;
+void duparg(const char *, const char *) ATTRIBUTE_NORETURN;
+void duparg2(const char *, const char *) ATTRIBUTE_NORETURN;
+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 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__ */

branches/stable/mindi-busybox/networking/nameif.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * nameif.c - Naming Interfaces based on MAC address for busybox.
 …
  */
+#include "busybox.h"
+#include <sys/syslog.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include "libbb.h"
+#include <syslog.h>
 #include <net/if.h>
 #include <netinet/ether.h>
 …
 } mactable_t;
-static unsigned long flags;
-static void serror(const char *s, ...) ATTRIBUTE_NORETURN;
-static void serror(const char *s, ...)
+{
-    va_list ap;
-    va_start(ap, s);
-    if (flags & 1) {
-        openlog(bb_applet_name, 0, LOG_LOCAL0);
-        vsyslog(LOG_ERR, s, ap);
-        closelog();
-    } else {
-        bb_verror_msg(s, ap);
-        putc('\n', stderr);
+    }
-    va_end(ap);
-    exit(EXIT_FAILURE);
+}
 /* Check ascii str_macaddr, convert and copy to *mac */
 static struct ether_addr *cc_macaddr(const char *str_macaddr)
 …
     lmac = ether_aton(str_macaddr);
     if (lmac == NULL)
         serror("cannot parse MAC %s", str_macaddr);
+        bb_error_msg_and_die("cannot parse MAC %s", str_macaddr);
     mac = xmalloc(ETH_ALEN);
     memcpy(mac, lmac, ETH_ALEN);
 …
+}
+int nameif_main(int argc, char **argv);
 int nameif_main(int argc, char **argv)
+{
 …
     mactable_t *ch;
+    flags = bb_getopt_ulflags(argc, argv, "sc:", &fname);
+    if (1 & getopt32(argv, "sc:", &fname)) {
+        openlog(applet_name, 0, LOG_LOCAL0);
+        logmode = LOGMODE_SYSLOG;
+    }
     if ((argc - optind) & 1)
 …
         while (*a) {
             if (strlen(*a) > IF_NAMESIZE)
+                serror("interface name `%s' too long", *a);
+                bb_error_msg_and_die("interface name '%s' "
+                        "too long", *a);
             ch = xzalloc(sizeof(mactable_t));
             ch->ifname = bb_xstrdup(*a++);
+            ch->ifname = xstrdup(*a++);
             ch->mac = cc_macaddr(*a++);
             if (clist)
 …
+        }
     } else {
         ifh = bb_xfopen(fname, "r");
+        ifh = xfopen(fname, "r");
         while ((line = bb_get_line_from_file(ifh)) != NULL) {
+        while ((line = xmalloc_fgets(ifh)) != NULL) {
             char *line_ptr;
             size_t name_length;
 …
             name_length = strcspn(line_ptr, " \t");
             ch = xzalloc(sizeof(mactable_t));
             ch->ifname = bb_xstrndup(line_ptr, name_length);
+            ch->ifname = xstrndup(line_ptr, name_length);
             if (name_length > IF_NAMESIZE)
+                serror("interface name `%s' too long", ch->ifname);
+                bb_error_msg_and_die("interface name '%s' "
+                        "too long", ch->ifname);
             line_ptr += name_length;
             line_ptr += strspn(line_ptr, " \t");
 …
+    }
+    if ((ctl_sk = socket(PF_INET, SOCK_DGRAM, 0)) == -1)
+        serror("socket: %m");
+    ctl_sk = xsocket(PF_INET, SOCK_DGRAM, 0);
     while (clist) {
 …
         strcpy(ifr.ifr_newname, ch->ifname);
         if (ioctl(ctl_sk, SIOCSIFNAME, &ifr) < 0)
             serror("cannot change ifname %s to %s: %m",
                    ifr.ifr_name, ch->ifname);
+        ioctl_or_perror_and_die(ctl_sk, SIOCSIFNAME, &ifr,
+                    "cannot change ifname %s to %s",
+                    ifr.ifr_name, ch->ifname);
         /* Remove list entry of renamed interface */

branches/stable/mindi-busybox/networking/nc.c

-              r821
+              r1770
 /* vi: set sw=4 ts=4: */
 /*  nc: mini-netcat - built from the ground up for LRP
+    Copyright (C) 1998  Charles P. Wright
+.0.1   6K      It works.
+.0.2   5K      Smaller and you can also check the exit condition if you wish.
+.0.3           Uses select()
+    19980918 Busy Boxed! Dave Cinege
+    19990512 Uses Select. Charles P. Wright
+    19990513 Fixes stdin stupidity and uses buffers.  Charles P. Wright
+    Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/ioctl.h>
+#include "busybox.h"
+ *
+ *  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 "libbb.h"
+#if ENABLE_DESKTOP
+#include "nc_bloaty.c"
+#else
+/* Lots of small differences in features
+ * when compared to "standard" nc
+ */
 static void timeout(int signum)
+{
     bb_error_msg_and_die("Timed out");
+    bb_error_msg_and_die("timed out");
+}
+int nc_main(int argc, char **argv);
 int nc_main(int argc, char **argv)
+{
+    int do_listen = 0, lport = 0, delay = 0, wsecs = 0, tmpfd, opt, sfd, x;
+#ifdef CONFIG_NC_GAPING_SECURITY_HOLE
+    char *pr00gie = NULL;
+#endif
+    struct sockaddr_in address;
+    struct hostent *hostinfo;
+    /* sfd sits _here_ only because of "repeat" option (-l -l). */
+    int sfd = sfd; /* for gcc */
+    int cfd = 0;
+    unsigned lport = 0;
+    SKIP_NC_SERVER(const) unsigned do_listen = 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;)
+    len_and_sockaddr *lsa;
     fd_set readfds, testfds;
+    while ((opt = getopt(argc, argv, "lp:i:e:w:")) > 0) {
+        switch (opt) {
+            case 'l':
+                do_listen++;
+                break;
+            case 'p':
+                lport = bb_lookup_port(optarg, "tcp", 0);
+                break;
+            case 'i':
+                delay = atoi(optarg);
+                break;
+#ifdef CONFIG_NC_GAPING_SECURITY_HOLE
+            case 'e':
+                pr00gie = optarg;
+                break;
+#endif
+            case 'w':
+                wsecs = atoi(optarg);
+                break;
+            default:
+                bb_show_usage();
+        }
+    }
+    if ((do_listen && optind != argc) || (!do_listen && optind + 2 != argc))
+        bb_show_usage();
+    sfd = bb_xsocket(AF_INET, SOCK_STREAM, 0);
+    x = 1;
+    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof (x)) == -1)
+        bb_perror_msg_and_die("reuseaddr");
+    address.sin_family = AF_INET;
+    int opt; /* must be signed (getopt returns -1) */
+    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
+        if (do_listen || cfd) {
+            if (argc) bb_show_usage();
+        } else {
+            if (!argc || argc > 2) bb_show_usage();
+        }
+    } else {
+        if (argc != 3) bb_show_usage();
+        argc--;
+        argv++;
+    }
     if (wsecs) {
 …
+    }
+    if (lport != 0) {
+        memset(&address.sin_addr, 0, sizeof(address.sin_addr));
+        address.sin_port = lport;
+        bb_xbind(sfd, (struct sockaddr *) &address, sizeof(address));
+    }
+    if (do_listen) {
+        socklen_t addrlen = sizeof(address);
+        bb_xlisten(sfd, 1);
+        if ((tmpfd = accept(sfd, (struct sockaddr *) &address, &addrlen)) < 0)
+            bb_perror_msg_and_die("accept");
+        close(sfd);
+        sfd = tmpfd;
+    } else {
+        hostinfo = xgethostbyname(argv[optind]);
+        address.sin_addr = *(struct in_addr *) *hostinfo->h_addr_list;
+        address.sin_port = bb_lookup_port(argv[optind+1], "tcp", 0);
+        if (connect(sfd, (struct sockaddr *) &address, sizeof(address)) < 0)
+            bb_perror_msg_and_die("connect");
+    if (!cfd) {
+        if (do_listen) {
+            /* create_and_bind_stream_or_die(NULL, lport)
+             * would've work wonderfully, but we need
+             * to know lsa */
+            sfd = xsocket_stream(&lsa);
+            if (lport)
+                set_nport(lsa, htons(lport));
+            setsockopt_reuseaddr(sfd);
+            xbind(sfd, &lsa->sa, lsa->len);
+            xlisten(sfd, do_listen); /* can be > 1 */
+            /* If we didn't specify a port number,
+             * query and print it after listen() */
+            if (!lport) {
+                socklen_t addrlen = lsa->len;
+                getsockname(sfd, &lsa->sa, &addrlen);
+                lport = get_nport(&lsa->sa);
+                fdprintf(2, "%d\n", ntohs(lport));
+            }
+            fcntl(sfd, F_SETFD, FD_CLOEXEC);
+ accept_again:
+            cfd = accept(sfd, NULL, 0);
+            if (cfd < 0)
+                bb_perror_msg_and_die("accept");
+            if (!execparam)
+                close(sfd);
+        } else {
+            cfd = create_and_connect_stream_or_die(argv[0],
+                argv[1] ? bb_lookup_port(argv[1], "tcp", 0) : 0);
+        }
+    }
 …
+    }
-#ifdef CONFIG_NC_GAPING_SECURITY_HOLE
     /* -e given? */
+    if (pr00gie) {
+        dup2(sfd, 0);
+        close(sfd);
+    if (execparam) {
+        signal(SIGCHLD, SIG_IGN);
+        // With more than one -l, repeatedly act as server.
+        if (do_listen > 1 && vfork()) {
+            /* parent */
+            // 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 accept_again;
+        }
+        /* child (or main thread if no multiple -l) */
+        if (cfd) {
+            dup2(cfd, 0);
+            close(cfd);
+        }
         dup2(0, 1);
         dup2(0, 2);
         execl(pr00gie, pr00gie, NULL);
+        USE_NC_EXTRA(BB_EXECVP(execparam[0], execparam);)
         /* Don't print stuff or it will go over the wire.... */
+        _exit(-1);
+    }
+#endif /* CONFIG_NC_GAPING_SECURITY_HOLE */
+        _exit(127);
+    }
+    // Select loop copying stdin to cfd, and cfd to stdout.
     FD_ZERO(&readfds);
     FD_SET(sfd, &readfds);
+    FD_SET(cfd, &readfds);
     FD_SET(STDIN_FILENO, &readfds);
     while (1) {
+    for (;;) {
         int fd;
         int ofd;
 …
             bb_perror_msg_and_die("select");
+#define iobuf bb_common_bufsiz1
         for (fd = 0; fd < FD_SETSIZE; fd++) {
             if (FD_ISSET(fd, &testfds)) {
+                if ((nread = safe_read(fd, bb_common_bufsiz1,
+                    sizeof(bb_common_bufsiz1))) < 0)
+                {
+                    bb_perror_msg_and_die(bb_msg_read_error);
+                }
+                if (fd == sfd) {
+                    if (nread == 0)
+                nread = safe_read(fd, iobuf, sizeof(iobuf));
+                if (fd == cfd) {
+                    if (nread < 1)
                         exit(0);
                     ofd = STDOUT_FILENO;
                 } else {
+                    if (nread <= 0) {
+                        shutdown(sfd, 1 /* send */ );
+                        close(STDIN_FILENO);
+                    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 = sfd;
+                    ofd = cfd;
+                }
+                if (bb_full_write(ofd, bb_common_bufsiz1, nread) < 0)
+                    bb_perror_msg_and_die(bb_msg_write_error);
+                if (delay > 0) {
+                    sleep(delay);
+                }
+                xwrite(ofd, iobuf, nread);
+                if (delay > 0) sleep(delay);
+            }
+        }
+    }
+}
+#endif

branches/stable/mindi-busybox/networking/netstat.c

-              r821
+              r1770
  * Copyright (C) 2002 by Bart Visscher <magick@linux-fan.com>
+ *
- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
  * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+#include "libbb.h"
 #include "inet_common.h"
-#include "busybox.h"
-#include "pwd_.h"
-#ifdef CONFIG_ROUTE
-extern void displayroutes(int noresolve, int netstatfmt);
-#endif
-#define NETSTAT_CONNECTED   0x01
-#define NETSTAT_LISTENING   0x02
-#define NETSTAT_NUMERIC     0x04
-#define NETSTAT_TCP         0x10
-#define NETSTAT_UDP         0x20
-#define NETSTAT_RAW         0x40
-#define NETSTAT_UNIX        0x80
-static int flags = NETSTAT_CONNECTED |
-            NETSTAT_TCP | NETSTAT_UDP | NETSTAT_RAW | NETSTAT_UNIX;
-#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 */
+    OPT_extended = 0x4,
+    OPT_showroute = 0x100,
+    OPT_widedisplay = 0x200 * ENABLE_FEATURE_NETSTAT_WIDE,
 };
+static const char * const tcp_state[] =
+{
+    "",
+    "ESTABLISHED",
+    "SYN_SENT",
+    "SYN_RECV",
+    "FIN_WAIT1",
+    "FIN_WAIT2",
+    "TIME_WAIT",
+    "CLOSE",
+    "CLOSE_WAIT",
+    "LAST_ACK",
+    "LISTEN",
+    "CLOSING"
+# define NETSTAT_OPTS "laentuwxr"USE_FEATURE_NETSTAT_WIDE("W")
+#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 smallint flags = NETSTAT_CONNECTED | NETSTAT_ALLPROTO;
+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  */
+    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 *itoa(unsigned int i)
+{
+    /* 21 digits plus null terminator, good for 64-bit or smaller ints */
+    static char local[22];
+    char *p = &local[21];
+    *p-- = '\0';
+    do {
+        *p-- = '0' + i % 10;
+        i /= 10;
+    } while (i > 0);
+    return p + 1;
+}
+static char *get_sname(int port, const char *proto, int num)
+{
+    char *str=itoa(ntohs(port));
+    if (num) {
+#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            */
+/* Standard printout size */
+#define PRINT_IP_MAX_SIZE           23
+#define PRINT_NET_CONN              "%s   %6ld %6ld %-23s %-23s %-12s\n"
+#define PRINT_NET_CONN_HEADER       "\nProto Recv-Q Send-Q %-23s %-23s State\n"
+/* When there are IPv6 connections the IPv6 addresses will be
+ * truncated to none-recognition. The '-W' option makes the
+ * address columns wide enough to accomodate for longest possible
+ * IPv6 addresses, i.e. addresses of the form
+ * xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:ddd.ddd.ddd.ddd
+ */
+#define PRINT_IP_MAX_SIZE_WIDE      51  /* INET6_ADDRSTRLEN + 5 for the port number */
+#define PRINT_NET_CONN_WIDE         "%s   %6ld %6ld %-51s %-51s %-12s\n"
+#define PRINT_NET_CONN_HEADER_WIDE  "\nProto Recv-Q Send-Q %-51s %-51s State\n"
+static const char *net_conn_line = PRINT_NET_CONN;
+#if ENABLE_FEATURE_IPV6
+static void build_ipv6_addr(char* local_addr, struct sockaddr_in6* localaddr)
+{
+    char addr6[INET6_ADDRSTRLEN];
+    struct in6_addr in6;
+    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);
+    localaddr->sin6_family = AF_INET6;
+}
+#endif
+#if ENABLE_FEATURE_IPV6
+static void build_ipv4_addr(char* local_addr, struct sockaddr_in6* localaddr)
+#else
+static void build_ipv4_addr(char* local_addr, struct sockaddr_in* localaddr)
+#endif
+{
+    sscanf(local_addr, "%X",
+           &((struct sockaddr_in *) localaddr)->sin_addr.s_addr);
+    ((struct sockaddr *) localaddr)->sa_family = AF_INET;
+}
+static const char *get_sname(int port, const char *proto, int numeric)
+{
+    if (!port)
+        return "*";
+    if (!numeric) {
+        struct servent *se = getservbyport(port, proto);
+        if (se)
+            return se->s_name;
+    }
+    /* hummm, we may return static buffer here!! */
+    return itoa(ntohs(port));
+}
+static char *ip_port_str(struct sockaddr *addr, int port, const char *proto, int numeric)
+{
+    enum { salen = USE_FEATURE_IPV6(sizeof(struct sockaddr_in6)) SKIP_FEATURE_IPV6(sizeof(struct sockaddr_in)) };
+    char *host, *host_port;
+    /* Code which used "*" for INADDR_ANY is removed: it's ambiguous in IPv6,
+     * while "0.0.0.0" is not. */
+    host = numeric ? xmalloc_sockaddr2dotted_noport(addr)
+                   : xmalloc_sockaddr2host_noport(addr);
+    host_port = xasprintf("%s:%s", host, get_sname(htons(port), proto, numeric));
+    free(host);
+    return host_port;
+}
+static void tcp_do_one(int lnr, const char *line)
+{
+    char local_addr[64], rem_addr[64];
+    char more[512];
+    int num, local_port, rem_port, d, state, timer_run, uid, timeout;
+#if ENABLE_FEATURE_IPV6
+    struct sockaddr_in6 localaddr, remaddr;
+#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) {
+#if ENABLE_FEATURE_IPV6
+        build_ipv6_addr(local_addr, &localaddr);
+        build_ipv6_addr(rem_addr, &remaddr);
+#endif
     } 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,
+x4000 | ((numeric&NETSTAT_NUMERIC) ? 0x0fff : 0),
+xffffffff);
+    }
+    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)
+        build_ipv4_addr(local_addr, &localaddr);
+        build_ipv4_addr(rem_addr, &remaddr);
+    }
+    if (num < 10) {
+        bb_error_msg("warning, got bogus tcp line");
+        return;
+    }
+    if ((rem_port && (flags & NETSTAT_CONNECTED))
+     || (!rem_port && (flags & NETSTAT_LISTENING))
+    ) {
+        char *l = ip_port_str(
+                (struct sockaddr *) &localaddr, local_port,
+                "tcp", flags & NETSTAT_NUMERIC);
+        char *r = ip_port_str(
+                (struct sockaddr *) &remaddr, rem_port,
+                "tcp", flags & NETSTAT_NUMERIC);
+        printf(net_conn_line,
+            "tcp", rxq, txq, l, r, tcp_state[state]);
+        free(l);
+        free(r);
+    }
+}
+static void udp_do_one(int lnr, const char *line)
+{
     char local_addr[64], rem_addr[64];
 …
     char more[512];
     int num, local_port, rem_port, d, state, timer_run, uid, timeout;
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     struct sockaddr_in6 localaddr, remaddr;
-    char addr6[INET6_ADDRSTRLEN];
-    struct in6_addr in6;
 #else
     struct sockaddr_in localaddr, remaddr;
 …
     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);
+            "%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;
+#if ENABLE_FEATURE_IPV6
+        /* Demangle what the kernel gives us */
+        build_ipv6_addr(local_addr, &localaddr);
+        build_ipv6_addr(rem_addr, &remaddr);
 #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;
+        build_ipv4_addr(local_addr, &localaddr);
+        build_ipv4_addr(rem_addr, &remaddr);
+    }
     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.");
+        bb_error_msg("warning, got bogus udp line");
         return;
+    }
 …
             state_str = "ESTABLISHED";
             break;
         case TCP_CLOSE:
             state_str = "";
             break;
         default:
             state_str = "UNKNOWN";
 …
+    }
+#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))
+#if ENABLE_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);
+        int have_remaddr = notnull(remaddr);
+        if ((have_remaddr && (flags & NETSTAT_CONNECTED))
+         || (!have_remaddr && (flags & NETSTAT_LISTENING))
+        ) {
+            char *l = ip_port_str(
+                (struct sockaddr *) &localaddr, local_port,
+                "udp", flags & NETSTAT_NUMERIC);
+            char *r = ip_port_str(
+                (struct sockaddr *) &remaddr, rem_port,
+                "udp", flags & NETSTAT_NUMERIC);
+            printf(net_conn_line,
+                "udp", rxq, txq, l, r, state_str);
+            free(l);
+            free(r);
+        }
+    }
+}
 …
+{
     char local_addr[64], rem_addr[64];
     char *state_str, more[512];
+    char more[512];
     int num, local_port, rem_port, d, state, timer_run, uid, timeout;
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     struct sockaddr_in6 localaddr, remaddr;
-    char addr6[INET6_ADDRSTRLEN];
-    struct in6_addr in6;
 #else
     struct sockaddr_in localaddr, remaddr;
 …
     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);
+            "%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;
+#if ENABLE_FEATURE_IPV6
+        build_ipv6_addr(local_addr, &localaddr);
+        build_ipv6_addr(rem_addr, &remaddr);
 #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;
+        build_ipv4_addr(local_addr, &localaddr);
+        build_ipv4_addr(rem_addr, &remaddr);
+    }
     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)))
+        bb_error_msg("warning, got bogus raw line");
+        return;
+    }
+    {
+        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
+        int have_remaddr = notnull(remaddr);
+        if ((have_remaddr && (flags & NETSTAT_CONNECTED))
+         || (!have_remaddr && (flags & NETSTAT_LISTENING))
+        ) {
+            char *l = ip_port_str(
+                (struct sockaddr *) &localaddr, local_port,
+                "raw", flags & NETSTAT_NUMERIC);
+            char *r = ip_port_str(
+                (struct sockaddr *) &remaddr, rem_port,
+                "raw", flags & NETSTAT_NUMERIC);
+            printf(net_conn_line,
+                "raw", rxq, txq, l, r, itoa(state));
+            free(l);
+            free(r);
+        }
+    }
+}
 static void unix_do_one(int nr, const char *line)
+{
+    static int has = 0;
+    static smallint has_inode = 0;
     char path[PATH_MAX], ss_flags[32];
     char *ss_proto, *ss_state, *ss_type;
+    const char *ss_proto, *ss_state, *ss_type;
     int num, state, type, inode;
     void *d;
 …
     if (nr == 0) {
         if (strstr(line, "Inode"))
             has |= HAS_INODE;
+            has_inode = 1;
         return;
+    }
     path[0] = '\0';
     num = sscanf(line, "%p: %lX %lX %lX %X %X %d %s",
                  &d, &refcnt, &proto, &unix_flags, &type, &state, &inode, path);
+            &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)) {
+        bb_error_msg("warning, got bogus unix line");
+        return;
+    }
+    if (!has_inode)
+        sprintf(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))
+            if (!(flags & NETSTAT_LISTENING))
                 return;
         } else {
             if (!(flags&NETSTAT_CONNECTED))
+            if (!(flags & NETSTAT_CONNECTED))
                 return;
+        }
 …
             ss_proto = "unix";
             break;
         default:
             ss_proto = "??";
 …
             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";
 …
             ss_state = "FREE";
             break;
         case SS_UNCONNECTED:
             /*
 …
+            }
             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";
 …
     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);
+    if (has_inode)
+        printf("%-6d ", inode);
     else
         printf("-      ");
 …
 static void do_info(const char *file, const char *name, void (*proc)(int, const char *))
+{
-    char buffer[8192];
     int lnr = 0;
     FILE *procinfo;
 …
     if (procinfo == NULL) {
         if (errno != ENOENT) {
             perror(file);
+            bb_perror_msg("%s", file);
         } else {
         bb_error_msg("no support for `%s' on this system.", name);
+            bb_error_msg("no support for '%s' on this system", name);
+        }
+    } else {
+        do {
+            if (fgets(buffer, sizeof(buffer), procinfo))
+                (proc)(lnr++, buffer);
+        } while (!feof(procinfo));
+        fclose(procinfo);
+    }
+        return;
+    }
+    do {
+        char *buffer = xmalloc_fgets(procinfo);
+        if (buffer) {
+            (proc)(lnr++, buffer);
+            free(buffer);
+        }
+    } while (!feof(procinfo));
+    fclose(procinfo);
+}
 …
  */
+int netstat_main(int argc, char **argv);
 int netstat_main(int argc, char **argv)
+{
+    int opt;
+    int new_flags=0;
+    int showroute = 0, extended = 0;
+#ifdef CONFIG_FEATURE_IPV6
+    int inet=1;
+    int inet6=1;
+#else
+# define inet 1
+# define inet6 0
+#endif
+    while ((opt = getopt(argc, argv, "laenrtuwx")) != -1)
+        switch (opt) {
+        case 'l':
+            flags &= ~NETSTAT_CONNECTED;
+            flags |= NETSTAT_LISTENING;
+            break;
+        case 'a':
+            flags |= NETSTAT_LISTENING | NETSTAT_CONNECTED;
+            break;
+        case 'n':
+            flags |= NETSTAT_NUMERIC;
+            break;
+        case 'r':
+            showroute = 1;
+            break;
+        case 'e':
+            extended = 1;
+            break;
+        case 't':
+            new_flags |= NETSTAT_TCP;
+            break;
+        case 'u':
+            new_flags |= NETSTAT_UDP;
+            break;
+        case 'w':
+            new_flags |= NETSTAT_RAW;
+            break;
+        case 'x':
+            new_flags |= NETSTAT_UNIX;
+            break;
+        default:
+            bb_show_usage();
+        }
+    if ( showroute ) {
+#ifdef CONFIG_ROUTE
+        displayroutes ( flags & NETSTAT_NUMERIC, !extended );
+    const char *net_conn_line_header = PRINT_NET_CONN_HEADER;
+    unsigned opt;
+#if ENABLE_FEATURE_IPV6
+    smallint inet = 1;
+    smallint inet6 = 1;
+#else
+    enum { inet = 1, inet6 = 0 };
+#endif
+    /* Option string must match NETSTAT_xxx constants */
+    opt = getopt32(argv, NETSTAT_OPTS);
+    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
+#if ENABLE_ROUTE
+        bb_displayroutes(flags & NETSTAT_NUMERIC, !(opt & OPT_extended));
         return 0;
 #else
+        bb_error_msg_and_die( "-r (display routing table) is not compiled in." );
+#endif
+    }
+    if (new_flags) {
+        flags &= ~(NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW|NETSTAT_UNIX);
+        flags |= new_flags;
+    }
+    if (flags&(NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW)) {
+        bb_show_usage();
+#endif
+    }
+    if (opt & OPT_widedisplay) { // -W
+        net_conn_line = PRINT_NET_CONN_WIDE;
+        net_conn_line_header = PRINT_NET_CONN_HEADER_WIDE;
+    }
+    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))
+        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) {
+        else if (flags & NETSTAT_LISTENING)
+            printf("(only servers)");
+        else
+            printf("(w/o servers)");
+        printf(net_conn_line_header, "Local Address", "Foreign Address");
+    }
+    if (inet && flags & NETSTAT_TCP)
+        do_info(_PATH_PROCNET_TCP, "AF INET (tcp)", tcp_do_one);
+#if ENABLE_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);
+#if ENABLE_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);
+#if ENABLE_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))
+        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)");
+        }
+        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);
+        do_info(_PATH_PROCNET_UNIX, "AF UNIX", unix_do_one);
+    }
     return 0;

branches/stable/mindi-busybox/networking/nslookup.c

-              r821
+              r1770
  * added by Ben Zeckel <bzeckel@hmc.edu> June 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <netdb.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <netinet/in.h>
 #include <resolv.h>
+#include <arpa/inet.h>
+#include "busybox.h"
+#include "libbb.h"
 /*
  |  I'm only implementing non-interactive mode;
  |  I totally forgot nslookup even had an interactive mode.
+ *  I'm only implementing non-interactive mode;
+ *  I totally forgot nslookup even had an interactive mode.
  */
+/* only works for IPv4 */
+static int addr_fprint(char *addr)
+/* 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 print_host(const char *hostname, const char *header)
+{
+    uint8_t split[4];
+    uint32_t ip;
+    uint32_t *x = (uint32_t *) addr;
+    /* We can't use xhost2sockaddr() - we want to get ALL addresses,
+     * not just one */
+    ip = ntohl(*x);
+    split[0] = (ip & 0xff000000) >> 24;
+    split[1] = (ip & 0x00ff0000) >> 16;
+    split[2] = (ip & 0x0000ff00) >> 8;
+    split[3] = (ip & 0x000000ff);
+    printf("%d.%d.%d.%d", split[0], split[1], split[2], split[3]);
+    return 0;
+}
+    struct addrinfo *result = NULL;
+    int rc;
+    struct addrinfo hint;
+/* takes the NULL-terminated array h_addr_list, and
+ * prints its contents appropriately
+ */
+static int addr_list_fprint(char **h_addr_list)
+{
+    int i, j;
+    char *addr_string = (h_addr_list[1])
+        ? "Addresses: " : "Address:   ";
+    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);
     printf("%s ", addr_string);
     for (i = 0, j = 0; h_addr_list[i]; i++, j++) {
         addr_fprint(h_addr_list[i]);
+    if (!rc) {
+        struct addrinfo *cur = result;
+        unsigned cnt = 0;
+        /* real nslookup does this */
+        if (j == 4) {
+            if (h_addr_list[i + 1]) {
+                printf("\n          ");
+        printf("%-10s %s\n", header, hostname);
+        // printf("%s\n", cur->ai_canonname); ?
+        while (cur) {
+            char *dotted, *revhost;
+            dotted = xmalloc_sockaddr2dotted_noport(cur->ai_addr);
+            revhost = xmalloc_sockaddr2hostonly_noport(cur->ai_addr);
+            printf("Address %u: %s%c", ++cnt, dotted, revhost ? ' ' : '\n');
+            if (revhost) {
+                puts(revhost);
+                if (ENABLE_FEATURE_CLEAN_UP)
+                    free(revhost);
+            }
+            j = 0;
+        } else {
+            if (h_addr_list[i + 1]) {
+                printf(", ");
+            }
+            if (ENABLE_FEATURE_CLEAN_UP)
+                free(dotted);
+            cur = cur->ai_next;
+        }
+    } else {
+#if ENABLE_VERBOSE_RESOLUTION_ERRORS
+        bb_error_msg("can't resolve '%s': %s", hostname, gai_strerror(rc));
+#else
+        bb_error_msg("can't resolve '%s'", hostname);
+#endif
+    }
+    printf("\n");
+    return 0;
+}
+/* print the results as nslookup would */
+static struct hostent *hostent_fprint(struct hostent *host, const char *server_host)
+{
+    if (host) {
+        printf("%s     %s\n", server_host, host->h_name);
+        addr_list_fprint(host->h_addr_list);
+    } else {
+        printf("*** Unknown host\n");
+    }
+    return host;
+}
+/* changes a c-string matching the perl regex \d+\.\d+\.\d+\.\d+
+ * into a uint32_t
+ */
+static uint32_t str_to_addr(const char *addr)
+{
+    uint32_t split[4];
+    uint32_t ip;
+    sscanf(addr, "%d.%d.%d.%d",
+           &split[0], &split[1], &split[2], &split[3]);
+    /* assuming sscanf worked */
+    ip = (split[0] << 24) |
+        (split[1] << 16) | (split[2] << 8) | (split[3]);
+    return htonl(ip);
+}
+/* gethostbyaddr wrapper */
+static struct hostent *gethostbyaddr_wrapper(const char *address)
+{
+    struct in_addr addr;
+    addr.s_addr = str_to_addr(address);
+    return gethostbyaddr((char *) &addr, 4, AF_INET);   /* IPv4 only for now */
+    if (ENABLE_FEATURE_CLEAN_UP)
+        freeaddrinfo(result);
+    return (rc != 0);
+}
 /* lookup the default nameserver and display it */
 static inline void server_print(void)
+static void server_print(void)
+{
+    struct sockaddr_in def = _res.nsaddr_list[0];
+    char *ip = inet_ntoa(def.sin_addr);
+    char *server;
+    hostent_fprint(gethostbyaddr_wrapper(ip), "Server:");
+    printf("\n");
+    server = xmalloc_sockaddr2dotted_noport((struct sockaddr*)&_res.nsaddr_list[0]);
+    /* I honestly don't know what to do if DNS server has _IPv6 address_.
+     * Probably it is listed in
+     * _res._u._ext_.nsaddrs[MAXNS] (of type "struct sockaddr_in6*" each)
+     * but how to find out whether resolver uses
+     * _res.nsaddr_list[] or _res._u._ext_.nsaddrs[], or both?
+     * Looks like classic design from hell, BIND-grade. Hard to surpass. */
+    print_host(server, "Server:");
+    if (ENABLE_FEATURE_CLEAN_UP)
+        free(server);
+    puts("");
+}
 /* alter the global _res nameserver structure to use
    an explicit dns server instead of what is in /etc/resolv.h */
 static inline void set_default_dns(char *server)
+static void set_default_dns(char *server)
+{
     struct in_addr server_in_addr;
+    if(inet_aton(server,&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;
 …
+}
+/* naive function to check whether char *s is an ip address */
+static int is_ip_address(const char *s)
+{
+    while (*s) {
+        if ((isdigit(*s)) || (*s == '.')) {
+            s++;
+            continue;
+        }
+        return 0;
+    }
+    return 1;
+}
+/* ________________________________________________________________________ */
+int nslookup_main(int argc, char **argv);
 int nslookup_main(int argc, char **argv)
+{
+    struct hostent *host;
+    /* 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 */
+    /*
+    * initialize DNS structure _res used in printing the default
+    * name server and in the explicit name server option feature.
+    */
+    if (argc < 2 || *argv[1] == '-' || argc > 3)
+        bb_show_usage();
+    /* initialize DNS structure _res used in printing the default
+     * name server and in the explicit name server option feature. */
     res_init();
+    /* rfc2133 says this enables IPv6 lookups */
+    /* (but it also says "may be enabled in /etc/resolv.conf|) */
+    /*_res.options |= RES_USE_INET6;*/
+    /*
+    * 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)
+    if (argc == 3)
         set_default_dns(argv[2]);
     server_print();
+    if (is_ip_address(argv[1])) {
+        host = gethostbyaddr_wrapper(argv[1]);
+    } else {
+        host = xgethostbyname(argv[1]);
+    }
+    hostent_fprint(host, "Name:  ");
+    if (host) {
+        return EXIT_SUCCESS;
+    }
+    return EXIT_FAILURE;
+    return print_host(argv[1], "Name:");
+}
-/* $Id: nslookup.c,v 1.33 2004/10/13 07:25:01 andersen Exp $ */

branches/stable/mindi-busybox/networking/ping.c

-              r821
+              r1770
 /* 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
+ *
 …
  * 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.
+ * All rights reserved.
+ *
+ * This code is 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>
+/* from ping6.c:
+ * Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
+ *
+ * This version of ping is adapted from the ping in netkit-base 0.10,
+ * which is:
+ *
+ * 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 <net/if.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"
+#include "libbb.h"
+#if ENABLE_PING6
+#include <netinet/icmp6.h>
+/* I see RENUMBERED constants in bits/in.h - !!?
+ * What a fuck is going on with libc? Is it a glibc joke? */
+#ifdef IPV6_2292HOPLIMIT
+#undef IPV6_HOPLIMIT
+#define IPV6_HOPLIMIT IPV6_2292HOPLIMIT
+#endif
+#endif
 enum {
 …
     MAX_DUP_CHK = (8 * 128),
     MAXWAIT = 10,
     PINGINTERVAL = 1        /* second */
+    PINGINTERVAL = 1, /* 1 second */
 };
+#define O_QUIET         (1 << 0)
+/* 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;
+}
+#if !ENABLE_FEATURE_FANCY_PING
+/* simple version */
+static char *hostname;
+static void noresp(int ign ATTRIBUTE_UNUSED)
+{
+    printf("No response from %s\n", hostname);
+    exit(EXIT_FAILURE);
+}
+static void ping4(len_and_sockaddr *lsa)
+{
+    struct sockaddr_in pingaddr;
+    struct icmp *pkt;
+    int pingsock, c;
+    char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
+    pingsock = create_icmp_socket();
+    pingaddr = lsa->sin;
+    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 = xsendto(pingsock, packet, DEFDATALEN + ICMP_MINLEN,
+               (struct sockaddr *) &pingaddr, sizeof(pingaddr));
+    /* listen for replies */
+    while (1) {
+        struct sockaddr_in from;
+        socklen_t fromlen = sizeof(from);
+        c = recvfrom(pingsock, packet, sizeof(packet), 0,
+                (struct sockaddr *) &from, &fromlen);
+        if (c < 0) {
+            if (errno != EINTR)
+                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);
+}
+#if ENABLE_PING6
+static void ping6(len_and_sockaddr *lsa)
+{
+    struct sockaddr_in6 pingaddr;
+    struct icmp6_hdr *pkt;
+    int pingsock, c;
+    int sockopt;
+    char packet[DEFDATALEN + MAXIPLEN + MAXICMPLEN];
+    pingsock = create_icmp6_socket();
+    pingaddr = lsa->sin6;
+    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, &sockopt, sizeof(sockopt));
+    c = xsendto(pingsock, packet, DEFDATALEN + sizeof (struct icmp6_hdr),
+               (struct sockaddr *) &pingaddr, sizeof(pingaddr));
+    /* listen for replies */
+    while (1) {
+        struct sockaddr_in6 from;
+        socklen_t fromlen = sizeof(from);
+        c = recvfrom(pingsock, packet, sizeof(packet), 0,
+                (struct sockaddr *) &from, &fromlen);
+        if (c < 0) {
+            if (errno != EINTR)
+                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);
+}
+#endif
+int ping_main(int argc, char **argv);
+int ping_main(int argc, char **argv)
+{
+    len_and_sockaddr *lsa;
+#if ENABLE_PING6
+    sa_family_t af = AF_UNSPEC;
+    while ((++argv)[0] && argv[0][0] == '-') {
+        if (argv[0][1] == '4') {
+            af = AF_INET;
+            continue;
+        }
+        if (argv[0][1] == '6') {
+            af = AF_INET6;
+            continue;
+        }
+        bb_show_usage();
+    }
+#else
+    argv++;
+#endif
+    hostname = *argv;
+    if (!hostname)
+        bb_show_usage();
+#if ENABLE_PING6
+    lsa = xhost_and_af2sockaddr(hostname, 0, af);
+#else
+    lsa = xhost_and_af2sockaddr(hostname, 0, AF_INET);
+#endif
+    /* Set timer _after_ DNS resolution */
+    signal(SIGALRM, noresp);
+    alarm(5); /* give the host 5000ms to respond */
+#if ENABLE_PING6
+    if (lsa->sa.sa_family == AF_INET6)
+        ping6(lsa);
+    else
+#endif
+        ping4(lsa);
+    printf("%s is alive!\n", hostname);
+    return EXIT_SUCCESS;
+}
+#else /* FEATURE_FANCY_PING */
+/* full(er) version */
+#define OPT_STRING ("qvc:s:I:4" USE_PING6("6"))
+enum {
+    OPT_QUIET = 1 << 0,
+    OPT_VERBOSE = 1 << 1,
+    OPT_c = 1 << 2,
+    OPT_s = 1 << 3,
+    OPT_I = 1 << 4,
+    OPT_IPV4 = 1 << 5,
+    OPT_IPV6 = (1 << 6) * ENABLE_PING6,
+};
+struct globals {
+    int pingsock;
+    len_and_sockaddr *source_lsa;
+    unsigned datalen;
+    int if_index;
+    unsigned long ntransmitted, nreceived, nrepeats, pingcount;
+    uint16_t myid;
+    unsigned tmin, tmax; /* in us */
+    unsigned long long tsum; /* in us, sum of all times */
+    const char *hostname;
+    const char *dotted;
+    union {
+        struct sockaddr sa;
+        struct sockaddr_in sin;
+#if ENABLE_PING6
+        struct sockaddr_in6 sin6;
+#endif
+    } pingaddr;
+    char rcvd_tbl[MAX_DUP_CHK / 8];
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define pingsock     (G.pingsock    )
+#define source_lsa   (G.source_lsa  )
+#define datalen      (G.datalen     )
+#define if_index     (G.if_index    )
+#define ntransmitted (G.ntransmitted)
+#define nreceived    (G.nreceived   )
+#define nrepeats     (G.nrepeats    )
+#define pingcount    (G.pingcount   )
+#define myid         (G.myid        )
+#define tmin         (G.tmin        )
+#define tmax         (G.tmax        )
+#define tsum         (G.tsum        )
+#define hostname     (G.hostname    )
+#define dotted       (G.dotted      )
+#define pingaddr     (G.pingaddr    )
+#define rcvd_tbl     (G.rcvd_tbl    )
+void BUG_ping_globals_too_big(void);
+#define INIT_G() do { \
+        if (sizeof(G) > COMMON_BUFSIZE) \
+                BUG_ping_globals_too_big(); \
+    pingsock = -1; \
+    tmin = UINT_MAX; \
+} while (0)
 #define A(bit)      rcvd_tbl[(bit)>>3]  /* identify byte in array */
 …
 #define TST(bit)    (A(bit) & B(bit))
-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);
+}
-/* simple version */
-#ifndef CONFIG_FEATURE_FANCY_PING
-static char *hostname = NULL;
-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 */
-static struct sockaddr_in pingaddr;
-static int pingsock = -1;
-static int datalen; /* intentionally uninitialized to work around gcc bug */
-static long ntransmitted, nreceived, nrepeats, pingcount;
-static int myid, options;
-static unsigned long tmin = ULONG_MAX, tmax, tsum;
-static char rcvd_tbl[MAX_DUP_CHK / 8];
-#ifndef CONFIG_FEATURE_FANCY_PING6
-static
-#endif
-    struct hostent *hostent;
-static void sendping(int);
-static void pingstats(int);
-static void unpack(char *, int, struct sockaddr_in *);
 /**************************************************************************/
+static void pingstats(int junk)
+{
+    int status;
+static void pingstats(int junk ATTRIBUTE_UNUSED)
+{
     signal(SIGINT, SIG_IGN);
     printf("\n--- %s ping statistics ---\n", hostent->h_name);
     printf("%ld packets transmitted, ", ntransmitted);
     printf("%ld packets received, ", nreceived);
+    printf("\n--- %s ping statistics ---\n", hostname);
+    printf("%lu packets transmitted, ", ntransmitted);
+    printf("%lu packets received, ", nreceived);
     if (nrepeats)
         printf("%ld duplicates, ", nrepeats);
+        printf("%lu duplicates, ", nrepeats);
     if (ntransmitted)
+        printf("%ld%% 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;
+        ntransmitted = (ntransmitted - nreceived) * 100 / ntransmitted;
+    printf("%lu%% packet loss\n", ntransmitted);
+    if (tmin != UINT_MAX) {
+        unsigned tavg = tsum / (nreceived + nrepeats);
+        printf("round-trip min/avg/max = %u.%03u/%u.%03u/%u.%03u ms\n",
+            tmin / 1000, tmin % 1000,
+            tavg / 1000, tavg % 1000,
+            tmax / 1000, tmax % 1000);
+    }
+    exit(nreceived == 0); /* (nreceived == 0) is true (1) -- 'failure' */
+}
+static void sendping_tail(void (*sp)(int), const void *pkt, int size_pkt)
+{
+    int sz;
+    CLR((uint16_t)ntransmitted % MAX_DUP_CHK);
+    ntransmitted++;
+    /* sizeof(pingaddr) can be larger than real sa size, but I think
+     * it doesn't matter */
+    sz = xsendto(pingsock, pkt, size_pkt, &pingaddr.sa, sizeof(pingaddr));
+    if (sz != size_pkt)
+        bb_error_msg_and_die(bb_msg_write_error);
+    signal(SIGALRM, sp);
+    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 void sendping4(int junk ATTRIBUTE_UNUSED)
+{
+    /* +4 reserves a place for timestamp, which may end up sitting
+     * *after* packet. Saves one if() */
+    struct icmp *pkt = alloca(datalen + ICMP_MINLEN + 4);
     pkt->icmp_type = ICMP_ECHO;
     pkt->icmp_code = 0;
     pkt->icmp_cksum = 0;
     pkt->icmp_seq = htons(ntransmitted++);
+    pkt->icmp_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
     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)
+    /* We don't do hton, because we will read it back on the same machine */
+    /*if (datalen >= 4)*/
+        *(uint32_t*)&pkt->icmp_dun = monotonic_us();
+    pkt->icmp_cksum = in_cksum((unsigned short *) pkt, datalen + ICMP_MINLEN);
+    sendping_tail(sendping4, pkt, datalen + ICMP_MINLEN);
+}
+#if ENABLE_PING6
+static void sendping6(int junk ATTRIBUTE_UNUSED)
+{
+    struct icmp6_hdr *pkt = alloca(datalen + sizeof(struct icmp6_hdr) + 4);
+    pkt->icmp6_type = ICMP6_ECHO_REQUEST;
+    pkt->icmp6_code = 0;
+    pkt->icmp6_cksum = 0;
+    pkt->icmp6_seq = htons(ntransmitted); /* don't ++ here, it can be a macro */
+    pkt->icmp6_id = myid;
+    /*if (datalen >= 4)*/
+        *(uint32_t*)(&pkt->icmp6_data8[4]) = monotonic_us();
+    sendping_tail(sendping6, pkt, datalen + sizeof(struct icmp6_hdr));
+}
+#endif
+static const 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);
+    /* check IP header */
+    iphdr = (struct iphdr *) buf;
+    hlen = iphdr->ihl << 2;
+    /* discard if too short */
+    if (sz < (datalen + ICMP_MINLEN))
+        return;
+    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);
+    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";
+    }
+}
+#if ENABLE_PING6
+/* 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 const 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";
+    }
+}
+#endif
+static void unpack_tail(int sz, uint32_t *tp,
+        const char *from_str,
+        uint16_t recv_seq, int ttl)
+{
+    const char *dupmsg = " (DUP!)";
+    unsigned triptime = triptime; /* for gcc */
+    ++nreceived;
+    if (tp) {
+        /* (int32_t) cast is for hypothetical 64-bit unsigned */
+        /* (doesn't hurt 32-bit real-world anyway) */
+        triptime = (int32_t) ((uint32_t)monotonic_us() - *tp);
         tsum += triptime;
         if (triptime < tmin)
 …
         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 (options & O_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!)");
+        printf("\n");
+    } else
+        if (icmppkt->icmp_type != ICMP_ECHO)
+            bb_error_msg("Warning: Got ICMP %d (%s)",
+                    icmppkt->icmp_type, icmp_type_name (icmppkt->icmp_type));
+    }
+    if (TST(recv_seq % MAX_DUP_CHK)) {
+        ++nrepeats;
+        --nreceived;
+    } else {
+        SET(recv_seq % MAX_DUP_CHK);
+        dupmsg += 7;
+    }
+    if (option_mask32 & OPT_QUIET)
+        return;
+    printf("%d bytes from %s: seq=%u ttl=%d", sz,
+        from_str, recv_seq, ttl);
+    if (tp)
+        printf(" time=%u.%03u ms", triptime / 1000, triptime % 1000);
+    puts(dupmsg);
     fflush(stdout);
+}
+static void ping(const char *host)
+static void unpack4(char *buf, int sz, struct sockaddr_in *from)
+{
+    struct icmp *icmppkt;
+    struct iphdr *iphdr;
+    int hlen;
+    /* 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) {
+        uint16_t recv_seq = ntohs(icmppkt->icmp_seq);
+        uint32_t *tp = NULL;
+        if (sz >= ICMP_MINLEN + sizeof(uint32_t))
+            tp = (uint32_t *) icmppkt->icmp_data;
+        unpack_tail(sz, tp,
+            inet_ntoa(*(struct in_addr *) &from->sin_addr.s_addr),
+            recv_seq, iphdr->ttl);
+    } else if (icmppkt->icmp_type != ICMP_ECHO) {
+        bb_error_msg("warning: got ICMP %d (%s)",
+                icmppkt->icmp_type,
+                icmp_type_name(icmppkt->icmp_type));
+    }
+}
+#if ENABLE_PING6
+static void unpack6(char *packet, int sz, struct sockaddr_in6 *from, int hoplimit)
+{
+    struct icmp6_hdr *icmppkt;
+    char buf[INET6_ADDRSTRLEN];
+    /* 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) {
+        uint16_t recv_seq = ntohs(icmppkt->icmp6_seq);
+        uint32_t *tp = NULL;
+        if (sz >= sizeof(struct icmp6_hdr) + sizeof(uint32_t))
+            tp = (uint32_t *) &icmppkt->icmp6_data8[4];
+        unpack_tail(sz, tp,
+            inet_ntop(AF_INET6, &pingaddr.sin6.sin6_addr,
+                    buf, sizeof(buf)),
+            recv_seq, hoplimit);
+    } 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));
+    }
+}
+#endif
+static void ping4(len_and_sockaddr *lsa)
+{
     char packet[datalen + MAXIPLEN + MAXICMPLEN];
 …
     pingsock = create_icmp_socket();
+    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));
+    pingaddr.sin = lsa->sin;
+    if (source_lsa) {
+        if (setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_IF,
+                &source_lsa->sa, source_lsa->len))
+            bb_error_msg_and_die("can't set multicast source interface");
+        xbind(pingsock, &source_lsa->sa, source_lsa->len);
+    }
     /* enable broadcast pings */
+    sockopt = 1;
+    setsockopt(pingsock, SOL_SOCKET, SO_BROADCAST, (char *) &sockopt,
+               sizeof(sockopt));
+    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): %d data bytes\n",
+               hostent->h_name,
+           inet_ntoa(*(struct in_addr *) &pingaddr.sin_addr.s_addr),
+           datalen);
+    sockopt = 48 * 1024; /* explain why 48k? */
+    setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
     signal(SIGINT, pingstats);
     /* start the ping's going ... */
     sendping(0);
+    sendping4(0);
     /* listen for replies */
 …
         int c;
         if ((c = recvfrom(pingsock, packet, sizeof(packet), 0,
                           (struct sockaddr *) &from, &fromlen)) < 0) {
             if (errno == EINTR)
                 continue;
             bb_perror_msg("recvfrom");
+        c = recvfrom(pingsock, packet, sizeof(packet), 0,
+                (struct sockaddr *) &from, &fromlen);
+        if (c < 0) {
+            if (errno != EINTR)
+                bb_perror_msg("recvfrom");
             continue;
+        }
         unpack(packet, c, &from);
+        unpack4(packet, c, &from);
         if (pingcount > 0 && nreceived >= pingcount)
             break;
+    }
+}
+#if ENABLE_PING6
+extern int BUG_bad_offsetof_icmp6_cksum(void);
+static void ping6(len_and_sockaddr *lsa)
+{
+    char packet[datalen + MAXIPLEN + MAXICMPLEN];
+    int sockopt;
+    struct msghdr msg;
+    struct sockaddr_in6 from;
+    struct iovec iov;
+    char control_buf[CMSG_SPACE(36)];
+    pingsock = create_icmp6_socket();
+    pingaddr.sin6 = lsa->sin6;
+    /* untested whether "-I addr" really works for IPv6: */
+    if (source_lsa)
+        xbind(pingsock, &source_lsa->sa, source_lsa->len);
+#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; /* explain why 48k? */
+    setsockopt(pingsock, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof(sockopt));
+    sockopt = offsetof(struct icmp6_hdr, icmp6_cksum);
+    if (offsetof(struct icmp6_hdr, icmp6_cksum) != 2)
+        BUG_bad_offsetof_icmp6_cksum();
+    setsockopt(pingsock, SOL_RAW, IPV6_CHECKSUM, &sockopt, sizeof(sockopt));
+    /* request ttl info to be returned in ancillary data */
+    setsockopt(pingsock, SOL_IPV6, IPV6_HOPLIMIT, &const_int_1, sizeof(const_int_1));
+    if (if_index)
+        pingaddr.sin6.sin6_scope_id = if_index;
+    signal(SIGINT, pingstats);
+    /* start the ping's going ... */
+    sendping6(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 *mp;
+        int hoplimit = -1;
+        msg.msg_controllen = sizeof(control_buf);
+        c = recvmsg(pingsock, &msg, 0);
+        if (c < 0) {
+            if (errno != EINTR)
+                bb_perror_msg("recvfrom");
+            continue;
+        }
+        for (mp = CMSG_FIRSTHDR(&msg); mp; mp = CMSG_NXTHDR(&msg, mp)) {
+            if (mp->cmsg_level == SOL_IPV6
+             && mp->cmsg_type == IPV6_HOPLIMIT
+             /* don't check len - we trust the kernel: */
+             /* && mp->cmsg_len >= CMSG_LEN(sizeof(int)) */
+            ) {
+                hoplimit = *(int*)CMSG_DATA(mp);
+            }
+        }
+        unpack6(packet, c, &from, hoplimit);
+        if (pingcount > 0 && nreceived >= pingcount)
+            break;
+    }
+}
+#endif
+static void ping(len_and_sockaddr *lsa)
+{
+    printf("PING %s (%s)", hostname, dotted);
+    if (source_lsa) {
+        printf(" from %s",
+            xmalloc_sockaddr2dotted_noport(&source_lsa->sa));
+    }
+    printf(": %d data bytes\n", datalen);
+#if ENABLE_PING6
+    if (lsa->sa.sa_family == AF_INET6)
+        ping6(lsa);
+    else
+#endif
+        ping4(lsa);
+}
+int ping_main(int argc, char **argv);
+int ping_main(int argc, char **argv)
+{
+    len_and_sockaddr *lsa;
+    char *opt_c, *opt_s, *opt_I;
+    USE_PING6(sa_family_t af = AF_UNSPEC;)
+    INIT_G();
+    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(argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
+    if (option_mask32 & OPT_c) pingcount = xatoul(opt_c); // -c
+    if (option_mask32 & OPT_s) datalen = xatou16(opt_s); // -s
+    if (option_mask32 & OPT_I) { // -I
+        if_index = if_nametoindex(opt_I);
+        if (!if_index) {
+            /* TODO: I'm not sure it takes IPv6 unless in [XX:XX..] format */
+            source_lsa = xdotted2sockaddr(opt_I, 0);
+        }
+    }
+    myid = (uint16_t) getpid();
+    hostname = argv[optind];
+#if ENABLE_PING6
+    if (option_mask32 & OPT_IPV4)
+        af = AF_INET;
+    if (option_mask32 & OPT_IPV6)
+        af = AF_INET6;
+    lsa = xhost_and_af2sockaddr(hostname, 0, af);
+#else
+    lsa = xhost_and_af2sockaddr(hostname, 0, AF_INET);
+#endif
+    if (source_lsa && source_lsa->sa.sa_family != lsa->sa.sa_family)
+        /* leaking it here... */
+        source_lsa = NULL;
+    dotted = xmalloc_sockaddr2dotted_noport(&lsa->sa);
+    ping(lsa);
     pingstats(0);
+}
-int ping_main(int argc, char **argv)
+{
-    char *thisarg;
-    datalen = DEFDATALEN; /* initialized here rather than in global scope to work around gcc bug */
-    argc--;
-    argv++;
-    options = 0;
-    /* Parse any options */
-    while (argc >= 1 && **argv == '-') {
-        thisarg = *argv;
-        thisarg++;
-        switch (*thisarg) {
-        case 'q':
-            options |= O_QUIET;
-            break;
-        case 'c':
-            if (--argc <= 0)
-                    bb_show_usage();
-            argv++;
-            pingcount = atoi(*argv);
-            break;
-        case 's':
-            if (--argc <= 0)
-                    bb_show_usage();
-            argv++;
-            datalen = atoi(*argv);
-            break;
-        default:
-            bb_show_usage();
+        }
-        argc--;
-        argv++;
+    }
-    if (argc < 1)
-        bb_show_usage();
-    myid = getpid() & 0xFFFF;
-    ping(*argv);
     return EXIT_SUCCESS;
+}
+#endif /* ! CONFIG_FEATURE_FANCY_PING */
+#endif /* FEATURE_FANCY_PING */
+#if ENABLE_PING6
+int ping6_main(int argc, char **argv);
+int ping6_main(int argc, char **argv)
+{
+    argv[0] = (char*)"-6";
+    return ping_main(argc + 1, argv - 1);
+}
+#endif
+/* from ping6.c:
+ * 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.
+ */

branches/stable/mindi-busybox/networking/route.c

-              r821
+              r1770
  * 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>
 …
  */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <assert.h>
-#include <unistd.h>
-#include <fcntl.h>
 #include <getopt.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
 #include <net/route.h>
 #include <net/if.h>
+#include "busybox.h"
+#include "libbb.h"
 #include "inet_common.h"
 #ifndef RTF_UP
 …
 #endif
 #if defined (SIOCADDRTOLD) || defined (RTF_IRTT)    /* route */
+#if defined(SIOCADDRTOLD) || defined(RTF_IRTT)  /* route */
 #define HAVE_NEW_ADDRT 1
 #endif
 …
 /* The RTACTION entries must agree with tbl_verb[] below! */
 #define RTACTION_ADD        1
 #define RTACTION_DEL        2
+#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
+#define NET_FLAG  1
+#define HOST_FLAG 2
 /* We remap '-' to '#' to avoid problems with getopt. */
 static const char tbl_hash_net_host[] =
+static const char tbl_hash_net_host[] ALIGN1 =
     "\007\001#net\0"
 /*  "\010\002#host\0" */
 …
+;
 #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[] =
+#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[] ALIGN1 =
     /* 020 is the "takes an arg" bit */
 #if HAVE_NEW_ADDRT
 …
     int skfd, isnet, xflag;
-    assert((action == RTACTION_ADD) || (action == RTACTION_DEL));
     /* Grab the -net or -host options.  Remember they were transformed. */
     xflag = kw_lookup(tbl_hash_net_host, &args);
 …
     /* Clean out the RTREQ structure. */
     memset((char *) &rt, 0, sizeof(struct rtentry));
+    memset(&rt, 0, sizeof(rt));
+    {
 …
         /* recognize x.x.x.x/mask format. */
         prefix = strchr(target, '/');
         if(prefix) {
+        if (prefix) {
             int prefix_len;
             prefix_len = bb_xgetularg10_bnd(prefix+1, 0, 32);
+            prefix_len = xatoul_range(prefix+1, 0, 32);
             mask_in_addr(rt) = htonl( ~ (0xffffffffUL >> prefix_len));
             *prefix = '\0';
 …
         } else {
             /* Default netmask. */
             netmask = bb_INET_default;
+            netmask = bb_str_default;
+        }
         /* Prefer hostname lookup is -host flag (xflag==1) was given. */
 …
             bb_error_msg_and_die("resolving %s", target);
+        }
         if(prefix) {
+        if (prefix) {
             /* do not destroy prefix for process args */
             *prefix = '/';
 …
 #if HAVE_NEW_ADDRT
         if (k == KW_IPVx_METRIC) {
             rt.rt_metric = bb_xgetularg10(args_m1) + 1;
+            rt.rt_metric = xatoul(args_m1) + 1;
             continue;
+        }
 …
         if (k == KW_IPVx_MSS) { /* Check valid MSS bounds. */
             rt.rt_flags |= RTF_MSS;
             rt.rt_mss = bb_xgetularg10_bnd(args_m1, 64, 32768);
+            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 = bb_xgetularg10_bnd(args_m1, 128, INT_MAX);
+            rt.rt_window = xatoul_range(args_m1, 128, INT_MAX);
             continue;
+        }
 …
         if (k == KW_IPVx_IRTT) {
             rt.rt_flags |= RTF_IRTT;
             rt.rt_irtt = bb_xgetularg10(args_m1);
+            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? */
 …
 #ifdef RTF_REJECT
     if ((rt.rt_flags & RTF_REJECT) && !rt.rt_dev) {
         rt.rt_dev = "lo";
+        rt.rt_dev = (char*)"lo";
+    }
 #endif
 …
     /* Create a socket to the INET kernel. */
+    skfd = bb_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");
+    }
+    skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    if (action == RTACTION_ADD)
+        xioctl(skfd, SIOCADDRT, &rt);
+    else
+        xioctl(skfd, SIOCDELRT, &rt);
     if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
+}
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
 static void INET6_setroute(int action, char **args)
 …
     const char *devname;
-    assert((action == RTACTION_ADD) || (action == RTACTION_DEL));
+    {
         /* We know args isn't NULL from the check in route_main. */
         const char *target = *args++;
         if (strcmp(target, bb_INET_default) == 0) {
+        if (strcmp(target, bb_str_default) == 0) {
             prefix_len = 0;
             memset(&sa6, 0, sizeof(sa6));
 …
             if ((cp = strchr(target, '/'))) { /* Yes... const to non is ok. */
                 *cp = 0;
                 prefix_len = bb_xgetularg10_bnd(cp+1, 0, 128);
+                prefix_len = xatoul_range(cp+1, 0, 128);
             } else {
                 prefix_len = 128;
 …
+            }
+        }
+    }
     /* Clean out the RTREQ structure. */
     memset((char *) &rt, 0, sizeof(struct in6_rtmsg));
+    memset(&rt, 0, sizeof(rt));
     memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
 …
         if (k == KW_IPVx_METRIC) {
             rt.rtmsg_metric = bb_xgetularg10(args_m1);
+            rt.rtmsg_metric = xatoul(args_m1);
             continue;
+        }
 …
     /* Create a socket to the INET6 kernel. */
     skfd = bb_xsocket(AF_INET6, SOCK_DGRAM, 0);
+    skfd = xsocket(AF_INET6, SOCK_DGRAM, 0);
     rt.rtmsg_ifindex = 0;
 …
         struct ifreq ifr;
         memset(&ifr, 0, sizeof(ifr));
+        strcpy(ifr.ifr_name, devname);
+        if (ioctl(skfd, SIOGIFINDEX, &ifr) < 0) {
+            bb_perror_msg_and_die("SIOGIFINDEX");
+        }
+        strncpy(ifr.ifr_name, devname, sizeof(ifr.ifr_name));
+        xioctl(skfd, SIOGIFINDEX, &ifr);
         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 (action == RTACTION_ADD)
+        xioctl(skfd, SIOCADDRT, &rt);
+    else
+        xioctl(skfd, SIOCDELRT, &rt);
     if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 …
 #endif
 static const unsigned int flagvals[] = { /* Must agree with flagchars[]. */
+static const unsigned flagvals[] = { /* Must agree with flagchars[]. */
     RTF_GATEWAY,
     RTF_HOST,
 …
     RTF_DYNAMIC,
     RTF_MODIFIED,
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     RTF_DEFAULT,
     RTF_ADDRCONF,
 …
 #define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
+static const char flagchars[] =     /* Must agree with flagvals[]. */
+/* Must agree with flagvals[]. */
+static const char flagchars[] ALIGN1 =
     "GHRDM"
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     "DAC"
 #endif
+;
+static
+#ifndef CONFIG_FEATURE_IPV6
+__inline
+#endif
+void set_flags(char *flagstr, int flags)
+static void set_flags(char *flagstr, int flags)
+{
     int i;
 …
     *flagstr++ = 'U';
     for (i=0 ; (*flagstr = flagchars[i]) != 0 ; i++) {
+    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)
+void bb_displayroutes(int noresolve, int netstatfmt)
+{
     char devname[64], flags[16], sdest[16], sgw[16];
     unsigned long int d, g, m;
+    char devname[64], flags[16], *sdest, *sgw;
+    unsigned long d, g, m;
     int flgs, ref, use, metric, mtu, win, ir;
     struct sockaddr_in s_addr;
     struct in_addr mask;
+    FILE *fp = bb_xfopen("/proc/net/route", "r");
+    bb_printf("Kernel IP routing table\n"
+              "Destination     Gateway         Genmask"
+              "         Flags %s Iface\n",
+              netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
+    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. */
 …
                 break;
+            }
         ERROR:
+ ERROR:
             bb_error_msg_and_die("fscanf");
+        }
 …
         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 *. */
+        sdest = INET_rresolve(&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. */
+        sgw = INET_rresolve(&s_addr, (noresolve | 0x4000), m); /* Host instead of net */
         mask.s_addr = m;
+        bb_printf("%-16s%-16s%-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
+        /* "%15.15s" truncates hostnames, do we really want that? */
+        printf("%-15.15s %-15.15s %-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
+        free(sdest);
+        free(sgw);
         if (netstatfmt) {
             bb_printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
+            printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
         } else {
             bb_printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
+            printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
+        }
+    }
+}
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
 static void INET6_displayroutes(int noresolve)
+{
     char addr6[128], naddr6[128];
+    char addr6[128], *naddr6;
     /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
      * We read the non-delimited strings into the tail of the buffer
 …
     struct sockaddr_in6 snaddr6;
     FILE *fp = bb_xfopen("/proc/net/ipv6_route", "r");
     bb_printf("Kernel IPv6 routing table\n%-44s%-40s"
+    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");
 …
                 break;
+            }
         ERROR:
+ ERROR:
             bb_error_msg_and_die("fscanf");
+        }
 …
             do {
                 if (!*p) {
                     if (i==40) { /* nul terminator for 1st address? */
+                    if (i == 40) { /* nul terminator for 1st address? */
                         addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
                         ++p;    /* Skip and continue. */
 …
+                }
                 addr6x[i++] = *p++;
                 if (!((i+1)%5)) {
+                if (!((i+1) % 5)) {
                     addr6x[i++] = ':';
+                }
 …
                       (struct sockaddr *) &snaddr6.sin6_addr);
             snaddr6.sin6_family = AF_INET6;
+            INET6_rresolve(naddr6, sizeof(naddr6),
+                           (struct sockaddr_in6 *) &snaddr6,
+#if 0
+                           (noresolve | 0x8000) /* Default instead of *. */
+#else
+            naddr6 = INET6_rresolve((struct sockaddr_in6 *) &snaddr6,
 x0fff /* Apparently, upstream never resolves. */
-#endif
                            );
 …
                 snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
                 r += 40;
+                free(naddr6);
             } else {            /* 2nd pass */
                 /* Print the info. */
+                bb_printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
+                          addr6, naddr6, flags, metric, refcnt, use, iface);
+                printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
+                        addr6, naddr6, flags, metric, refcnt, use, iface);
+                free(naddr6);
                 break;
+            }
 …
 #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. */
+#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 */
+/* 2nd byte matches RTACTION_* code */
+static const char tbl_verb[] ALIGN1 =
     "\006\001add\0"
     "\006\002del\0"
 /*  "\011\002delete\0" */
     "\010\002delete"            /* Since last, we can save a byte. */
+    "\010\002delete"  /* Since it's last, we can save a byte. */
+;
+int route_main(int argc, char **argv);
 int route_main(int argc, char **argv)
+{
     unsigned long opt;
+    unsigned opt;
     int what;
     char *family;
+    char **p;
     /* First, remap '-net' and '-host' to avoid getopt problems. */
+    {
+        char **p = argv;
+        while (*++p) {
+            if ((strcmp(*p, "-net") == 0) || (strcmp(*p, "-host") == 0)) {
+                p[0][0] = '#';
+            }
+        }
+    }
+    opt = bb_getopt_ulflags(argc, argv, "A:ne", &family);
+    if ((opt & ROUTE_OPT_A) && strcmp(family, "inet")) {
+#ifdef CONFIG_FEATURE_IPV6
+    p = argv;
+    while (*++p) {
+        if (strcmp(*p, "-net") == 0 || strcmp(*p, "-host") == 0) {
+            p[0][0] = '#';
+        }
+    }
+    opt = getopt32(argv, "A:ne", &family);
+    if ((opt & ROUTE_OPT_A) && strcmp(family, "inet") != 0) {
+#if ENABLE_FEATURE_IPV6
         if (strcmp(family, "inet6") == 0) {
             opt |= ROUTE_OPT_INET6; /* Set flag for ipv6. */
 …
     if (!*argv) {
         int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
         if (opt & ROUTE_OPT_INET6)
             INET6_displayroutes(noresolve);
         else
 #endif
+            displayroutes(noresolve, opt & ROUTE_OPT_e);
+        bb_xferror_stdout();
+        bb_fflush_stdout_and_exit(EXIT_SUCCESS);
+            bb_displayroutes(noresolve, opt & ROUTE_OPT_e);
+        fflush_stdout_and_exit(EXIT_SUCCESS);
+    }
 …
+    }
 #ifdef CONFIG_FEATURE_IPV6
+#if ENABLE_FEATURE_IPV6
     if (opt & ROUTE_OPT_INET6)
         INET6_setroute(what, argv);

branches/stable/mindi-busybox/networking/telnet.c

-              r821
+              r1770
 #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"
+#if 0
+enum { DOTRACE = 1 };
+#endif
+#include "libbb.h"
 #ifdef DOTRACE
-#include <arpa/inet.h> /* for inet_ntoa()... */
 #define TRACE(x, y) do { if (x) printf y; } while (0)
 #else
 …
 #endif
-#define DATABUFSIZE  128
-#define IACBUFSIZE   128
 enum {
+    DATABUFSIZE = 128,
+    IACBUFSIZE  = 128,
     CHM_TRY = 0,
     CHM_ON = 1,
 …
 };
-#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 */
+struct globals {
+    int netfd; /* console fd:s are 0 and 1 (and 2) */
+    short   iaclen; /* could even use byte */
     byte    telstate; /* telnet negotiation state from network input */
     byte    telwish;  /* DO, DONT, WILL, WONT */
 …
     byte    gotsig;
     byte    do_termios;
+#if ENABLE_FEATURE_TELNET_TTYPE
+    char    *ttype;
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+    const char *autologin;
+#endif
+#if ENABLE_FEATURE_AUTOWIDTH
+    int win_width, win_height;
+#endif
+    /* same buffer used both for network and console read/write */
+    char    buf[DATABUFSIZE];
     /* 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 inline void iacflush(void)
+{
+    write(G.netfd, G.iacbuf, G.iaclen);
+    G.iaclen = 0;
+}
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+void BUG_telnet_globals_too_big(void);
+#define INIT_G() do { \
+    if (sizeof(G) > COMMON_BUFSIZE) \
+        BUG_telnet_globals_too_big(); \
+    /* memset(&G, 0, sizeof G); - already is */ \
+} while (0)
 /* Function prototypes */
 …
 static int subneg(byte c);
+/* Some globals */
+static 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 iacflush(void)
+{
+    write(G.netfd, G.iacbuf, G.iaclen);
+    G.iaclen = 0;
+}
+#define write_str(fd, str) write(fd, str, sizeof(str) - 1)
 static void doexit(int ev)
 …
         rawmode();
     WriteCS(1, "\r\nConsole escape. Commands are:\r\n\n"
+    write_str(1, "\r\nConsole escape. Commands are:\r\n\n"
             " l go to line mode\r\n"
             " c go to character mode\r\n"
 …
         doexit(1);
+    switch (b)
+    {
+    switch (b) {
     case 'l':
+        if (!G.gotsig)
+        {
+        if (!G.gotsig) {
             do_linemode();
             goto rrturn;
 …
         break;
     case 'c':
+        if (G.gotsig)
+        {
+        if (G.gotsig) {
             will_charmode();
             goto rrturn;
 …
+    }
     WriteCS(1, "continuing...\r\n");
+    write_str(1, "continuing...\r\n");
     if (G.gotsig)
 …
+}
 static void handlenetoutput(int len)
+{
 …
      *  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.
+     *       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.
+     *      I don't understand.
      *  So I implemented it. It's realy useful for me. I hope that
      *  others people will find it interesting to.
 …
         outbuf[j++] = *p;
         if (*p == 0xff)
             outbuf[j++] = 0xff;
+            outbuf[j++] = 0xff;
         else if (*p == 0x0d)
+            outbuf[j++] = 0x00;
+    }
+    if (j > 0 )
+        write(G.netfd, outbuf, j);
+}
+            outbuf[j++] = 0x00;
+    }
+    if (j > 0)
+        write(G.netfd, outbuf, j);
+}
 static void handlenetinput(int len)
 …
+}
+/* ******************************* */
+static inline void putiac(int c)
+static void putiac(int c)
+{
     G.iacbuf[G.iaclen++] = c;
+}
 static void putiac2(byte wwdd, byte c)
 …
+}
+#if 0
+static void putiac1(byte c)
+{
+    if (G.iaclen + 2 > IACBUFSIZE)
+        iacflush();
+    putiac(IAC);
+    putiac(c);
+}
+#endif
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+#if ENABLE_FEATURE_TELNET_TTYPE
 static void putiac_subopt(byte c, char *str)
+{
 …
     putiac(0);
     while(*str)
+    while (*str)
         putiac(*str++);
 …
 #endif
 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
 static void putiac_subopt_autologin(void)
+{
     int len = strlen(autologin) + 6;    // (2 + 1 + 1 + strlen + 2)
     char *user = "USER";
+    int len = strlen(G.autologin) + 6;  // (2 + 1 + 1 + strlen + 2)
+    const char *user = "USER";
     if (G.iaclen + len > IACBUFSIZE)
 …
     putiac(NEW_ENV_VAR);
     while(*user)
+    while (*user)
         putiac(*user++);
     putiac(NEW_ENV_VALUE);
     while(*autologin)
         putiac(*autologin++);
+    while (*G.autologin)
+        putiac(*G.autologin++);
     putiac(IAC);
 …
 #endif
 #ifdef CONFIG_FEATURE_AUTOWIDTH
+#if ENABLE_FEATURE_AUTOWIDTH
 static void putiac_naws(byte c, int x, int y)
+{
 …
 #endif
+/* void putiacstring (subneg strings) */
+/* ******************************* */
+static char const escapecharis[] = "\r\nEscape character is ";
+static char const escapecharis[] ALIGN1 = "\r\nEscape character is ";
 static void setConMode(void)
+{
+    if (G.telflags & UF_ECHO)
+    {
+    if (G.telflags & UF_ECHO) {
         if (G.charmode == CHM_TRY) {
             G.charmode = CHM_ON;
 …
             rawmode();
+        }
+    }
+    else
+    {
+    } else {
         if (G.charmode != CHM_OFF) {
             G.charmode = CHM_OFF;
 …
+}
-/* ******************************* */
 static void will_charmode(void)
+{
 …
+}
+/* ******************************* */
 static inline void to_notsup(char c)
+{
     if      (G.telwish == WILL) putiac2(DONT, c);
     else if (G.telwish == DO)   putiac2(WONT, c);
+}
 static inline void to_echo(void)
+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 == DO) {
+        putiac2(WONT, TELOPT_ECHO);
+        return;
+    }
+    if (G.telwish == DONT)
+        return;
+    if (G.telflags & UF_ECHO) {
         if (G.telwish == WILL)
             return;
+    }
+    else
+        if (G.telwish == WONT)
+            return;
+    } else if (G.telwish == WONT)
+        return;
     if (G.charmode != CHM_OFF)
 …
     setConMode();
     WriteCS(1, "\r\n");  /* sudden modec */
+}
 static inline void to_sga(void)
+    write_str(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.telflags & UF_SGA) {
         if (G.telwish == WILL)
             return;
+    }
+    else
+        if (G.telwish == WONT)
+            return;
+    } else if (G.telwish == WONT)
+        return;
     if ((G.telflags ^= UF_SGA) & UF_SGA) /* toggle */
 …
     else
         putiac2(DONT, TELOPT_SGA);
+    return;
+}
+#ifdef CONFIG_FEATURE_TELNET_TTYPE
+static inline void to_ttype(void)
+}
+#if ENABLE_FEATURE_TELNET_TTYPE
+static void to_ttype(void)
+{
     /* Tell server we will (or won't) do TTYPE */
     if(ttype)
+    if (G.ttype)
         putiac2(WILL, TELOPT_TTYPE);
     else
         putiac2(WONT, TELOPT_TTYPE);
+    return;
+}
+#endif
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+static inline void to_new_environ(void)
+}
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+static void to_new_environ(void)
+{
     /* Tell server we will (or will not) do AUTOLOGIN */
     if (autologin)
+    if (G.autologin)
         putiac2(WILL, TELOPT_NEW_ENVIRON);
     else
         putiac2(WONT, TELOPT_NEW_ENVIRON);
+    return;
+}
+#endif
+#ifdef CONFIG_FEATURE_AUTOWIDTH
+static inline void to_naws(void)
+}
+#endif
+#if ENABLE_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;
+    }
+}
+/* ******************************* */
+    switch (c) {
+    case TELOPT_ECHO:
+        to_echo(); break;
+    case TELOPT_SGA:
+        to_sga(); break;
+#if ENABLE_FEATURE_TELNET_TTYPE
+    case TELOPT_TTYPE:
+        to_ttype(); break;
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+    case TELOPT_NEW_ENVIRON:
+        to_new_environ(); break;
+#endif
+#if ENABLE_FEATURE_AUTOWIDTH
+    case TELOPT_NAWS:
+        to_naws();
+        putiac_naws(c, G.win_width, G.win_height);
+        break;
+#endif
+    default:
+        to_notsup(c);
+        break;
+    }
+}
 /* subnegotiation -- ignore all (except TTYPE,NAWS) */
 static int subneg(byte c)
+{
+    switch (G.telstate)
+    {
+    switch (G.telstate) {
     case TS_SUB1:
         if (c == IAC)
             G.telstate = TS_SUB2;
 #ifdef CONFIG_FEATURE_TELNET_TTYPE
+#if ENABLE_FEATURE_TELNET_TTYPE
         else
         if (c == TELOPT_TTYPE)
             putiac_subopt(TELOPT_TTYPE,ttype);
 #endif
 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+            putiac_subopt(TELOPT_TTYPE, G.ttype);
+#endif
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
         else
         if (c == TELOPT_NEW_ENVIRON)
 …
+}
-/* ******************************* */
 static void fgotsig(int sig)
+{
 …
 static void rawmode(void)
+{
+    if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_raw);
+    if (G.do_termios)
+        tcsetattr(0, TCSADRAIN, &G.termios_raw);
+}
 static void cookmode(void)
+{
+    if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_def);
+}
+    if (G.do_termios)
+        tcsetattr(0, TCSADRAIN, &G.termios_def);
+}
+int telnet_main(int argc, char** argv);
 int telnet_main(int argc, char** argv)
+{
+    char *host;
+    int port;
     int len;
-    struct sockaddr_in s_in;
 #ifdef USE_POLL
     struct pollfd ufds[2];
 …
 #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);
+    INIT_G();
+#if ENABLE_FEATURE_AUTOWIDTH
+    get_terminal_width_height(0, &G.win_width, &G.win_height);
+#endif
+#if ENABLE_FEATURE_TELNET_TTYPE
+    G.ttype = getenv("TERM");
+#endif
     if (tcgetattr(0, &G.termios_def) >= 0) {
         G.do_termios = 1;
         G.termios_raw = G.termios_def;
         cfmakeraw(&G.termios_raw);
 …
         bb_show_usage();
+#ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
+    if (1 & bb_getopt_ulflags(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
+#if ENABLE_FEATURE_TELNET_AUTOLOGIN
+    if (1 & getopt32(argv, "al:", &G.autologin))
+        G.autologin = getenv("USER");
+    argv += optind;
+#else
+    argv++;
+#endif
+    if (!*argv)
         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(&s_in);
     setsockopt(G.netfd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof one);
+    host = *argv++;
+    port = bb_lookup_port(*argv ? *argv++ : "telnet", "tcp", 23);
+    if (*argv) /* extra params?? */
+        bb_show_usage();
+    G.netfd = create_and_connect_stream_or_die(host, port);
+    setsockopt(G.netfd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
     signal(SIGINT, fgotsig);
 …
 #endif
+    while (1)
+    {
+    while (1) {
 #ifndef USE_POLL
         fd_set rfds = readfds;
 …
+            {
                 len = read(0, G.buf, DATABUFSIZE);
                 if (len <= 0)
                     doexit(0);
                 TRACE(0, ("Read con: %d\n", len));
                 handlenetoutput(len);
+            }
 …
+            {
                 len = read(G.netfd, G.buf, DATABUFSIZE);
+                if (len <= 0)
+                {
+                    WriteCS(1, "Connection closed by foreign host.\r\n");
+                if (len <= 0) {
+                    write_str(1, "Connection closed by foreign host\r\n");
                     doexit(1);
+                }
                 TRACE(0, ("Read netfd (%d): %d\n", G.netfd, len));
                 handlenetinput(len);
+            }

branches/stable/mindi-busybox/networking/telnetd.c

-              r821
+              r1770
  */
+/*#define DEBUG 1 */
+#undef DEBUG
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <signal.h>
+#include <termios.h>
+#ifdef DEBUG
+#define DEBUG 0
+#include "libbb.h"
+#if DEBUG
 #define TELCMDS
 #define TELOPTS
 #endif
 #include <arpa/telnet.h>
-#include <ctype.h>
 #include <sys/syslog.h>
+#include "busybox.h"
+#define BUFSIZE 4000
+#ifdef CONFIG_FEATURE_IPV6
+#define SOCKET_TYPE AF_INET6
+typedef struct sockaddr_in6 sockaddr_type;
+#else
+#define SOCKET_TYPE AF_INET
+typedef struct sockaddr_in sockaddr_type;
+#endif
+#ifdef CONFIG_LOGIN
+#if ENABLE_LOGIN
 static const char *loginpath = "/bin/login";
 #else
+static const char *loginpath;
+#endif
+static const char *loginpath = DEFAULT_SHELL;
+#endif
 static const char *issuefile = "/etc/issue.net";
-/* shell name and arguments */
-static const char *argv_init[] = {NULL, NULL};
 /* structure that describes a session */
 struct tsession {
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+    struct tsession *next;
     int sockfd_read, sockfd_write, ptyfd;
-#else /* CONFIG_FEATURE_TELNETD_INETD */
-    struct tsession *next;
-    int sockfd, ptyfd;
-#endif /* CONFIG_FEATURE_TELNETD_INETD */
     int shell_pid;
     /* two circular buffers */
 …
 };
+/* Two buffers are directly after tsession in malloced memory.
+ * Make whole thing fit in 4k */
+enum { BUFSIZE = (4*1024 - sizeof(struct tsession)) / 2 };
 /*
    This is how the buffers are used. The arrows indicate the movement
    of data.
 …
    Each session has got two buffers.
 */
 …
 /*
    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
 …
    CR-LF ->'s CR mapping is also done here, for convenience
+  */
+ */
 static char *
+remove_iacs(struct tsession *ts, int *pnum_totty) {
+remove_iacs(struct tsession *ts, int *pnum_totty)
+{
     unsigned char *ptr0 = (unsigned char *)ts->buf1 + ts->wridx1;
     unsigned char *ptr = ptr0;
 …
             if (c == '\r' && (*ptr == '\n' || *ptr == 0) && ptr < end)
                 ptr++;
+        }
+        else {
+        } else {
             /*
              * TELOPT_NAWS support!
 …
                 ws.ws_col = (ptr[3] << 8) | ptr[4];
                 ws.ws_row = (ptr[5] << 8) | ptr[6];
                 (void) ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
+                ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
                 ptr += 9;
+            }
+            else {
+            } else {
                 /* skip 3-byte IAC non-SB cmd */
 #ifdef DEBUG
+#if DEBUG
                 fprintf(stderr, "Ignoring IAC %s,%s\n",
                     TELCMD(*(ptr+1)), TELOPT(*(ptr+2)));
+                    TELCMD(ptr[1]), TELOPT(ptr[2]));
 #endif
                 ptr += 3;
 …
 static int
 getpty(char *line)
+getpty(char *line, int size)
+{
     int p;
 #ifdef CONFIG_FEATURE_DEVPTS
     p = open("/dev/ptmx", 2);
+#if ENABLE_FEATURE_DEVPTS
+    p = open("/dev/ptmx", O_RDWR);
     if (p > 0) {
+        const char *name;
         grantpt(p);
         unlockpt(p);
+        strcpy(line, ptsname(p));
+        return(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
 …
         for (j = 0; j < 16; j++) {
             line[9] = j < 10 ? j + '0' : j - 10 + 'a';
+#ifdef DEBUG
             fprintf(stderr, "Trying to open device: %s\n", line);
+#endif
             if ((p = open(line, O_RDWR | O_NOCTTY)) >= 0) {
+            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 /* CONFIG_FEATURE_DEVPTS */
+#endif /* FEATURE_DEVPTS */
     return -1;
+}
 …
 send_iac(struct tsession *ts, unsigned char command, int option)
+{
     /* We rely on that there is space in the buffer for now.  */
+    /* We rely on that there is space in the buffer for now. */
     char *b = ts->buf2 + ts->rdidx2;
     *b++ = IAC;
 …
 static struct tsession *
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+make_new_session(void)
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+make_new_session(int sockfd)
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+{
+make_new_session(
+        USE_FEATURE_TELNETD_STANDALONE(int sock_r, int sock_w)
+        SKIP_FEATURE_TELNETD_STANDALONE(void)
+) {
+    const char *login_argv[2];
     struct termios termbuf;
     int pty, pid;
+    int fd, pid;
     char tty_name[32];
     struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
 …
     ts->buf2 = ts->buf1 + BUFSIZE;
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+    /* 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;
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+    ts->sockfd = sockfd;
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+    /* Got a new connection, set up a tty and spawn a shell.  */
+    pty = getpty(tty_name);
+    if (pty < 0) {
+        syslog(LOG_ERR, "All terminals in use!");
+        return 0;
+    }
+    if (pty > maxfd)
+        maxfd = pty;
+    ts->ptyfd = pty;
+    /* 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.
+     */
+     * stuff that requires char-by-char support. */
     send_iac(ts, DO, TELOPT_ECHO);
     send_iac(ts, DO, TELOPT_NAWS);
 …
     send_iac(ts, WILL, TELOPT_SGA);
     if ((pid = fork()) < 0) {
         syslog(LOG_ERR, "Could not fork");
+    }
     if (pid == 0) {
         /* In child, open the child's side of the tty.  */
         int i;
         for(i = 0; i <= maxfd; i++)
             close(i);
         /* make new process group */
         setsid();
+        if (open(tty_name, O_RDWR /*| O_NOCTTY*/) < 0) {
             syslog(LOG_ERR, "Could not open tty");
+            exit(1);
+        }
         dup(0);
+        dup(0);
         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);
         /* NOT REACHED */
+        syslog(LOG_ERR, "execv error");
         exit(1);
+    }
     ts->shell_pid = pid;
     return ts;
+    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 */
+    /* make new session and process group */
+    setsid();
+    /* open the child's side of the tty. */
+    /* NB: setsid() disconnects from any previous ctty's. Therefore
+     * we must open child's side of the tty AFTER setsid! */
+    fd = xopen(tty_name, O_RDWR); /* becomes our ctty */
+    dup2(fd, 0);
+    dup2(fd, 1);
+    dup2(fd, 2);
+    while (fd > 2) close(fd--);
+    tcsetpgrp(0, getpid()); /* switch this tty's process group to us */
+    /* 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 / login /whatever */
+    login_argv[0] = loginpath;
+    login_argv[1] = NULL;
+    execv(loginpath, (char **)login_argv);
+    /* Hmmm... this gets sent to the client thru fd#2! Is it ok?? */
+    bb_perror_msg_and_die("execv %s", loginpath);
+}
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+#if ENABLE_FEATURE_TELNETD_STANDALONE
 static void
 free_session(struct tsession *ts)
 …
     struct tsession *t = sessions;
     /* Unlink this telnet session from the session list.  */
+    /* unlink this telnet session from the session list */
     if (t == ts)
         sessions = ts->next;
     else {
         while(t->next != ts)
+        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);
+    if (ts->ptyfd == maxfd || ts->sockfd == maxfd)
+        maxfd--;
+    if (ts->ptyfd == maxfd || ts->sockfd == maxfd)
+        maxfd--;
+    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;
+    }
+}
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+int
+telnetd_main(int argc, char **argv)
+#else /* !FEATURE_TELNETD_STANDALONE */
+/* Never actually called */
+void free_session(struct tsession *ts);
+#endif
+int telnetd_main(int argc, char **argv);
+int telnetd_main(int argc, char **argv)
+{
-#ifndef CONFIG_FEATURE_TELNETD_INETD
-    sockaddr_type sa;
-    int master_fd;
-#endif /* CONFIG_FEATURE_TELNETD_INETD */
     fd_set rdfdset, wrfdset;
     int selret;
+#ifndef CONFIG_FEATURE_TELNETD_INETD
     int on = 1;
+    int portnbr = 23;
+    struct in_addr bind_addr = { .s_addr = 0x0 };
 #endif /* CONFIG_FEATURE_TELNETD_INETD */
     int c;
     static const char options[] =
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+        "f:l:";
+#else /* CONFIG_EATURE_TELNETD_INETD */
         "f:l:p:b:";
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
     int maxlen, w, r;
 #ifndef CONFIG_LOGIN
     loginpath = DEFAULT_SHELL;
+#endif
     for (;;) {
         c = getopt( argc, argv, options);
+        if (c == EOF) break;
         switch (c) {
             case 'f':
                 issuefile = optarg;
                 break;
             case 'l':
                 loginpath = optarg;
                 break;
+#ifndef CONFIG_FEATURE_TELNETD_INETD
             case 'p':
                 portnbr = atoi(optarg);
                 break;
             case 'b':
                 if (inet_aton(optarg, &bind_addr) == 0)
                     bb_show_usage();
                 break;
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
             default:
+                bb_show_usage();
+        }
+    }
+    if (access(loginpath, X_OK) < 0) {
         bb_error_msg_and_die ("'%s' unavailable.", loginpath);
+    }
     argv_init[0] = loginpath;
     openlog(bb_applet_name, 0, LOG_USER);
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+    maxfd = 1;
+    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(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. */
+#if ENABLE_FEATURE_TELNETD_STANDALONE
+    if (IS_INETD) {
+        sessions = make_new_session(0, 1);
+    } else {
+        master_fd = create_and_bind_stream_or_die(opt_bindaddr, portnbr);
+        xlisten(master_fd, 1);
+        if (!(opt & OPT_FOREGROUND))
+            bb_daemonize(DAEMON_CHDIR_ROOT);
+    }
+#else
     sessions = make_new_session();
+#else /* CONFIG_EATURE_TELNETD_INETD */
+    sessions = 0;
+    /* Grab a TCP socket.  */
+    master_fd = bb_xsocket(SOCKET_TYPE, SOCK_STREAM, 0);
+    (void)setsockopt(master_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+    /* Set it to listen to specified port.  */
+    memset((void *)&sa, 0, sizeof(sa));
+#ifdef CONFIG_FEATURE_IPV6
+    sa.sin6_family = AF_INET6;
+    sa.sin6_port = htons(portnbr);
+    /* sa.sin6_addr = bind_addr6; */
+#else
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(portnbr);
+    sa.sin_addr = bind_addr;
+#endif
+    bb_xbind(master_fd, (struct sockaddr *) &sa, sizeof(sa));
+    bb_xlisten(master_fd, 1);
+    bb_xdaemon(0, 0);
+    maxfd = master_fd;
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+    do {
+        struct tsession *ts;
+        FD_ZERO(&rdfdset);
+        FD_ZERO(&wrfdset);
+        /* select on the master socket, all telnet sockets and their
+         * ptys if there is room in their respective session buffers.
+         */
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+#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);
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+        ts = sessions;
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+        while (ts) {
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+            /* buf1 is used from socket to pty
+             * buf2 is used from pty to socket
+             */
+            if (ts->size1 > 0) {
+                FD_SET(ts->ptyfd, &wrfdset);  /* can write to pty */
+            }
+            if (ts->size1 < BUFSIZE) {
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                FD_SET(ts->sockfd_read, &rdfdset); /* can read from socket */
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                FD_SET(ts->sockfd, &rdfdset); /* can read from socket */
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+            }
+            if (ts->size2 > 0) {
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                FD_SET(ts->sockfd_write, &wrfdset); /* can write to socket */
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                FD_SET(ts->sockfd, &wrfdset); /* can write to socket */
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+            }
+            if (ts->size2 < BUFSIZE) {
+                FD_SET(ts->ptyfd, &rdfdset);  /* can read from pty */
+            }
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+            ts = ts->next;
+        }
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+        selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
+        if (!selret)
+            break;
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+        /* First check for and accept new sessions.  */
+        if (FD_ISSET(master_fd, &rdfdset)) {
+            int fd;
+            socklen_t salen;
+            salen = sizeof(sa);
+            if ((fd = accept(master_fd, (struct sockaddr *)&sa,
+                        &salen)) < 0) {
+        /* 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)) {
+        int fd;
+        struct tsession *new_ts;
+        fd = accept(master_fd, NULL, 0);
+        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;
+            } else {
+                /* Create a new session and link it into
+                    our active list.  */
+                struct tsession *new_ts = make_new_session(fd);
+                if (new_ts) {
+                    new_ts->next = sessions;
+                    sessions = new_ts;
+                    if (fd > maxfd)
+                        maxfd = fd;
+                } else {
+                    close(fd);
+                }
+            }
+        }
+        /* Then check for data tunneling.  */
+        ts = sessions;
+        while (ts) { /* For all sessions...  */
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+            struct tsession *next = ts->next; /* in case we free ts. */
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+            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 = write(ts->ptyfd, ptr, num_totty);
+                if (w < 0) {
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                    exit(0);
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                    free_session(ts);
+                    ts = next;
+            }
+            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;
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                }
+                ts->wridx1 += w;
+                ts->size1 -= w;
+                if (ts->wridx1 == BUFSIZE)
+                    ts->wridx1 = 0;
+            }
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+            if (ts->size2 && FD_ISSET(ts->sockfd_write, &wrfdset)) {
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+            if (ts->size2 && FD_ISSET(ts->sockfd, &wrfdset)) {
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                /* Write to socket from buffer 2.  */
+                maxlen = MIN(BUFSIZE - ts->wridx2, ts->size2);
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                w = write(ts->sockfd_write, ts->buf2 + ts->wridx2, maxlen);
+                if (w < 0)
+                    exit(0);
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                w = write(ts->sockfd, ts->buf2 + ts->wridx2, maxlen);
+                if (w < 0) {
+                    free_session(ts);
+                    ts = next;
+                    continue;
+                }
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                ts->wridx2 += w;
+                ts->size2 -= w;
+                if (ts->wridx2 == BUFSIZE)
+                    ts->wridx2 = 0;
+            }
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+            if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd_read, &rdfdset)) {
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+            if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd, &rdfdset)) {
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                /* Read from socket to buffer 1. */
+                maxlen = MIN(BUFSIZE - ts->rdidx1,
+                        BUFSIZE - ts->size1);
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                r = read(ts->sockfd_read, ts->buf1 + ts->rdidx1, maxlen);
+                if (!r || (r < 0 && errno != EINTR))
+                    exit(0);
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                r = read(ts->sockfd, ts->buf1 + ts->rdidx1, maxlen);
+                if (!r || (r < 0 && errno != EINTR)) {
+                    free_session(ts);
+                    ts = next;
+                    continue;
+                }
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                if (!*(ts->buf1 + ts->rdidx1 + r - 1)) {
+                    r--;
+                    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 = read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
+                if (!r || (r < 0 && errno != EINTR)) {
+#ifdef CONFIG_FEATURE_TELNETD_INETD
+                    exit(0);
+#else /* CONFIG_FEATURE_TELNETD_INETD */
+                    free_session(ts);
+                    ts = next;
+                    continue;
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+                }
+                ts->rdidx2 += r;
+                ts->size2 += r;
+                if (ts->rdidx2 == BUFSIZE)
+                    ts->rdidx2 = 0;
+            }
+            if (ts->size1 == 0) {
+            ts->rdidx1 += r;
+            ts->size1 += r;
+            if (ts->rdidx1 == BUFSIZE)
                 ts->rdidx1 = 0;
+                ts->wridx1 = 0;
+            }
+            if (ts->size2 == 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;
+                ts->wridx2 = 0;
+            }
+#ifndef CONFIG_FEATURE_TELNETD_INETD
+            ts = next;
+        }
+#endif /* CONFIG_FEATURE_TELNETD_INETD */
+    } while (1);
+    return 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;
+}

branches/stable/mindi-busybox/networking/tftp.c

-              r821
+              r1770
  * ------------------------------------------------------------------------- */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "busybox.h"
+#include "libbb.h"
+#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT
 #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_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)
+#if ENABLE_FEATURE_TFTP_GET && !ENABLE_FEATURE_TFTP_PUT
+#define USE_GETPUT(...)
+#define CMD_GET(cmd) 1
+#define CMD_PUT(cmd) 0
+#elif !ENABLE_FEATURE_TFTP_GET && ENABLE_FEATURE_TFTP_PUT
+#define USE_GETPUT(...)
+#define CMD_GET(cmd) 0
+#define CMD_PUT(cmd) 1
 #else
+# define tftp_cmd_put 0
+#endif
+#ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
+#define USE_GETPUT(...) __VA_ARGS__
+/* masks coming from getpot32 */
+#define CMD_GET(cmd) ((cmd) & 1)
+#define CMD_PUT(cmd) ((cmd) & 2)
+#endif
+/* NB: in the code below
+ * CMD_GET(cmd) and CMD_PUT(cmd) are mutually exclusive
+ */
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
 static int tftp_blocksize_check(int blocksize, int bufsize)
 …
      */
+    if ((bufsize && (blocksize > bufsize)) ||
+        (blocksize < 8) || (blocksize > 65564)) {
+    if ((bufsize && (blocksize > bufsize))
+     || (blocksize < 8) || (blocksize > 65564)
+    ) {
         bb_error_msg("bad blocksize");
         return 0;
 …
+}
 static char *tftp_option_get(char *buf, int len, const char * const option)
+static char *tftp_option_get(char *buf, int len, const char *option)
+{
     int opt_val = 0;
 …
     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;
+        }
+                goto nul_found;
+            }
+        }
+        return NULL;
+ nul_found:
         if (opt_val == 0) {
             if (strcasecmp(buf, option) == 0) {
                 opt_found = 1;
+            }
+        } else {
+            if (opt_found) {
+                return buf;
+            }
+        } else if (opt_found) {
+            return buf;
+        }
         k++;
         buf += k;
         len -= k;
         opt_val ^= 1;
+    }
 …
 #endif
+static int tftp(const int cmd, const struct hostent *host,
+           const char *remotefile, const int localfd,
+           const unsigned short port, int tftp_bufsize)
+static int tftp( USE_GETPUT(const int cmd,)
+        len_and_sockaddr *peer_lsa,
+        const char *remotefile, const int localfd,
+        unsigned 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 send_len;
+    USE_FEATURE_TFTP_BLOCKSIZE(smallint want_option_ack = 0;)
+    smallint finished = 0;
+    uint16_t opcode;
+    uint16_t block_nr = 1;
+    uint16_t recv_blk;
     int timeout = TFTP_NUM_RETRIES;
-    unsigned short block_nr = 1;
-    unsigned short tmp;
     char *cp;
+    USE_FEATURE_TFTP_BLOCKSIZE(int want_option_ack = 0;)
+    unsigned org_port;
+    len_and_sockaddr *const from = alloca(offsetof(len_and_sockaddr, sa) + peer_lsa->len);
     /* 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 bb_xsocket here. */
+        bb_perror_msg("socket");
+        return EXIT_FAILURE;
+    }
+    len = sizeof(sa);
+    memset(&sa, 0, len);
+    bb_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));
+    /* We must keep the transmit and receive buffers seperate */
+    /* In case we rcv a garbage pkt and we need to rexmit the last pkt */
+    char *xbuf = xmalloc(tftp_bufsize += 4);
+    char *rbuf = xmalloc(tftp_bufsize);
+    port = org_port = htons(port);
+    socketfd = xsocket(peer_lsa->sa.sa_family, SOCK_DGRAM, 0);
     /* build opcode */
+    if (cmd & tftp_cmd_get) {
+    opcode = TFTP_WRQ;
+    if (CMD_GET(cmd)) {
         opcode = TFTP_RRQ;
+    }
+    if (cmd & tftp_cmd_put) {
+        opcode = TFTP_WRQ;
+    }
+    cp = xbuf + 2;
+    /* add filename and mode */
+    /* fill in packet if the filename fits into xbuf */
+    len = strlen(remotefile) + 1;
+    if (2 + len + sizeof("octet") >= tftp_bufsize) {
+        bb_error_msg("remote filename is too long");
+        goto ret;
+    }
+    strcpy(cp, remotefile);
+    cp += len;
+    /* add "mode" part of the package */
+    strcpy(cp, "octet");
+    cp += sizeof("octet");
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+    len = tftp_bufsize - 4; /* data block size */
+    if (len != TFTP_BLOCKSIZE_DEFAULT) {
+        /* rfc2348 says that 65464 is a max allowed value */
+        if ((&xbuf[tftp_bufsize - 1] - cp) < sizeof("blksize NNNNN")) {
+            bb_error_msg("remote filename is too long");
+            goto ret;
+        }
+        /* add "blksize", <nul>, blocksize */
+        strcpy(cp, "blksize");
+        cp += sizeof("blksize");
+        cp += snprintf(cp, 6, "%d", len) + 1;
+        want_option_ack = 1;
+    }
+#endif
+    /* First packet is built, so skip packet generation */
+    goto send_pkt;
+    /* Using mostly goto's - continue/break will be less clear
+     * in where we actually jump to */
     while (1) {
+        cp = buf;
+        /* first create the opcode part */
+        *((unsigned short *) cp) = htons(opcode);
+        /* Build ACK or DATA */
+        cp = xbuf + 2;
+        *((uint16_t*)cp) = htons(block_nr);
         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;
+#ifdef CONFIG_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;
+        block_nr++;
+        opcode = TFTP_ACK;
+        if (CMD_PUT(cmd)) {
+            opcode = TFTP_DATA;
+            len = full_read(localfd, cp, tftp_bufsize - 4);
+            if (len < 0) {
+                bb_perror_msg(bb_msg_read_error);
+                goto ret;
+            }
+            if (len != (tftp_bufsize - 4)) {
+                finished = 1;
+            }
+            cp += len;
+        }
+ send_pkt:
+        /* Send packet */
+        *((uint16_t*)xbuf) = htons(opcode); /* fill in opcode part */
+        send_len = cp - xbuf;
+        /* NB: send_len value is preserved in code below
+         * for potential resend */
+ send_again:
+#if ENABLE_DEBUG_TFTP
+        fprintf(stderr, "sending %u bytes\n", send_len);
+        for (cp = xbuf; cp < &xbuf[send_len]; cp++)
+            fprintf(stderr, "%02x ", (unsigned char) *cp);
+        fprintf(stderr, "\n");
+#endif
+        xsendto(socketfd, xbuf, send_len, &peer_lsa->sa, peer_lsa->len);
+        /* Was it final ACK? then exit */
+        if (finished && (opcode == TFTP_ACK))
+            goto ret;
+        timeout = TFTP_NUM_RETRIES; /* re-initialize */
+ recv_again:
+        /* Receive packet */
+        tv.tv_sec = TFTP_TIMEOUT;
+        tv.tv_usec = 0;
+        FD_ZERO(&rfds);
+        FD_SET(socketfd, &rfds);
+        switch (select(socketfd + 1, &rfds, NULL, NULL, &tv)) {
+            unsigned from_port;
+        case 1:
+            from->len = peer_lsa->len;
+            memset(&from->sa, 0, peer_lsa->len);
+            len = recvfrom(socketfd, rbuf, tftp_bufsize, 0,
+                        &from->sa, &from->len);
+            if (len < 0) {
+                bb_perror_msg("recvfrom");
+                goto ret;
+            }
+            from_port = get_nport(&from->sa);
+            if (port == org_port) {
+                /* Our first query went to port 69
+                 * but reply will come from different one.
+                 * Remember and use this new port */
+                port = from_port;
+                set_nport(peer_lsa, from_port);
+            }
+            if (port != from_port)
+                goto recv_again;
+            goto process_pkt;
+        case 0:
+            timeout--;
+            if (timeout == 0) {
+                bb_error_msg("last timeout");
+                goto ret;
+            }
+            bb_error_msg("last timeout" + 5);
+            goto send_again; /* resend last sent pkt */
+        default:
+            bb_perror_msg("select");
+            goto ret;
+        }
+ process_pkt:
+        /* Process recv'ed packet */
+        opcode = ntohs( ((uint16_t*)rbuf)[0] );
+        recv_blk = ntohs( ((uint16_t*)rbuf)[1] );
+#if ENABLE_DEBUG_TFTP
+        fprintf(stderr, "received %d bytes: %04x %04x\n", len, opcode, recv_blk);
+#endif
+        if (opcode == TFTP_ERROR) {
+            static const char *const errcode_str[] = {
+                "",
+                "file not found",
+                "access violation",
+                "disk full",
+                "illegal TFTP operation",
+                "unknown transfer id",
+                "file already exists",
+                "no such user",
+                "bad option"
+            };
+            const char *msg = "";
+            if (rbuf[4] != '\0') {
+                msg = &rbuf[4];
+                rbuf[tftp_bufsize - 1] = '\0';
+            } else if (recv_blk < ARRAY_SIZE(errcode_str)) {
+                msg = errcode_str[recv_blk];
+            }
+            bb_error_msg("server error: (%u) %s", recv_blk, msg);
+            goto ret;
+        }
+#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(&rbuf[2], len - 2, "blksize");
+                if (res) {
+                    int blksize = xatoi_u(res);
+                    if (!tftp_blocksize_check(blksize, tftp_bufsize - 4)) {
+                        /* send ERROR 8 to server... */
+                        /* htons can be impossible to use in const initializer: */
+                        /*static const uint16_t error_8[2] = { htons(TFTP_ERROR), htons(8) };*/
+                        /* thus we open-code big-endian layout */
+                        static const uint8_t error_8[4] = { 0,TFTP_ERROR, 0,8 };
+                        xsendto(socketfd, error_8, 4, &peer_lsa->sa, peer_lsa->len);
+                        bb_error_msg("server proposes bad blksize %d, exiting", blksize);
+                        goto ret;
+                    }
+#if ENABLE_DEBUG_TFTP
+                    fprintf(stderr, "using blksize %u\n",
+                            blksize);
+#endif
+                    tftp_bufsize = blksize + 4;
+                    /* Send ACK for OACK ("block" no: 0) */
+                    block_nr = 0;
+                    continue;
+                }
+                /* 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 = bb_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;
+#ifdef CONFIG_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]));
+#ifdef CONFIG_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;
+        }
+#ifdef CONFIG_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 = atoi(res);
+                    if (tftp_blocksize_check(blksize, tftp_bufsize - 4)) {
+                        if (cmd & tftp_cmd_put) {
+                            opcode = TFTP_DATA;
+                        } else {
+                            opcode = TFTP_ACK;
+                        }
+#ifdef CONFIG_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");
+                /* rfc2347:
+                 * "An option not acknowledged by the server
+                 *  must be ignored by the client and server
+                 *  as if it were never requested." */
+            }
+            bb_error_msg("blksize is 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 = bb_full_write(localfd, &buf[4], len - 4);
+        /* block_nr is already advanced to next block# we expect
+         * to get / block# we are about to send next time */
+        if (CMD_GET(cmd) && (opcode == TFTP_DATA)) {
+            if (recv_blk == block_nr) {
+                len = full_write(localfd, &rbuf[4], len - 4);
                 if (len < 0) {
                     bb_perror_msg(bb_msg_write_error);
                     break;
+                    goto ret;
+                }
                 if (len != (tftp_bufsize - 4)) {
                     finished++;
+                    finished = 1;
+                }
+                opcode = TFTP_ACK;
+                continue; /* send ACK */
+            }
+            if (recv_blk == (block_nr - 1)) {
+                /* Server lost our TFTP_ACK.  Resend it */
+                block_nr = recv_blk;
                 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;
+            }
+        }
+    }
+#ifdef CONFIG_FEATURE_CLEAN_UP
+    close(socketfd);
+    free(buf);
+#endif
+    return finished ? EXIT_SUCCESS : EXIT_FAILURE;
+        }
+        if (CMD_PUT(cmd) && (opcode == TFTP_ACK)) {
+            /* did server ACK our last DATA pkt? */
+            if (recv_blk == (uint16_t) (block_nr - 1)) {
+                if (finished)
+                    goto ret;
+                continue; /* send next block */
+            }
+        }
+        /* Awww... recv'd packet is not recognized! */
+        goto recv_again;
+        /* why recv_again? - rfc1123 says:
+         * "The sender (i.e., the side originating the DATA packets)
+         *  must never resend the current DATA packet on receipt
+         *  of a duplicate ACK".
+         * DATA pkts are resent ONLY on timeout.
+         * Thus "goto send_again" will ba a bad mistake above.
+         * See:
+         * http://en.wikipedia.org/wiki/Sorcerer's_Apprentice_Syndrome
+         */
+    }
+ ret:
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        close(socketfd);
+        free(xbuf);
+        free(rbuf);
+    }
+    return finished == 0; /* returns 1 on failure */
+}
+int tftp_main(int argc, char **argv);
 int tftp_main(int argc, char **argv)
+{
     struct hostent *host = NULL;
+    len_and_sockaddr *peer_lsa;
     const char *localfile = NULL;
     const char *remotefile = NULL;
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
+    const char *sblocksize = NULL;
+#endif
     int port;
     int cmd = 0;
+    USE_GETPUT(int cmd;)
     int fd = -1;
     int flags = 0;
 …
     int blocksize = TFTP_BLOCKSIZE_DEFAULT;
+    /* figure out what to pass to getopt */
+#ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
+    char *sblocksize = NULL;
+#define BS "b:"
+#define BS_ARG , &sblocksize
+#else
+#define BS
+#define BS_ARG
+#endif
+#ifdef CONFIG_FEATURE_TFTP_GET
+#define GET "g"
+#define GET_COMPL ":g"
+#else
+#define GET
+#define GET_COMPL
+#endif
+#ifdef CONFIG_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)
+    bb_opt_complementally = GET_COMPL PUT_COMPL ":?g--p:p--g";
+#elif defined(CONFIG_FEATURE_TFTP_GET) || defined(CONFIG_FEATURE_TFTP_PUT)
+    bb_opt_complementally = GET_COMPL PUT_COMPL;
+#endif
+    cmd = bb_getopt_ulflags(argc, argv, GET PUT "l:r:" BS,
+                            &localfile, &remotefile BS_ARG);
+    cmd &= (tftp_cmd_get | tftp_cmd_put);
+#ifdef CONFIG_FEATURE_TFTP_GET
+    if (cmd == tftp_cmd_get)
+    /* -p or -g is mandatory, and they are mutually exclusive */
+    opt_complementary = "" USE_FEATURE_TFTP_GET("g:") USE_FEATURE_TFTP_PUT("p:")
+            USE_GETPUT("?g--p:p--g");
+    USE_GETPUT(cmd =) getopt32(argv,
+            USE_FEATURE_TFTP_GET("g") USE_FEATURE_TFTP_PUT("p")
+                "l:r:" USE_FEATURE_TFTP_BLOCKSIZE("b:"),
+            &localfile, &remotefile
+            USE_FEATURE_TFTP_BLOCKSIZE(, &sblocksize));
+    argv += optind;
+    flags = O_RDONLY;
+    if (CMD_GET(cmd))
         flags = O_WRONLY | O_CREAT | O_TRUNC;
+#endif
+#ifdef CONFIG_FEATURE_TFTP_PUT
+    if (cmd == tftp_cmd_put)
+        flags = O_RDONLY;
+#endif
+#ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
+#if ENABLE_FEATURE_TFTP_BLOCKSIZE
     if (sblocksize) {
         blocksize = atoi(sblocksize);
+        blocksize = xatoi_u(sblocksize);
         if (!tftp_blocksize_check(blocksize, 0)) {
             return EXIT_FAILURE;
 …
 #endif
     if (localfile == NULL)
+    if (!localfile)
         localfile = remotefile;
     if (remotefile == NULL)
+    if (!remotefile)
         remotefile = localfile;
+    if ((localfile == NULL && remotefile == NULL) || (argv[optind] == NULL))
+    /* Error if filename or host is not known */
+    if (!remotefile || !argv[0])
         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);
+#ifdef CONFIG_DEBUG_TFTP
+    fprintf(stderr, "using server \"%s\", remotefile \"%s\", "
+            "localfile \"%s\".\n",
+            inet_ntoa(*((struct in_addr *) host->h_addr)),
+    fd = CMD_GET(cmd) ? STDOUT_FILENO : STDIN_FILENO;
+    if (!LONE_DASH(localfile)) {
+        fd = xopen(localfile, flags);
+    }
+    port = bb_lookup_port(argv[1], "udp", 69);
+    peer_lsa = xhost2sockaddr(argv[0], port);
+#if ENABLE_DEBUG_TFTP
+    fprintf(stderr, "using server '%s', remotefile '%s', localfile '%s'\n",
+            xmalloc_sockaddr2dotted(&peer_lsa->sa),
             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);
+    result = tftp( USE_GETPUT(cmd,) peer_lsa, remotefile, fd, port, blocksize);
+    if (ENABLE_FEATURE_CLEAN_UP)
+        close(fd);
+    if (result != EXIT_SUCCESS && !LONE_DASH(localfile) && CMD_GET(cmd)) {
+        unlink(localfile);
+    }
+    return result;
+}
+#endif /* ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT */

branches/stable/mindi-busybox/networking/traceroute.c

-              r902
+              r1770
  */
+#undef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+#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_SO_DEBUG   /* not in documentation man */
+#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+//#undef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
 //#define CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
 #undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+//#undef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
 //#define CONFIG_FEATURE_TRACEROUTE_USE_ICMP
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <endian.h>
-#include <getopt.h>
-#include <sys/param.h>
-#include <sys/file.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/select.h>
-#include "inet_common.h"
 #include <net/if.h>
+#include <arpa/inet.h>
 #include <netinet/in.h>
-#include <arpa/inet.h>
 #include <netinet/udp.h>
 #include <netinet/ip.h>
 #include <netinet/ip_icmp.h>
+#include "busybox.h"
+#include "libbb.h"
+#include "inet_common.h"
 …
  * Per RFC 791, September 1981.
  */
+#define IPVERSION       4
+#define IPVERSION 4
+#ifndef IPPROTO_ICMP
+/* Grrrr.... */
+#define IPPROTO_ICMP 1
+#endif
+#ifndef IPPROTO_IP
+#define IPPROTO_IP 0
+#endif
 /*
 …
  * UDP kernel structures and variables.
  */
 struct  udpiphdr {
+struct udpiphdr {
     struct  ipovly ui_i;            /* overlaid ip structure */
     struct  udphdr ui_u;            /* udp header */
 …
     char *name;
     int n;
     u_int32_t *addrs;
+    uint32_t *addrs;
 };
 …
     unsigned char seq;             /* sequence number of this packet */
     unsigned char ttl;             /* ttl packet left with */
+    struct timeval tv ATTRIBUTE_PACKED; /* time packet left */
+// UNUSED. Retaining to have the same packet size.
+    struct timeval tv_UNUSED ATTRIBUTE_PACKED; /* time packet left */
 };
 struct IFADDRLIST {
     u_int32_t addr;
+    uint32_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 outdata *outdata;        /* last output (udp) packet */
 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
 static struct icmp *outicmp;           /* last output (icmp) packet */
-#endif
-#ifdef CONFIG_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 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 char *hostname;
 static u_short ident;
 static u_short port = 32768 + 666;     /* start udp dest port # for probe packets */
+static uint16_t ident;
+static uint16_t 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 */
 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 static int optlen;                     /* length of ip options */
 #else
 …
 #endif
+#ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+static int useicmp;                    /* use icmp echo instead of udp packets */
+#endif
+#ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+static int verbose;
+#endif
+/* Keep in sync with getopt32 call! */
+#define OPT_DONT_FRAGMNT (1<<0)    /* F */
+#define OPT_USE_ICMP     (1<<1)    /* I */
+#define OPT_TTL_FLAG     (1<<2)    /* l */
+#define OPT_ADDR_NUM     (1<<3)    /* n */
+#define OPT_BYPASS_ROUTE (1<<4)    /* r */
+#define OPT_DEBUG        (1<<5)    /* d */
+#define OPT_VERBOSE      (1<<6)    /* v */
+#define OPT_IP_CHKSUM    (1<<7)    /* x */
+#define OPT_TOS          (1<<8)    /* t */
+#define OPT_DEVICE       (1<<9)    /* i */
+#define OPT_MAX_TTL      (1<<10)   /* m */
+#define OPT_PORT         (1<<11)   /* p */
+#define OPT_NPROBES      (1<<12)   /* q */
+#define OPT_SOURCE       (1<<13)   /* s */
+#define OPT_WAITTIME     (1<<14)   /* w */
+#define OPT_PAUSE_MS     (1<<15)   /* z */
+#define OPT_FIRST_TTL    (1<<16)   /* f */
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
+/* use icmp echo instead of udp packets */
+#define useicmp (option_mask32 & OPT_USE_ICMP)
+#endif
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
+#define verbose (option_mask32 & OPT_VERBOSE)
+#endif
+#define nflag   (option_mask32 & OPT_ADDR_NUM)
+struct globals {
+    /* last inbound (icmp) packet */
+    unsigned char packet[512];
+    struct sockaddr_storage whereto;        /* Who to try to reach */
+    struct sockaddr_storage wherefrom;      /* Who we are */
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    /* Maximum number of gateways (include room for one noop) */
+#define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(uint32_t)))
+    /* loose source route gateway list (including room for final destination) */
+    uint32_t gwlist[NGATEWAYS + 1];
+#endif
+};
+#define G (*ptr_to_globals)
+#define packet    (G.packet   )
+#define whereto   (G.whereto  )
+#define wherefrom (G.wherefrom)
+#define gwlist    (G.gwlist   )
 /*
 …
 ifaddrlist(struct IFADDRLIST **ipaddrp)
+{
+    enum { IFREQ_BUFSIZE = (32 * 1024) / sizeof(struct ifreq) };
     int fd, nipaddr;
 #ifdef HAVE_SOCKADDR_SA_LEN
 …
     struct IFADDRLIST *al;
     struct ifconf ifc;
+    struct ifreq ibuf[(32 * 1024) / sizeof(struct ifreq)], ifr;
+    struct ifreq ifr;
+    /* Was on stack, but 32k is a bit too much: */
+    struct ifreq *ibuf = xmalloc(IFREQ_BUFSIZE * sizeof(ibuf[0]));
     struct IFADDRLIST *st_ifaddrlist;
     fd = bb_xsocket(AF_INET, SOCK_DGRAM, 0);
     ifc.ifc_len = sizeof(ibuf);
+    fd = xsocket(AF_INET, SOCK_DGRAM, 0);
+    ifc.ifc_len = IFREQ_BUFSIZE * sizeof(ibuf[0]);
     ifc.ifc_buf = (caddr_t)ibuf;
+    if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
+        ifc.ifc_len < sizeof(struct ifreq)) {
+    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");
+                "SIOCGIFCONF: ifreq struct too small (%u bytes)",
+                (unsigned)(IFREQ_BUFSIZE * sizeof(ibuf[0])));
+        bb_perror_msg_and_die("SIOCGIFCONF");
+    }
     ifrp = ibuf;
 …
     nipaddr = 1 + (ifc.ifc_len / sizeof(struct ifreq));
     st_ifaddrlist = xcalloc(nipaddr, sizeof(struct IFADDRLIST));
+    st_ifaddrlist = xzalloc(nipaddr * sizeof(struct IFADDRLIST));
     al = st_ifaddrlist;
     nipaddr = 0;
 …
             continue;
 #endif
         if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0)
             bb_perror_msg_and_die("SIOCGIFADDR: %s", al->device);
+        ioctl_or_perror_and_die(fd, SIOCGIFADDR, (char *)&ifr,
+                "SIOCGIFADDR: %s", al->device);
         addr_sin = (struct sockaddr_in *)&ifr.ifr_addr;
 …
         ++nipaddr;
+    }
+    if(nipaddr == 0)
+        bb_error_msg_and_die ("Can't find any network interfaces");
+    (void)close(fd);
+    if (nipaddr == 0)
+        bb_error_msg_and_die("can't find any network interfaces");
+    free(ibuf);
+    close(fd);
     *ipaddrp = st_ifaddrlist;
     return nipaddr;
 …
 static void
 setsin(struct sockaddr_in *addr_sin, u_int32_t addr)
+setsin(struct sockaddr_in *addr_sin, uint32_t addr)
+{
     memset(addr_sin, 0, sizeof(*addr_sin));
 …
     int i, n;
     FILE *f;
     u_int32_t mask;
     u_int32_t dest, tmask;
+    uint32_t mask;
+    uint32_t dest, tmask;
     struct IFADDRLIST *al;
     char buf[256], tdevice[256], device[256];
     f = bb_xfopen(route, "r");
+    f = xfopen("/proc/net/route", "r");
     /* Find the appropriate interface */
 …
         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)) {
+        i = sscanf(buf, "%255s %x %*s %*s %*s %*s %*s %x",
+                    tdevice, &dest, &tmask);
+        if (i != 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);
 …
     if (device[0] == '\0')
         bb_error_msg_and_die ("Can't find interface");
+        bb_error_msg_and_die("can't find interface");
     /* Get the interface address list */
 …
             break;
     if (i <= 0)
         bb_error_msg_and_die("Can't find interface %s", device);
+        bb_error_msg_and_die("can't find interface %s", device);
     setsin(from, al->addr);
 …
 */
-/* String to value with optional min and max. Handles decimal and hex. */
 static int
+str2val(const char *str, const char *what, int mi, int ma)
+{
+    const char *cp;
+    int val;
+    char *ep;
+    if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
+        cp = str + 2;
+        val = (int)strtol(cp, &ep, 16);
+    } else
+        val = (int)strtol(str, &ep, 10);
+    if (*ep != '\0') {
+        bb_error_msg_and_die("\"%s\" bad value for %s \n", str, what);
+    }
+    if (val < mi && mi >= 0) {
+        if (mi == 0)
+            bb_error_msg_and_die("%s must be >= %d\n", what, mi);
+        else
+            bb_error_msg_and_die("%s must be > %d\n", what, mi - 1);
+    }
+    if (val > ma && ma >= 0)
+        bb_error_msg_and_die("%s must be <= %d\n", what, ma);
+    return val;
+}
+/*
+ * 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)
+wait_for_reply(int sock, struct sockaddr_in *fromp)
+{
     fd_set fds;
+    struct timeval now, wait;
+    struct timezone tz;
+    struct timeval tvwait;
     int cc = 0;
     socklen_t fromlen = sizeof(*fromp);
 …
     FD_SET(sock, &fds);
+    wait.tv_sec = tp->tv_sec + waittime;
+    wait.tv_usec = tp->tv_usec;
+    (void)gettimeofday(&now, &tz);
+    tvsub(&wait, &now);
+    if (select(sock + 1, &fds, NULL, NULL, &wait) > 0)
+    tvwait.tv_sec = waittime;
+    tvwait.tv_usec = 0;
+    if (select(sock + 1, &fds, NULL, NULL, &tvwait) > 0)
         cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
                 (struct sockaddr *)fromp, &fromlen);
 …
  * Checksum routine for Internet Protocol family headers (C Version)
  */
 static u_short
 in_cksum(u_short *addr, int len)
+static uint16_t
+in_cksum(uint16_t *addr, int len)
+{
     int nleft = len;
     u_short *w = addr;
     u_short answer;
+    uint16_t *w = addr;
+    uint16_t answer;
     int sum = 0;
 …
 static void
 send_probe(int seq, int ttl, struct timeval *tp)
+send_probe(int seq, int ttl)
+{
     int cc;
 …
     if (doipcksum) {
         outip->ip_sum =
             in_cksum((u_short *)outip, sizeof(*outip) + optlen);
+            in_cksum((uint16_t *)outip, sizeof(*outip) + optlen);
         if (outip->ip_sum == 0)
             outip->ip_sum = 0xffff;
 …
     outdata->seq = seq;
     outdata->ttl = ttl;
+    memcpy(&outdata->tv, tp, sizeof(outdata->tv));
+#ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+// UNUSED: was storing gettimeofday's result there, but never ever checked it
+    /*memcpy(&outdata->tv, tp, sizeof(outdata->tv));*/
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
     if (useicmp)
         outicmp->icmp_seq = htons(seq);
 …
         outudp->dest = htons(port + seq);
 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+#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,
+        outicmp->icmp_cksum = in_cksum((uint16_t *)outicmp,
             packlen - (sizeof(*outip) + optlen));
         if (outicmp->icmp_cksum == 0)
 …
     } else
 #endif
            if (doipcksum) {
+    if (doipcksum) {
         /* Checksum (we must save and restore ip header) */
         tip = *outip;
 …
         ui->ui_len = outudp->len;
         outudp->check = 0;
         outudp->check = in_cksum((u_short *)ui, packlen);
+        outudp->check = in_cksum((uint16_t *)ui, packlen);
         if (outudp->check == 0)
             outudp->check = 0xffff;
 …
+    }
 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
     /* XXX undocumented debugging hack */
     if (verbose > 1) {
         const u_short *sp;
+        const uint16_t *sp;
         int nshorts, i;
         sp = (u_short *)outip;
         nshorts = (u_int)packlen / sizeof(u_short);
+        sp = (uint16_t *)outip;
+        nshorts = (unsigned)packlen / sizeof(uint16_t);
         i = 0;
         printf("[ %d bytes", packlen);
 …
 #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",
+            bb_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;
+}
+#ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+    cc = xsendto(sndsock, (char *)outip,
+        packlen, (struct sockaddr *)&whereto, sizeof(whereto));
+    if (cc != packlen)  {
+        bb_info_msg("wrote %s %d chars, ret=%d", hostname, packlen, cc);
+    }
+}
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
 /*
  * Convert an ICMP "type" field to a printable string.
 …
 pr_type(unsigned char t)
+{
     static const char * const ttab[] = {
+    static const char *const ttab[] = {
     "Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
     "Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
 …
     hlen = ip->ip_hl << 2;
     if (cc < hlen + ICMP_MINLEN) {
 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
         if (verbose)
             printf("packet too short (%d bytes) from %s\n", cc,
 …
         hip = &icp->icmp_ip;
         hlen = hip->ip_hl << 2;
 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
         if (useicmp) {
             struct icmp *hicmp;
 …
         } else
 #endif
+              {
+        {
             up = (struct udphdr *)((unsigned char *)hip + hlen);
             /* XXX 8 is a magic number */
 …
+        }
+    }
 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
     if (verbose) {
         int i;
         u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
+        uint32_t *lp = (uint32_t *)&icp->icmp_ip;
         printf("\n%d bytes from %s to "
 …
             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))
+        for (i = 4; i < cc; i += sizeof(*lp))
             printf("%2d: x%8.8x\n", i, *lp++);
+    }
 …
  */
 static inline void
+inetname(struct sockaddr_in *from)
+{
+    const char *n = NULL;
+print_inetname(struct sockaddr_in *from)
+{
     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
+    else {
+        char *n = NULL;
+        if (from->sin_addr.s_addr != INADDR_ANY)
+            n = xmalloc_sockaddr2host_noport((struct sockaddr*)from);
         printf(" %s (%s)", (n ? n : ina), ina);
+        free(n);
+    }
+}
 …
     cc -= hlen;
     inetname(from);
 #ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+    print_inetname(from);
+#if ENABLE_FEATURE_TRACEROUTE_VERBOSE
     if (verbose)
         printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
+        printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst));
 #endif
+}
 …
     struct hostinfo *hi;
     char **p;
     u_int32_t addr, *ap;
     hi = xcalloc(1, sizeof(*hi));
+    uint32_t addr, *ap;
+    hi = xzalloc(sizeof(*hi));
     addr = inet_addr(host);
     if ((int32_t)addr != -1) {
         hi->name = bb_xstrdup(host);
+    if (addr != 0xffffffff) {
+        hi->name = xstrdup(host);
         hi->n = 1;
         hi->addrs = xcalloc(1, sizeof(hi->addrs[0]));
+        hi->addrs = xzalloc(sizeof(hi->addrs[0]));
         hi->addrs[0] = addr;
         return hi;
 …
     if (hp->h_addrtype != AF_INET || hp->h_length != 4)
         bb_perror_msg_and_die("bad host %s", host);
     hi->name = bb_xstrdup(hp->h_name);
+    hi->name = xstrdup(hp->h_name);
     for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
         continue;
     hi->n = n;
     hi->addrs = xcalloc(n, sizeof(hi->addrs[0]));
+    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));
 …
+{
     free(hi->name);
+    hi->name = NULL;
+    free((char *)hi->addrs);
+    free((char *)hi);
+}
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    free(hi->addrs);
+    free(hi);
+}
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
 static void
 getaddr(u_int32_t *ap, const char *host)
+getaddr(uint32_t *ap, const char *host)
+{
     struct hostinfo *hi;
 …
 #endif
+int
+traceroute_main(int argc, char *argv[])
+static void
+print_delta_ms(unsigned t1p, unsigned t2p)
+{
+    unsigned tt = t2p - t1p;
+    printf("  %u.%03u ms", tt/1000, tt%1000);
+}
+int traceroute_main(int argc, char **argv);
+int traceroute_main(int argc, char **argv)
+{
     int code, n;
-    char *cp;
     unsigned char *outp;
     u_int32_t *ap;
     struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
     struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
+    uint32_t *ap;
+    struct sockaddr_in *from;
+    struct sockaddr_in *to;
     struct hostinfo *hi;
-    int on = 1;
-    struct protoent *pe;
     int ttl, probe, i;
     int seq = 0;
     int tos = 0;
+    char *tos_str = NULL;
+    char *source = NULL;
+    unsigned long op;
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    char *tos_str;
+    char *source;
+    unsigned op;
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
     int lsrr = 0;
 #endif
     u_short off = 0;
+    uint16_t off = 0;
     struct IFADDRLIST *al;
     char *device = NULL;
+    char *device;
     int max_ttl = 30;
     char *max_ttl_str = NULL;
     char *port_str = NULL;
+    char *max_ttl_str;
+    char *port_str;
     int nprobes = 3;
     char *nprobes_str = NULL;
     char *waittime_str = NULL;
     u_int pausemsecs = 0;
     char *pausemsecs_str = NULL;
+    char *nprobes_str;
+    char *waittime_str;
+    unsigned pausemsecs = 0;
+    char *pausemsecs_str;
     int first_ttl = 1;
+    char *first_ttl_str = NULL;
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    llist_t *sourse_route_list = NULL;
+#endif
+    opterr = 0;
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    bb_opt_complementally = "x-x:g::";
+    char *first_ttl_str;
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    llist_t *source_route_list = NULL;
+#endif
+    PTR_TO_GLOBALS = xzalloc(sizeof(G));
+    from = (struct sockaddr_in *)&wherefrom;
+    to = (struct sockaddr_in *)&whereto;
+    //opterr = 0;
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    opt_complementary = "x-x:g::";
 #else
+    bb_opt_complementally = "x-x";
+#endif
+    op = bb_getopt_ulflags(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 */
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    opt_complementary = "x-x";
+#endif
+    op = getopt32(argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
+#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
 #ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
     , &sourse_route_list
+        , &tos_str, &device, &max_ttl_str, &port_str, &nprobes_str
+        , &source, &waittime_str, &pausemsecs_str, &first_ttl_str
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+        , &source_route_list
 #endif
     );
     if(op & USAGE_OP_DONT_FRAGMNT)
+    if (op & OPT_DONT_FRAGMNT)
         off = IP_DF;
+#ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+    useicmp = op & USAGE_OP_USE_ICMP;
+#endif
+    nflag = op & USAGE_OP_ADDR_NUM;
+#ifdef CONFIG_FEATURE_TRACEROUTE_VERBOSE
+    verbose = op &  USAGE_OP_VERBOSE;
+#endif
+    if(op & USAGE_OP_IP_CHKSUM) {
+    if (op & OPT_IP_CHKSUM) {
         doipcksum = 0;
+        bb_error_msg("Warning: ip checksums disabled");
+    }
+    if (tos_str)
+        tos = str2val(tos_str, "tos", 0, 255);
+    if(max_ttl_str)
+        max_ttl = str2val(max_ttl_str, "max ttl", 1, 255);
+    if(port_str)
+        port = (u_short)str2val(port_str, "port", 1, (1 << 16) - 1);
+    if(nprobes_str)
+        nprobes = str2val(nprobes_str, "nprobes", 1, -1);
+    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 = str2val(waittime_str, "wait time", 2, 24 * 60 * 60);
+    if(pausemsecs_str)
+        pausemsecs = str2val(pausemsecs_str, "pause msecs", 0, 60 * 60 * 1000);
+    if(first_ttl_str)
+        first_ttl = str2val(first_ttl_str, "first ttl", 1, 255);
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    if(sourse_route_list) {
+        bb_error_msg("warning: ip checksums disabled");
+    }
+    if (op & OPT_TOS)
+        tos = xatou_range(tos_str, 0, 255);
+    if (op & OPT_MAX_TTL)
+        max_ttl = xatou_range(max_ttl_str, 1, 255);
+    if (op & OPT_PORT)
+        port = xatou16(port_str);
+    if (op & OPT_NPROBES)
+        nprobes = xatou_range(nprobes_str, 1, INT_MAX);
+    if (op & OPT_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 (op & OPT_WAITTIME)
+        waittime = xatou_range(waittime_str, 2, 24 * 60 * 60);
+    if (op & OPT_PAUSE_MS)
+        pausemsecs = xatou_range(pausemsecs_str, 0, 60 * 60 * 1000);
+    if (op & OPT_FIRST_TTL)
+        first_ttl = xatou_range(first_ttl_str, 1, 255);
+#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    if (source_route_list) {
         llist_t *l_sr;
+        for(l_sr = sourse_route_list; l_sr; ) {
+        l_sr = source_route_list;
+        while (l_sr) {
             if (lsrr >= NGATEWAYS)
                 bb_error_msg_and_die("No more than %d gateways", 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;
+            free(source_route_list);
+            source_route_list = l_sr;
+        }
         optlen = (lsrr + 1) * sizeof(gwlist[0]);
 …
     minpacket = sizeof(*outip) + sizeof(*outdata) + optlen;
 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+#if ENABLE_FEATURE_TRACEROUTE_USE_ICMP
     if (useicmp)
         minpacket += 8;                 /* XXX magic number */
 …
     case 2:
+        packlen = str2val(argv[optind + 1],
+            "packet length", minpacket, maxpacket);
+        packlen = xatoul_range(argv[optind + 1], minpacket, maxpacket);
         /* Fall through */
 …
         setsin(to, hi->addrs[0]);
         if (hi->n > 1)
+            bb_error_msg(
+            "Warning: %s has multiple addresses; using %s",
+            bb_error_msg("warning: %s has multiple addresses; using %s",
                 hostname, inet_ntoa(to->sin_addr));
         hostname = hi->name;
 …
+    }
+    cp = "icmp";
+    if ((pe = getprotobyname(cp)) == NULL)
+        bb_perror_msg_and_die("unknown protocol %s", cp);
+    /* Insure the socket fds won't be 0, 1 or 2 */
+    do n = bb_xopen(bb_dev_null, O_RDONLY); while (n < 2);
+    if (n > 2)
+        close(n);
+    s = bb_xsocket(AF_INET, SOCK_RAW, pe->p_proto);
+#ifdef CONFIG_FEATURE_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 = bb_xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+#ifdef CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE
+    /* Ensure the socket fds won't be 0, 1 or 2 */
+    bb_sanitize_stdio();
+    s = xsocket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+#if TRACEROUTE_SO_DEBUG
+    if (op & OPT_DEBUG)
+        setsockopt(s, SOL_SOCKET, SO_DEBUG,
+                &const_int_1, sizeof(const_int_1));
+#endif
+    if (op & OPT_BYPASS_ROUTE)
+        setsockopt(s, SOL_SOCKET, SO_DONTROUTE,
+                &const_int_1, sizeof(const_int_1));
+    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];
-        cp = "ip";
-        if ((pe = getprotobyname(cp)) == NULL)
-            bb_perror_msg_and_die("unknown protocol");
         /* final hop */
 …
         memcpy(optlist + 4, gwlist, i);
         if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
+        if ((setsockopt(sndsock, IPPROTO_IP, IP_OPTIONS,
             (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
             bb_perror_msg_and_die("IP_OPTIONS");
+            }
+        }
+    }
 #endif /* IP_OPTIONS */
 …
 #ifdef SO_SNDBUF
+    if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
+        sizeof(packlen)) < 0) {
+    if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, &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) {
+    if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, &const_int_1, sizeof(const_int_1)) < 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) {
+    if (tos_str && setsockopt(sndsock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
         bb_perror_msg_and_die("setsockopt tos %d", tos);
+    }
 #endif
 #endif
 #ifdef CONFIG_FEATURE_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));
+#if TRACEROUTE_SO_DEBUG
+    if (op & OPT_DEBUG)
+        setsockopt(sndsock, SOL_SOCKET, SO_DEBUG,
+                &const_int_1, sizeof(const_int_1));
+#endif
+    if (op & OPT_BYPASS_ROUTE)
+        setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE,
+                &const_int_1, sizeof(const_int_1));
     /* Revert to non-privileged user after opening sockets */
 …
     xsetuid(getuid());
     outip = (struct ip *)xcalloc(1, (unsigned)packlen);
+    outip = xzalloc(packlen);
     outip->ip_v = IPVERSION;
 …
     outip->ip_hl = (outp - (unsigned char *)outip) >> 2;
     ident = (getpid() & 0xffff) | 0x8000;
 #ifdef CONFIG_FEATURE_TRACEROUTE_USE_ICMP
+#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)));
+        outudp->len = htons((uint16_t)(packlen - (sizeof(*outip) + optlen)));
         outdata = (struct outdata *)(outudp + 1);
+    }
 …
     /* Look for a specific device */
     if (device != NULL) {
+    if (op & OPT_DEVICE) {
         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);
+        }
+    }
+                goto found_dev;
+        bb_error_msg_and_die("can't find interface %s", device);
+    }
+ found_dev:
     /* Determine our source address */
     if (source == NULL) {
+    if (!(op & OPT_SOURCE)) {
         /*
          * If a device was specified, use the interface address.
          * Otherwise, try to determine our source address.
          */
         if (device != NULL)
+        if (op & OPT_DEVICE)
             setsin(from, al->addr);
         findsaddr(to, from);
 …
          * there are more than one).
          */
         if (device != NULL) {
+        if (op & OPT_DEVICE) {
             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);
+            }
+                    goto found_dev2;
+            bb_error_msg_and_die("%s is not on interface %s",
+                    source, device);
+ found_dev2:
             setsin(from, *ap);
         } else {
 …
             if (hi->n > 1)
                 bb_error_msg(
             "Warning: %s has multiple addresses; using %s",
+            "warning: %s has multiple addresses; using %s",
                     source, inet_ntoa(from->sin_addr));
+        }
 …
     outip->ip_src = from->sin_addr;
 #ifndef IP_HDRINCL
     bb_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);
+    xbind(sndsock, (struct sockaddr *)from, sizeof(*from));
+#endif
+    printf("traceroute to %s (%s)", hostname, inet_ntoa(to->sin_addr));
+    if (op & OPT_SOURCE)
+        printf(" from %s", source);
+    printf(", %d hops max, %d byte packets\n", max_ttl, packlen);
+    fflush(stdout);
     for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
         u_int32_t lastaddr = 0;
+        uint32_t lastaddr = 0;
         int gotlastaddr = 0;
         int got_there = 0;
 …
         for (probe = 0; probe < nprobes; ++probe) {
             int cc;
             struct timeval t1, t2;
             struct timezone tz;
+            unsigned t1;
+            unsigned t2;
             struct ip *ip;
             if (sentfirst && pausemsecs > 0)
                 usleep(pausemsecs * 1000);
             (void)gettimeofday(&t1, &tz);
             send_probe(++seq, ttl, &t1);
+            t1 = monotonic_us();
+            send_probe(++seq, ttl);
             ++sentfirst;
             while ((cc = wait_for_reply(s, from, &t1)) != 0) {
                 (void)gettimeofday(&t2, &tz);
+            while ((cc = wait_for_reply(s, from)) != 0) {
+                t2 = monotonic_us();
                 i = packet_ok(packet, cc, from, seq);
                 /* Skip short packet */
 …
                     ++gotlastaddr;
+                }
                 printf("  %.3f ms", deltaT(&t1, &t2));
+                print_delta_ms(t1, t2);
                 ip = (struct ip *)packet;
                 if (op & USAGE_OP_TTL_FLAG)
+                if (op & OPT_TTL_FLAG)
                     printf(" (%d)", ip->ip_ttl);
                 if (i == -2) {

branches/stable/mindi-busybox/networking/udhcp/Config.in

-              r821
+              r1770
+#
+menu "udhcp Server/Client"
+config CONFIG_APP_UDHCPD
+config APP_UDHCPD
     bool "udhcp Server (udhcpd)"
     default n
 …
       See http://udhcp.busybox.net for further details.
+config CONFIG_APP_UDHCPC
+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 FEATURE_UDHCPD_WRITE_LEASES_EARLY
+    bool "Rewrite the lease file at every new acknowledge"
+    default n
+    depends on APP_UDHCPD
+    help
+      If selected, udhcpd will write a new file with leases every
+      time a new lease has been accepted, thus eleminating the need
+      to send SIGUSR1 for the initial writing, or updating. Any timed
+      rewriting remains undisturbed
+config APP_UDHCPC
     bool "udhcp Client (udhcpc)"
     default n
 …
       See http://udhcp.busybox.net for further details.
 config CONFIG_APP_DUMPLEASES
     bool "Lease display utility (dumpleases)"
+config FEATURE_UDHCP_DEBUG
+    bool "Compile udhcp with noisy debugging messages"
     default n
+    depends on CONFIG_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 CONFIG_FEATURE_UDHCP_SYSLOG
+    bool "  Log udhcp messages to syslog (instead of stdout)"
+    default n
+    depends on CONFIG_APP_UDHCPD || CONFIG_APP_UDHCPC
+    help
+      If selected, udhcpd will log all its messages to syslog, otherwise,
+      it will attempt to log them to stdout.
+      See http://udhcp.busybox.net for further details.
+config CONFIG_FEATURE_UDHCP_DEBUG
+    bool "  Compile udhcp with noisy debugging messages"
+    default n
+    depends on CONFIG_APP_UDHCPD || CONFIG_APP_UDHCPC
+    depends on APP_UDHCPD || APP_UDHCPC
     help
       If selected, udhcpd will output extra debugging output.  If using
 …
       See http://udhcp.busybox.net for further details.
+endmenu
+config FEATURE_RFC3397
+    bool "Support for RFC3397 domain search (experimental)"
+    default n
+    depends on APP_UDHCPD || APP_UDHCPC
+    help
+      If selected, both client and server will support passing of domain
+      search lists via option 119, specified in RFC3397.

branches/stable/mindi-busybox/networking/udhcp/arpping.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * arpping.c
 …
  */
-#include <time.h>
-#include <sys/socket.h>
 #include <netinet/if_ether.h>
 #include <net/if_arp.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
+#include "common.h"
 #include "dhcpd.h"
-#include "arpping.h"
-#include "common.h"
-/* 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 optval = 1;
-    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;
+    if ((s = socket (PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP))) == -1) {
+#ifdef IN_BUSYBOX
+        LOG(LOG_ERR, bb_msg_can_not_create_raw_socket);
+#else
+        LOG(LOG_ERR, "Could not open raw socket");
+#endif
+struct arpMsg {
+    /* Ethernet header */
+    uint8_t  h_dest[6];     /* 00 destination ether addr */
+    uint8_t  h_source[6];   /* 06 source ether addr */
+    uint16_t h_proto;       /* 0c packet type ID field */
+    /* ARP packet */
+    uint16_t htype;         /* 0e hardware type (must be ARPHRD_ETHER) */
+    uint16_t ptype;         /* 10 protocol type (must be ETH_P_IP) */
+    uint8_t  hlen;          /* 12 hardware address length (must be 6) */
+    uint8_t  plen;          /* 13 protocol address length (must be 4) */
+    uint16_t operation;     /* 14 ARP opcode */
+    uint8_t  sHaddr[6];     /* 16 sender's hardware address */
+    uint8_t  sInaddr[4];    /* 1c sender's IP address */
+    uint8_t  tHaddr[6];     /* 20 target's hardware address */
+    uint8_t  tInaddr[4];    /* 26 target's IP address */
+    uint8_t  pad[18];       /* 2a pad for min. ethernet payload (60 bytes) */
+} ATTRIBUTE_PACKED;
+/* Returns 1 if no reply received */
+int arpping(uint32_t test_ip, uint32_t from_ip, uint8_t *from_mac, const char *interface)
+{
+    int timeout = 2;
+    int s;                  /* socket */
+    int rv = 1;             /* "no reply received" yet */
+    struct sockaddr addr;   /* for interface name */
+    struct arpMsg arp;
+    fd_set fdset;
+    struct timeval tm;
+    unsigned 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(s, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval)) == -1) {
+        LOG(LOG_ERR, "Could not setsocketopt on raw socket");
+        close(s);
+        return -1;
+    if (setsockopt_broadcast(s) == -1) {
+        bb_perror_msg("cannot setsocketopt on raw socket");
+        goto ret;
+    }
     /* 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(arp.h_dest, 0xff, 6);                    /* MAC DA */
+    memcpy(arp.h_source, from_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.sHaddr, from_mac, 6);                /* source hardware address */
+    memcpy(arp.sInaddr, &from_ip, sizeof(from_ip)); /* source IP address */
+    /* tHaddr */                                    /* target hardware address */
+    memcpy(arp.tInaddr, &test_ip, sizeof(test_ip)); /* target IP address */
     memset(&addr, 0, sizeof(addr));
     strcpy(addr.sa_data, interface);
+    safe_strncpy(addr.sa_data, interface, sizeof(addr.sa_data));
     if (sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0)
         rv = 0;
+        goto ret;
     /* wait arp reply, and check it */
     tm.tv_usec = 0;
     prevTime = uptime();
     while (timeout > 0) {
+    /* wait for arp reply, and check it */
+    do {
+        int r;
+        prevTime = monotonic_sec();
         FD_ZERO(&fdset);
         FD_SET(s, &fdset);
         tm.tv_sec = timeout;
+        if (select(s + 1, &fdset, (fd_set *) NULL, (fd_set *) NULL, &tm) < 0) {
+            DEBUG(LOG_ERR, "Error on ARPING request: %m");
+            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(LOG_INFO, "Valid arp reply receved for this address");
+        tm.tv_usec = 0;
+        r = select(s + 1, &fdset, NULL, NULL, &tm);
+        if (r < 0) {
+            bb_perror_msg("error on ARPING request");
+            if (errno != EINTR)
+                break;
+        } else if (r) {
+            if (recv(s, &arp, sizeof(arp), 0) < 0)
+                break;
+            if (arp.operation == htons(ARPOP_REPLY)
+             && memcmp(arp.tHaddr, from_mac, 6) == 0
+             && *((uint32_t *) arp.sInaddr) == test_ip
+            ) {
                 rv = 0;
                 break;
+            }
+        }
+        timeout -= uptime() - prevTime;
+        prevTime = uptime();
+    }
+        timeout -= monotonic_sec() - prevTime;
+    } while (timeout > 0);
+ ret:
     close(s);
     DEBUG(LOG_INFO, "%salid arp replies for this address", rv ? "No v" : "V");
+    DEBUG("%srp reply received for this address", rv ? "No a" : "A");
     return rv;
+}

branches/stable/mindi-busybox/networking/udhcp/clientpacket.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* clientpacket.c
+ *
 …
  */
-#include <string.h>
-#include <sys/socket.h>
 #include <features.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR >= 1) || defined _NEWLIB_VERSION
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 …
 #include <linux/if_ether.h>
 #endif
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include "common.h"
 #include "dhcpd.h"
 #include "clientpacket.h"
+#include "dhcpc.h"
 #include "options.h"
-#include "dhcpc.h"
-#include "common.h"
 /* Create a random xid */
+unsigned long random_xid(void)
+{
+    static int initialized;
+uint32_t random_xid(void)
+{
+    static smallint initialized;
     if (!initialized) {
+        int fd;
+        unsigned long seed;
+        fd = open("/dev/urandom", 0);
+        if (fd < 0 || read(fd, &seed, sizeof(seed)) < 0) {
+            LOG(LOG_WARNING, "Could not load seed from /dev/urandom: %m");
+            seed = time(0);
+        }
+        if (fd >= 0) close(fd);
+        srand(seed);
+        initialized++;
+        srand(monotonic_us());
+        initialized = 1;
+    }
     return rand();
 …
     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.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);
+}
 …
 /* Broadcast a DHCP discover packet to the network, with an optionally requested IP */
 int send_discover(unsigned long xid, unsigned long requested)
+int send_discover(uint32_t xid, uint32_t requested)
+{
     struct dhcpMessage packet;
 …
     add_requests(&packet);
+    LOG(LOG_DEBUG, "Sending discover...");
+    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(uint32_t xid, uint32_t server, uint32_t 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);
 …
-/* 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;
-    LOG(LOG_DEBUG, "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;
+int send_renew(uint32_t xid, uint32_t server, uint32_t ciaddr)
+{
+    struct dhcpMessage packet;
     init_packet(&packet, DHCPREQUEST);
 …
     add_requests(&packet);
     LOG(LOG_DEBUG, "Sending renew...");
+    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,
+        return udhcp_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+    return 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)
+int send_release(uint32_t server, uint32_t ciaddr)
+{
     struct dhcpMessage packet;
 …
     add_simple_option(packet.options, DHCP_SERVER_ID, server);
     LOG(LOG_DEBUG, "Sending release...");
+    bb_info_msg("Sending release...");
     return udhcp_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+}
 …
     bytes = read(fd, &packet, sizeof(struct udp_dhcp_packet));
     if (bytes < 0) {
         DEBUG(LOG_INFO, "couldn't read on raw listening socket -- ignoring");
+        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(LOG_INFO, "message too short, ignoring");
+        DEBUG("Message too short, ignoring");
         return -2;
+    }
     if (bytes < ntohs(packet.ip.tot_len)) {
         DEBUG(LOG_INFO, "Truncated packet");
+        DEBUG("Truncated packet");
         return -2;
+    }
 …
     /* 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(LOG_INFO, "unrelated/bogus packet");
+    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;
+    }
 …
     packet.ip.check = 0;
     if (check != udhcp_checksum(&(packet.ip), sizeof(packet.ip))) {
         DEBUG(LOG_INFO, "bad IP header checksum, ignoring");
+        DEBUG("bad IP header checksum, ignoring");
         return -1;
+    }
 …
     packet.ip.tot_len = packet.udp.len; /* cheat on the psuedo-header */
     if (check && check != udhcp_checksum(&packet, bytes)) {
         DEBUG(LOG_ERR, "packet with bad UDP checksum received, ignoring");
+        bb_error_msg("packet with bad UDP checksum received, ignoring");
         return -2;
+    }
 …
     if (ntohl(payload->cookie) != DHCP_MAGIC) {
         LOG(LOG_ERR, "received bogus message (bad magic) -- ignoring");
         return -2;
+    }
     DEBUG(LOG_INFO, "oooooh!!! got some!");
+        bb_error_msg("received bogus message (bad magic) - ignoring");
+        return -2;
+    }
+    DEBUG("oooooh!!! got some!");
     return bytes - (sizeof(packet.ip) + sizeof(packet.udp));
+}
+}

branches/stable/mindi-busybox/networking/udhcp/clientsocket.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * clientsocket.c -- DHCP client socket creation
 …
  */
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#include <netinet/in.h>
 #include <features.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR >= 1) || defined _NEWLIB_VERSION
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 …
 #endif
-#include "clientsocket.h"
 #include "common.h"
 …
     struct sockaddr_ll sock;
+    DEBUG(LOG_INFO, "Opening raw socket on ifindex %d", ifindex);
+    if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
+        DEBUG(LOG_ERR, "socket call failed: %m");
+        return -1;
+    }
+    DEBUG("Opening raw socket on ifindex %d", ifindex);
+    fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
     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) {
+        DEBUG(LOG_ERR, "bind call failed: %m");
+        close(fd);
+        return -1;
+    }
+    xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
     return fd;

branches/stable/mindi-busybox/networking/udhcp/common.c

-              r821
+              r1770
 /* 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 <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <paths.h>
+#include <sys/socket.h>
+#include <stdarg.h>
+#include "common.h"
+#include "common.h"
+#include "pidfile.h"
+static int daemonized;
+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 zero;
+    if ((zero = open(bb_dev_null, O_RDWR, 0)) < 0)
+        return;
+    while (zero < 3)
+        zero = dup(zero);
+    close(zero);
+}
+void udhcp_background(const char *pidfile)
+{
+#ifdef __uClinux__
+    LOG(LOG_ERR, "Cannot background in uclinux (yet)");
+#else /* __uClinux__ */
+    int pid_fd;
+    /* hold lock during fork. */
+    pid_fd = pidfile_acquire(pidfile);
+    if (daemon(0, 0) == -1) { /* bb_xdaemon? */
+        perror("fork");
+        exit(1);
+    }
+    daemonized++;
+    pidfile_write_release(pid_fd);
+#endif /* __uClinux__ */
+}
+#ifdef CONFIG_FEATURE_UDHCP_SYSLOG
+void udhcp_logging(int level, const char *fmt, ...)
+{
+    va_list p;
+    va_list p2;
+    va_start(p, fmt);
+    __va_copy(p2, p);
+    if (!daemonized) {
+        vprintf(fmt, p);
+        putchar('\n');
+    }
+    vsyslog(level, fmt, p2);
+    va_end(p);
+}
+#else
+static char *syslog_level_msg[] = {
+    [LOG_EMERG]   = "EMERGENCY!",
+    [LOG_ALERT]   = "ALERT!",
+    [LOG_CRIT]    = "critical!",
+    [LOG_WARNING] = "warning",
+    [LOG_ERR]     = "error",
+    [LOG_INFO]    = "info",
+    [LOG_DEBUG]   = "debug"
+const uint8_t MAC_BCAST_ADDR[6] ALIGN2 = {
+xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
-void udhcp_logging(int level, const char *fmt, ...)
+{
-    va_list p;
-    va_start(p, fmt);
-    if (!daemonized) {
-        printf("%s, ", syslog_level_msg[level]);
-        vprintf(fmt, p);
-        putchar('\n');
+    }
-    va_end(p);
+}
-#endif
-void udhcp_start_log_and_pid(const char *client_server, 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(client_server, LOG_PID | LOG_CONS, LOG_LOCAL0);
-    udhcp_logging(LOG_INFO, "%s (v%s) started", client_server, BB_VER);
+}

branches/stable/mindi-busybox/networking/udhcp/common.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* common.h
+ *
 …
 #define _COMMON_H
+#include "libbb_udhcp.h"
+#include "libbb.h"
+#define DEFAULT_SCRIPT  "/usr/share/udhcpc/default.script"
+extern const uint8_t MAC_BCAST_ADDR[6]; /* six all-ones */
+/*** 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,
+        const 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);
+enum syslog_levels {
+    LOG_EMERG = 0,
+    LOG_ALERT,
+    LOG_CRIT,
+    LOG_WARNING,
+    LOG_ERR,
+    LOG_INFO,
+    LOG_DEBUG
+};
+#include <syslog.h>
+/**/
 long uptime(void);
+void udhcp_run_script(struct dhcpMessage *packet, const char *name);
+#define LOG(level, str, args...) udhcp_logging(level, str, ## args)
+// Still need to clean these up...
+/* 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
+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(const char *interface, int *ifindex, uint32_t *addr, uint8_t *arp);
+int listen_socket(/*uint32_t ip,*/ int port, const char *inf);
+/* Returns 1 if no reply received */
+int arpping(uint32_t test_ip, uint32_t from_ip, uint8_t *from_mac, const char *interface);
 #if ENABLE_FEATURE_UDHCP_DEBUG
 # define DEBUG(level, str, args...) LOG(level, str, ## args)
+# define DEBUG(str, args...) bb_info_msg(str, ## args)
 #else
 # define DEBUG(level, str, args...) do {;} while(0)
+# define DEBUG(str, args...) do {;} while (0)
 #endif

branches/stable/mindi-busybox/networking/udhcp/dhcpc.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* dhcpc.c
+ *
 …
  */
-#include <sys/file.h>
-#include <unistd.h>
 #include <getopt.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <signal.h>
+#include <time.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <errno.h>
+#include <syslog.h>
+/* Override ENABLE_FEATURE_PIDFILE - ifupdown needs our pidfile to always exist */
+#define WANT_PIDFILE 1
 #include "common.h"
 #include "dhcpd.h"
 #include "dhcpc.h"
 #include "options.h"
+#include "clientpacket.h"
+#include "clientsocket.h"
+#include "socket.h"
+#include "signalpipe.h"
+static int state;
+static unsigned long requested_ip; /* = 0 */
+static unsigned long server_addr;
+static unsigned long timeout;
+/* 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 timeout;
+static uint32_t requested_ip; /* = 0 */
+static uint32_t server_addr;
 static int packet_num; /* = 0 */
 static int fd = -1;
+static int sockfd = -1;
 #define LISTEN_NONE 0
 #define LISTEN_KERNEL 1
 #define LISTEN_RAW 2
+static int listen_mode;
+struct client_config_t client_config = {
+    /* Default options. */
+    .abort_if_no_lease = 0,
+    .foreground = 0,
+    .quit_after_lease = 0,
+    .background_if_no_lease = 0,
+    .interface = "eth0",
+    .pidfile = NULL,
+    .script = DEFAULT_SCRIPT,
+    .clientid = NULL,
+    .vendorclass = NULL,
+    .hostname = NULL,
+    .fqdn = NULL,
+    .ifindex = 0,
+    .retries = 3,
+    .timeout = 3,
+    .arp = "\0\0\0\0\0\0",      /* appease gcc-3.0 */
+};
+static smallint listen_mode;
+static smallint state;
+struct client_config_t client_config;
 /* just a little helper */
 static void change_mode(int new_mode)
+{
     DEBUG(LOG_INFO, "entering %s listen mode",
+    DEBUG("entering %s listen mode",
         new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none");
+    if (fd >= 0) close(fd);
+    fd = -1;
+    if (sockfd >= 0) {
+        close(sockfd);
+        sockfd = -1;
+    }
     listen_mode = new_mode;
+}
 …
 static void perform_renew(void)
+{
     LOG(LOG_INFO, "Performing a DHCP renew");
+    bb_info_msg("Performing a DHCP renew");
     switch (state) {
     case BOUND:
 …
 static void perform_release(void)
+{
     char buffer[16];
+    char buffer[sizeof("255.255.255.255")];
     struct in_addr temp_addr;
 …
     if (state == BOUND || state == RENEWING || state == REBINDING) {
         temp_addr.s_addr = server_addr;
         sprintf(buffer, "%s", inet_ntoa(temp_addr));
+        strcpy(buffer, inet_ntoa(temp_addr));
         temp_addr.s_addr = requested_ip;
         LOG(LOG_INFO, "Unicasting a release of %s to %s",
+        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");
+    }
     LOG(LOG_INFO, "Entering released state");
+    bb_info_msg("Entering released state");
     change_mode(LISTEN_NONE);
     state = RELEASED;
     timeout = 0x7fffffff;
+    timeout = INT_MAX;
+}
 …
 static void client_background(void)
+{
+    udhcp_background(client_config.pidfile);
+    client_config.foreground = 1; /* Do not fork again. */
+#if !BB_MMU
+    bb_error_msg("cannot background in uclinux (yet)");
+/* ... mainly because udhcpc calls client_background()
+ * in _the _middle _of _udhcpc _run_, not at the start!
+ * If that will be properly disabled for NOMMU, client_background()
+ * will work on NOMMU too */
+#else
+    bb_daemonize(0);
+    logmode &= ~LOGMODE_STDIO;
+    /* rewrite pidfile, as our pid is different now */
+    write_pidfile(client_config.pidfile);
+#endif
+    /* Do not fork again. */
+    client_config.foreground = 1;
     client_config.background_if_no_lease = 0;
+}
+int udhcpc_main(int argc, char *argv[])
+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);
+int udhcpc_main(int argc, char **argv)
+{
     uint8_t *temp, *message;
+    unsigned long t1 = 0, t2 = 0, xid = 0;
+    unsigned long start = 0, lease;
+    char *str_c, *str_V, *str_h, *str_F, *str_r, *str_T, *str_t;
+    uint32_t xid = 0;
+    uint32_t lease = 0; /* can be given as 32-bit quantity */
+    unsigned t1 = 0, t2 = 0; /* what a wonderful names */
+    unsigned start = 0;
+    unsigned now;
+    unsigned opt;
+    int max_fd;
+    int retval;
+    int len;
+    struct timeval tv;
+    struct in_addr temp_addr;
+    struct dhcpMessage packet;
     fd_set rfds;
+    int retval;
+    struct timeval tv;
+    int c, len;
+    struct dhcpMessage packet;
+    struct in_addr temp_addr;
+    long now;
+    int max_fd;
+    int sig;
+    int no_clientid = 0;
+    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'},
+        {"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}
+    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,
+        OPT_S = 1 << 18,
     };
+    /* get options */
+    while (1) {
+        int option_index = 0;
+        c = getopt_long(argc, argv, "c:CV:fbH:h:F:i:np:qr:s:T:t:v", arg_options, &option_index);
+        if (c == -1) break;
+        switch (c) {
+        case 'c':
+            if (no_clientid) bb_show_usage();
+            len = strlen(optarg) > 255 ? 255 : strlen(optarg);
+            free(client_config.clientid);
+            client_config.clientid = xmalloc(len + 2);
+            client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
+            client_config.clientid[OPT_LEN] = len;
+            client_config.clientid[OPT_DATA] = '\0';
+            strncpy((char*)client_config.clientid + OPT_DATA, optarg, len);
+            break;
+        case 'C':
+            if (client_config.clientid) bb_show_usage();
+            no_clientid = 1;
+            break;
+        case 'V':
+            len = strlen(optarg) > 255 ? 255 : strlen(optarg);
+            free(client_config.vendorclass);
+            client_config.vendorclass = xmalloc(len + 2);
+            client_config.vendorclass[OPT_CODE] = DHCP_VENDOR;
+            client_config.vendorclass[OPT_LEN] = len;
+            strncpy((char*)client_config.vendorclass + OPT_DATA, optarg, len);
+            break;
+        case 'f':
+            client_config.foreground = 1;
+            break;
+        case 'b':
+            client_config.background_if_no_lease = 1;
+            break;
+        case 'h':
+        case 'H':
+            len = strlen(optarg) > 255 ? 255 : strlen(optarg);
+            free(client_config.hostname);
+            client_config.hostname = xmalloc(len + 2);
+            client_config.hostname[OPT_CODE] = DHCP_HOST_NAME;
+            client_config.hostname[OPT_LEN] = len;
+            strncpy((char*)client_config.hostname + 2, optarg, len);
+            break;
+        case 'F':
+            len = strlen(optarg) > 255 ? 255 : strlen(optarg);
+            free(client_config.fqdn);
+            client_config.fqdn = xmalloc(len + 5);
+            client_config.fqdn[OPT_CODE] = DHCP_FQDN;
+            client_config.fqdn[OPT_LEN] = len + 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_LEN + 1] = 0x1;
+            client_config.fqdn[OPT_LEN + 2] = 0;
+            client_config.fqdn[OPT_LEN + 3] = 0;
+            strncpy((char*)client_config.fqdn + 5, optarg, len);
+            break;
+        case 'i':
+            client_config.interface =  optarg;
+            break;
+        case 'n':
+            client_config.abort_if_no_lease = 1;
+            break;
+        case 'p':
+            client_config.pidfile = optarg;
+            break;
+        case 'q':
+            client_config.quit_after_lease = 1;
+            break;
+        case 'r':
+            requested_ip = inet_addr(optarg);
+            break;
+        case 's':
+            client_config.script = optarg;
+            break;
+        case 'T':
+            client_config.timeout = atoi(optarg);
+            break;
+        case 't':
+            client_config.retries = atoi(optarg);
+            break;
+        case 'v':
+            printf("version %s\n\n", BB_VER);
+            return 0;
+            break;
+        default:
+            bb_show_usage();
+        }
+    }
+    /* Start the log, sanitize fd's, and write a pid file */
+    udhcp_start_log_and_pid("udhcpc", client_config.pidfile);
+#if ENABLE_GETOPT_LONG
+    static const char udhcpc_longopts[] ALIGN1 =
+        "clientid\0"      Required_argument "c"
+        "clientid-none\0" No_argument       "C"
+        "vendorclass\0"   Required_argument "V"
+        "foreground\0"    No_argument       "f"
+        "background\0"    No_argument       "b"
+        "hostname\0"      Required_argument "H"
+        "hostname\0"      Required_argument "h"
+        "fqdn\0"          Required_argument "F"
+        "interface\0"     Required_argument "i"
+        "now\0"           No_argument       "n"
+        "pidfile\0"       Required_argument "p"
+        "quit\0"          No_argument       "q"
+        "release\0"       No_argument       "R"
+        "request\0"       Required_argument "r"
+        "script\0"        Required_argument "s"
+        "timeout\0"       Required_argument "T"
+        "version\0"       No_argument       "v"
+        "retries\0"       Required_argument "t"
+        "syslog\0"        No_argument       "S"
+        ;
+#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 = udhcpc_longopts;
+#endif
+    opt = getopt32(argv, "c:CV:fbH:h:F:i:np:qRr:s:T:t:vS",
+        &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)
+    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", BB_VER);
+        return 0;
+    }
+    if (opt & OPT_S) {
+        openlog(applet_name, LOG_PID, LOG_LOCAL0);
+        logmode |= LOGMODE_SYSLOG;
+    }
     if (read_interface(client_config.interface, &client_config.ifindex,
                NULL, client_config.arp) < 0)
+               NULL, client_config.arp))
         return 1;
+    /* Make sure fd 0,1,2 are open */
+    bb_sanitize_stdio();
+    /* Equivalent of doing a fflush after every \n */
+    setlinebuf(stdout);
+    /* Create pidfile */
+    write_pidfile(client_config.pidfile);
+    /* if (!..) bb_perror_msg("cannot create pidfile %s", pidfile); */
+    /* Goes to stdout and possibly syslog */
+    bb_info_msg("%s (v%s) started", applet_name, BB_VER);
     /* if not set, and not suppressed, setup the default client ID */
+    if (!client_config.clientid && !no_clientid) {
+        client_config.clientid = xmalloc(6 + 3);
+        client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
+        client_config.clientid[OPT_LEN] = 7;
+    if (!client_config.clientid && !(opt & OPT_C)) {
+        client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
         client_config.clientid[OPT_DATA] = 1;
+        memcpy(client_config.clientid + 3, client_config.arp, 6);
+    }
+    if (!client_config.vendorclass) {
+        client_config.vendorclass = xmalloc(sizeof("udhcp "BB_VER) + 2);
+        client_config.vendorclass[OPT_CODE] = DHCP_VENDOR;
+        client_config.vendorclass[OPT_LEN] = sizeof("udhcp "BB_VER) - 1;
+        client_config.vendorclass[OPT_DATA] = 1;
+        memcpy(&client_config.vendorclass[OPT_DATA],
+            "udhcp "BB_VER, sizeof("udhcp "BB_VER) - 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_run_script(NULL, "deconfig");
     change_mode(LISTEN_RAW);
+    tv.tv_sec = 0;
+    goto jump_in;
     for (;;) {
+        tv.tv_sec = timeout - uptime();
+        tv.tv_sec = timeout - monotonic_sec();
+ jump_in:
         tv.tv_usec = 0;
         if (listen_mode != LISTEN_NONE && fd < 0) {
+        if (listen_mode != LISTEN_NONE && sockfd < 0) {
             if (listen_mode == LISTEN_KERNEL)
                 fd = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface);
+                sockfd = listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface);
             else
+                fd = raw_socket(client_config.ifindex);
+            if (fd < 0) {
+                LOG(LOG_ERR, "FATAL: couldn't listen on socket, %m");
+                return 0;
+            }
+                sockfd = raw_socket(client_config.ifindex);
+        }
+        max_fd = udhcp_sp_fd_set(&rfds, fd);
+        max_fd = udhcp_sp_fd_set(&rfds, sockfd);
+        retval = 0; /* If we already timed out, fall through, else... */
         if (tv.tv_sec > 0) {
             DEBUG(LOG_INFO, "Waiting on select...");
+            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) {
+        }
+        now = monotonic_sec();
+        if (retval < 0) {
+            /* EINTR? signal was caught, don't panic */
+            if (errno != EINTR) {
+                /* Else: an error occured, panic! */
+                bb_perror_msg_and_die("select");
+            }
+        } else if (retval == 0) {
             /* timeout dropped to zero */
             switch (state) {
 …
                     udhcp_run_script(NULL, "leasefail");
                     if (client_config.background_if_no_lease) {
                         LOG(LOG_INFO, "No lease, forking to background.");
+                        bb_info_msg("No lease, forking to background");
                         client_background();
                     } else if (client_config.abort_if_no_lease) {
+                        LOG(LOG_INFO, "No lease, failing.");
+                        return 1;
+                        bb_info_msg("No lease, failing");
+                        retval = 1;
+                        goto ret;
+                    }
                     /* wait to try again */
 …
                 } else {
                     /* timed out, go back to init state */
+                    if (state == RENEW_REQUESTED) udhcp_run_script(NULL, "deconfig");
+                    if (state == RENEW_REQUESTED)
+                        udhcp_run_script(NULL, "deconfig");
                     state = INIT_SELECTING;
                     timeout = now;
 …
                 state = RENEWING;
                 change_mode(LISTEN_KERNEL);
                 DEBUG(LOG_INFO, "Entering renew state");
+                DEBUG("Entering renew state");
                 /* fall right through */
             case RENEWING:
 …
                     state = REBINDING;
                     timeout = now + (t2 - t1);
                     DEBUG(LOG_INFO, "Entering rebinding state");
+                    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;
+                    timeout = start + t1;
+                }
                 break;
 …
                     /* timed out, enter init state */
                     state = INIT_SELECTING;
                     LOG(LOG_INFO, "Lease lost, entering init state");
+                    bb_info_msg("Lease lost, entering init state");
                     udhcp_run_script(NULL, "deconfig");
                     timeout = now;
 …
                     /* send a request packet */
                     send_renew(xid, 0, requested_ip); /* broadcast */
                     t2 = (lease - t2) / 2 + t2;
                     timeout = t2 + start;
+                    timeout = start + t2;
+                }
                 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)) {
+                timeout = INT_MAX;
+                break;
+            }
+        } else if (listen_mode != LISTEN_NONE && FD_ISSET(sockfd, &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);
+                len = udhcp_get_packet(&packet, sockfd);
+            else len = get_raw_packet(&packet, sockfd);
             if (len == -1 && errno != EINTR) {
                 DEBUG(LOG_INFO, "error on read, %m, reopening socket");
+                DEBUG("error on read, %s, reopening socket", strerror(errno));
                 change_mode(listen_mode); /* just close and reopen */
+            }
 …
             if (packet.xid != xid) {
                 DEBUG(LOG_INFO, "Ignoring XID %lx (our xid is %lx)",
                     (unsigned long) packet.xid, xid);
+                DEBUG("Ignoring XID %x (our xid is %x)",
+                    (unsigned)packet.xid, (unsigned)xid);
                 continue;
+            }
 …
             /* Ignore packets that aren't for us */
             if (memcmp(packet.chaddr, client_config.arp, 6)) {
                 DEBUG(LOG_INFO, "packet does not have our chaddr -- ignoring");
+                DEBUG("Packet does not have our chaddr - ignoring");
                 continue;
+            }
+            if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
+                DEBUG(LOG_ERR, "couldnt get option from packet -- ignoring");
+            message = get_option(&packet, DHCP_MESSAGE_TYPE);
+            if (message == NULL) {
+                bb_error_msg("cannot get option from packet - ignoring");
                 continue;
+            }
 …
                 /* Must be a DHCPOFFER to one of our xid's */
                 if (*message == DHCPOFFER) {
+                    if ((temp = get_option(&packet, DHCP_SERVER_ID))) {
+                    temp = get_option(&packet, DHCP_SERVER_ID);
+                    if (temp) {
+                        /* can be misaligned, thus memcpy */
                         memcpy(&server_addr, temp, 4);
                         xid = packet.xid;
 …
                         packet_num = 0;
                     } else {
                         DEBUG(LOG_ERR, "No server ID in message");
+                        bb_error_msg("no server ID in message");
+                    }
+                }
 …
             case REBINDING:
                 if (*message == DHCPACK) {
+                    if (!(temp = get_option(&packet, DHCP_LEASE_TIME))) {
+                        LOG(LOG_ERR, "No lease time with ACK, using 1 hour lease");
+                    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 {
+                        /* can be misaligned, thus memcpy */
                         memcpy(&lease, temp, 4);
                         lease = ntohl(lease);
 …
                     /* little fixed point for n * .875 */
                     t2 = (lease * 0x7) >> 3;
+                    t2 = (lease * 7) >> 3;
                     temp_addr.s_addr = packet.yiaddr;
                     LOG(LOG_INFO, "Lease of %s obtained, lease time %ld",
                         inet_ntoa(temp_addr), lease);
+                    bb_info_msg("Lease of %s obtained, lease time %u",
+                        inet_ntoa(temp_addr), (unsigned)lease);
                     start = now;
                     timeout = t1 + start;
+                    timeout = start + t1;
                     requested_ip = packet.yiaddr;
                     udhcp_run_script(&packet,
 …
                     state = BOUND;
                     change_mode(LISTEN_NONE);
+                    if (client_config.quit_after_lease)
+                        return 0;
+                    if (client_config.quit_after_lease) {
+                        if (client_config.release_on_quit)
+                            perform_release();
+                        goto ret0;
+                    }
                     if (!client_config.foreground)
                         client_background();
 …
                 } else if (*message == DHCPNAK) {
                     /* return to init state */
                     LOG(LOG_INFO, "Received DHCP NAK");
+                    bb_info_msg("Received DHCP NAK");
                     udhcp_run_script(&packet, "nak");
                     if (state != REQUESTING)
 …
             /* case BOUND, RELEASED: - ignore all packets */
+            }
+        } else if (retval > 0 && (sig = udhcp_sp_read(&rfds))) {
+            switch (sig) {
+        } else {
+            int signo = udhcp_sp_read(&rfds);
+            switch (signo) {
             case SIGUSR1:
                 perform_renew();
 …
                 break;
             case SIGTERM:
+                LOG(LOG_INFO, "Received SIGTERM");
+                return 0;
+            }
+        } else if (retval == -1 && errno == EINTR) {
+            /* a signal was caught */
+        } else {
+            /* An error occured */
+            DEBUG(LOG_ERR, "Error on select");
+                bb_info_msg("Received SIGTERM");
+                if (client_config.release_on_quit)
+                    perform_release();
+                goto ret0;
+            }
+        }
+    }
+    return 0;
+    } /* for (;;) */
+ ret0:
+    retval = 0;
+ ret:
+    /*if (client_config.pidfile) - remove_pidfile has it's own check */
+        remove_pidfile(client_config.pidfile);
+    return retval;
+}

branches/stable/mindi-busybox/networking/udhcp/dhcpc.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* dhcpc.h */
 #ifndef _DHCPC_H
 #define _DHCPC_H
-/* grab define DEFAULT_SCRIPT */
-#include "libbb_udhcp.h"
 #define INIT_SELECTING  0
 …
 #define RELEASED    7
 struct client_config_t {
+    char foreground;        /* Do not fork */
+    char quit_after_lease;      /* Quit after obtaining lease */
+    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 */
+    /* 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 */
+    const char *interface;          /* The name of the interface to use */
+    char *pidfile;                  /* Optionally store the process ID */
+    const 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 */
 };
 …
+/*** clientpacket.h ***/
+uint32_t random_xid(void);
+int send_discover(uint32_t xid, uint32_t requested);
+int send_selecting(uint32_t xid, uint32_t server, uint32_t requested);
+int send_renew(uint32_t xid, uint32_t server, uint32_t ciaddr);
+int send_renew(uint32_t xid, uint32_t server, uint32_t ciaddr);
+int send_release(uint32_t server, uint32_t ciaddr);
+int get_raw_packet(struct dhcpMessage *payload, int fd);
 #endif

branches/stable/mindi-busybox/networking/udhcp/dhcpd.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* dhcpd.c
+ *
 …
  */
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <syslog.h>
+#include "common.h"
 #include "dhcpd.h"
-#include "arpping.h"
-#include "socket.h"
 #include "options.h"
-#include "files.h"
-#include "serverpacket.h"
-#include "common.h"
-#include "signalpipe.h"
-#include "static_leases.h"
 …
+int udhcpd_main(int argc, char *argv[])
+int udhcpd_main(int argc, char **argv);
+int udhcpd_main(int argc, char **argv)
+{
     fd_set rfds;
 …
     uint8_t *state, *server_id, *requested;
     uint32_t server_id_align, requested_align, static_lease_ip;
+    unsigned long timeout_end, num_ips;
+    unsigned timeout_end;
+    unsigned num_ips;
+    unsigned opt;
     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("udhcpd", server_config.pidfile);
+    if ((option = find_option(server_config.options, DHCP_LEASE_TIME))) {
+    opt = getopt32(argv, "fS");
+    argv += optind;
+    if (!(opt & 1)) { /* no -f */
+        bb_daemonize_or_rexec(0, argv);
+        logmode &= ~LOGMODE_STDIO;
+    }
+    if (opt & 2) { /* -S */
+        openlog(applet_name, LOG_PID, LOG_LOCAL0);
+        logmode |= LOGMODE_SYSLOG;
+    }
+    /* Would rather not do read_config before daemonization -
+     * otherwise NOMMU machines will parse config twice */
+    read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
+    /* Make sure fd 0,1,2 are open */
+    bb_sanitize_stdio();
+    /* Equivalent of doing a fflush after every \n */
+    setlinebuf(stdout);
+    /* Create pidfile */
+    write_pidfile(server_config.pidfile);
+    /* if (!..) bb_perror_msg("cannot create pidfile %s", pidfile); */
+    bb_info_msg("%s (v%s) started", applet_name, BB_VER);
+    option = find_option(server_config.options, DHCP_LEASE_TIME);
+    server_config.lease = LEASE_TIME;
+    if (option) {
         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;
+    num_ips = server_config.end_ip - server_config.start_ip + 1;
     if (server_config.max_leases > num_ips) {
+        LOG(LOG_ERR, "max_leases value (%lu) not sane, "
+            "setting to %lu instead",
+            server_config.max_leases, num_ips);
+        bb_error_msg("max_leases=%u is too big, setting to %u",
+            (unsigned)server_config.max_leases, num_ips);
         server_config.max_leases = num_ips;
+    }
     leases = xzalloc(server_config.max_leases * sizeof(struct dhcpOfferedAddr));
+    leases = xzalloc(server_config.max_leases * sizeof(*leases));
     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. */
+               &server_config.server, server_config.arp)) {
+        retval = 1;
+        goto ret;
+    }
     /* 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)
+            if ((server_socket = listen_socket(INADDR_ANY, SERVER_PORT, server_config.interface)) < 0) {
+                LOG(LOG_ERR, "FATAL: couldn't create server socket, %m");
+                return 2;
+            }
+    timeout_end = monotonic_sec() + 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);
+        }
         max_sock = udhcp_sp_fd_set(&rfds, server_socket);
         if (server_config.auto_time) {
             tv.tv_sec = timeout_end - time(0);
+            tv.tv_sec = timeout_end - monotonic_sec();
             tv.tv_usec = 0;
+        }
+        retval = 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(LOG_INFO, "error on select");
+            timeout_end = monotonic_sec() + server_config.auto_time;
+            continue;
+        }
+        if (retval < 0 && errno != EINTR) {
+            DEBUG("error on select");
             continue;
+        }
 …
         switch (udhcp_sp_read(&rfds)) {
         case SIGUSR1:
             LOG(LOG_INFO, "Received a SIGUSR1");
+            bb_info_msg("Received a SIGUSR1");
             write_leases();
             /* why not just reset the timeout, eh */
             timeout_end = time(0) + server_config.auto_time;
+            timeout_end = monotonic_sec() + server_config.auto_time;
             continue;
         case SIGTERM:
             LOG(LOG_INFO, "Received a SIGTERM");
             return 0;
+            bb_info_msg("Received a SIGTERM");
+            goto ret0;
         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 */
+        bytes = udhcp_get_packet(&packet, server_socket); /* this waits for a packet - idle */
+        if (bytes < 0) {
             if (bytes == -1 && errno != EINTR) {
                 DEBUG(LOG_INFO, "error on read, %m, reopening socket");
+                DEBUG("error on read, %s, reopening socket", strerror(errno));
                 close(server_socket);
                 server_socket = -1;
 …
+        }
+        if ((state = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
+            DEBUG(LOG_ERR, "couldn't get option from packet, ignoring");
+        state = get_option(&packet, DHCP_MESSAGE_TYPE);
+        if (state == NULL) {
+            bb_error_msg("cannot get option from packet, ignoring");
             continue;
+        }
 …
         static_lease_ip = getIpByMac(server_config.static_leases, &packet.chaddr);
+        if(static_lease_ip)
+        {
+            printf("Found static lease: %x\n", static_lease_ip);
+        if (static_lease_ip) {
+            bb_info_msg("Found static lease: %x", static_lease_ip);
             memcpy(&static_lease.chaddr, &packet.chaddr, 16);
 …
             lease = &static_lease;
+        }
+        else
+        {
+        lease = find_lease_by_chaddr(packet.chaddr);
+        } else {
+            lease = find_lease_by_chaddr(packet.chaddr);
+        }
         switch (state[0]) {
         case DHCPDISCOVER:
             DEBUG(LOG_INFO,"received DISCOVER");
+            DEBUG("Received DISCOVER");
             if (sendOffer(&packet) < 0) {
                 LOG(LOG_ERR, "send OFFER failed");
+                bb_error_msg("send OFFER failed");
+            }
             break;
         case DHCPREQUEST:
             DEBUG(LOG_INFO, "received REQUEST");
+            DEBUG("received REQUEST");
             requested = get_option(&packet, DHCP_REQUESTED_IP);
 …
                 if (server_id) {
                     /* SELECTING State */
+                    DEBUG(LOG_INFO, "server_id = %08x", ntohl(server_id_align));
+                    if (server_id_align == server_config.server && requested &&
+                        requested_align == lease->yiaddr) {
+                    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 if (lease->yiaddr == packet.ciaddr) {
+                    /* RENEWING or REBINDING State */
+                    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);
+                        }
+                    }
+                    /* don't know what to do!!!! */
+                    sendNAK(&packet);
+                }
 …
             } else if (requested) {
                 /* INIT-REBOOT State */
+                if ((lease = find_lease_by_yiaddr(requested_align))) {
+                lease = find_lease_by_yiaddr(requested_align);
+                if (lease) {
                     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
+                        sendNAK(&packet);
+                } else {
+                    uint32_t r = ntohl(requested_align);
+                    if (r < server_config.start_ip
+                         || r > server_config.end_ip
+                    ) {
+                        sendNAK(&packet);
+                    }
+                    /* else remain silent */
+                }
             } else {
                  /* RENEWING or REBINDING State */
+                /* RENEWING or REBINDING State */
+            }
             break;
         case DHCPDECLINE:
             DEBUG(LOG_INFO,"received DECLINE");
+            DEBUG("Received DECLINE");
             if (lease) {
                 memset(lease->chaddr, 0, 16);
 …
             break;
         case DHCPRELEASE:
+            DEBUG(LOG_INFO,"received RELEASE");
+            if (lease) lease->expires = time(0);
+            DEBUG("Received RELEASE");
+            if (lease)
+                lease->expires = time(0);
             break;
         case DHCPINFORM:
             DEBUG(LOG_INFO,"received INFORM");
+            DEBUG("Received INFORM");
             send_inform(&packet);
             break;
         default:
+            LOG(LOG_WARNING, "unsupported DHCP message (%02x) -- ignoring", state[0]);
+        }
+    }
+    return 0;
+            bb_info_msg("Unsupported DHCP message (%02x) - ignoring", state[0]);
+        }
+    }
+ ret0:
+    retval = 0;
+ ret:
+    /*if (server_config.pidfile) - server_config.pidfile is never NULL */
+        remove_pidfile(server_config.pidfile);
+    return retval;
+}

branches/stable/mindi-busybox/networking/udhcp/dhcpd.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* dhcpd.h */
 #ifndef _DHCPD_H
 #define _DHCPD_H
-#include <netinet/ip.h>
-#include <netinet/udp.h>
-#include "libbb_udhcp.h"
-#include "leases.h"
 /************************************/
 …
 #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 static_lease {
+    struct static_lease *next;
     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*/
+    uint32_t server;                /* Our IP, in network order */
+    /* start,end are in host order: we need to compare start <= ip <= end */
+    uint32_t start_ip;              /* Start address of leases, in host order */
+    uint32_t end_ip;                /* End of leases, in host 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 */
+    char remaining;                 /* should the lease file be interpreted as lease time remaining, or
+                                     * as the time the lease expires */
+    uint32_t lease;                 /* lease time in seconds (host order) */
+    uint32_t max_leases;            /* maximum number of leases (including reserved address) */
+    uint32_t auto_time;             /* how long should udhcpd wait before writing a config file.
+                                     * if this is zero, it will only write one on SIGUSR1 */
+    uint32_t decline_time;          /* how long an address is reserved if a client returns a
+                                     * decline message */
+    uint32_t conflict_time;         /* how long an arp conflict offender is leased for */
+    uint32_t offer_time;            /* how long an offered address is reserved */
+    uint32_t 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 */
+    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 */
 };
 …
+/*** leases.h ***/
+struct dhcpOfferedAddr {
+    uint8_t chaddr[16];
+    uint32_t yiaddr;    /* network order */
+    uint32_t expires;   /* host order */
+};
+struct dhcpOfferedAddr *add_lease(const uint8_t *chaddr, uint32_t yiaddr, unsigned long lease);
+int lease_expired(struct dhcpOfferedAddr *lease);
+struct dhcpOfferedAddr *find_lease_by_chaddr(const 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 ***/
+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

branches/stable/mindi-busybox/networking/udhcp/dumpleases.c

-              r821
+              r1770
  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  */
-#include <fcntl.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/wait.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <stdio.h>
-#include <sys/socket.h>
-#include <unistd.h>
 #include <getopt.h>
-#include <time.h>
+#include "common.h"
 #include "dhcpd.h"
-#include "leases.h"
-#include "libbb_udhcp.h"
+#define REMAINING 0
+#define ABSOLUTE 1
+#ifndef IN_BUSYBOX
+static void ATTRIBUTE_NORETURN show_usage(void)
+int dumpleases_main(int argc, char **argv);
+int dumpleases_main(int argc, char **argv)
+{
+    printf(
+"Usage: dumpleases -f <file> -[r|a]\n\n"
+"  -f, --file=FILENAME             Leases file to load\n"
+"  -r, --remaining                 Interepret lease times as time remaining\n"
+"  -a, --absolute                  Interepret lease times as expire time\n");
+    exit(0);
+}
+#else
+#define show_usage bb_show_usage
+#endif
+#ifdef IN_BUSYBOX
+int dumpleases_main(int argc, char *argv[])
+#else
+int main(int argc, char *argv[])
+#endif
+{
+    FILE *fp;
+    int i, c, mode = REMAINING;
+    long expires;
+    int fd;
+    int i;
+    unsigned opt;
+    time_t 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}
+    enum {
+        OPT_a   = 0x1,  // -a
+        OPT_r   = 0x2,  // -r
+        OPT_f   = 0x4,  // -f
     };
+#if ENABLE_GETOPT_LONG
+    static const char dumpleases_longopts[] ALIGN1 =
+        "absolute\0"  No_argument       "a"
+        "remaining\0" No_argument       "r"
+        "file\0"      Required_argument "f"
+        ;
     while (1) {
+        int option_index = 0;
         c = getopt_long(argc, argv, "arf:", options, &option_index);
         if (c == -1) break;
+    applet_long_options = dumpleases_longopts;
+#endif
+    opt_complementary = "=0:a--r:r--a";
+    opt = getopt32(argv, "arf:", &file);
+        switch (c) {
+        case 'a': mode = ABSOLUTE; break;
+        case 'r': mode = REMAINING; break;
+        case 'f':
+            file = optarg;
+            break;
+        default:
+            show_usage();
+        }
+    }
+    fd = xopen(file, O_RDONLY);
+    fp = xfopen(file, "r");
+    printf("Mac Address       IP-Address      Expires %s\n", mode == REMAINING ? "in" : "at");
+    printf("Mac Address       IP-Address      Expires %s\n", (opt & OPT_a) ? "at" : "in");
     /*     "00:00:00:00:00:00 255.255.255.255 Wed Jun 30 21:49:08 1993" */
+    while (fread(&lease, sizeof(lease), 1, fp)) {
+        for (i = 0; i < 6; i++) {
+            printf("%02x", lease.chaddr[i]);
+            if (i != 5) printf(":");
+    while (full_read(fd, &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));
+        printf(" %-15s ", inet_ntoa(addr));
         expires = ntohl(lease.expires);
         printf(" ");
         if (mode == REMAINING) {
             if (!expires) printf("expired\n");
+        if (!(opt & OPT_a)) { /* no -a */
+            if (!expires)
+                puts("expired");
             else {
+                if (expires > 60*60*24) {
+                    printf("%ld days, ", expires / (60*60*24));
+                    expires %= 60*60*24;
+                }
+                if (expires > 60*60) {
+                    printf("%ld hours, ", expires / (60*60));
+                    expires %= 60*60;
+                }
+                if (expires > 60) {
+                    printf("%ld minutes, ", expires / 60);
+                    expires %= 60;
+                }
+                printf("%ld seconds\n", expires);
+                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 printf("%s", ctime(&expires));
+        } else /* -a */
+            fputs(ctime(&expires), stdout);
+    }
     fclose(fp);
+    /* close(fd); */
     return 0;

branches/stable/mindi-busybox/networking/udhcp/files.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * files.c -- DHCP server file manipulation *
 …
  */
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <string.h>
-#include <stdlib.h>
-#include <time.h>
-#include <ctype.h>
-#include <netdb.h>
 #include <netinet/ether.h>
+#include "static_leases.h"
+#include "common.h"
 #include "dhcpd.h"
 #include "options.h"
+#include "files.h"
+#include "common.h"
+/* on these functions, make sure your datatype matches */
+static int read_ip(const char *line, void *arg)
+{
+    len_and_sockaddr *lsa;
+    lsa = host_and_af2sockaddr(line, 0, AF_INET);
+    if (!lsa)
+        return 0;
+    *(uint32_t*)arg = lsa->sin.sin_addr.s_addr;
+    free(lsa);
+    return 1;
+}
+static int read_mac(const char *line, void *arg)
+{
+    uint8_t *mac_bytes = arg;
+    struct ether_addr *temp_ether_addr;
+    temp_ether_addr = ether_aton(line);
+    if (temp_ether_addr == NULL)
+        return 0;
+    memcpy(mac_bytes, temp_ether_addr, 6);
+    return 1;
+}
+static int read_str(const char *line, void *arg)
+{
+    char **dest = arg;
+    free(*dest);
+    *dest = xstrdup(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;
+    if (!strcasecmp("yes", line)) {
+        *dest = 1;
+        return 1;
+    }
+    if (!strcasecmp("no", line)) {
+        *dest = 0;
+        return 1;
+    }
+    return 0;
+}
+/* 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;
+    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;
+    existing = find_option(*opt_list, option->code);
+    if (!existing) {
+        DEBUG("Attaching option %s to list", option->name);
+#if ENABLE_FEATURE_RFC3397
+        if ((option->flags & TYPE_MASK) == OPTION_STR1035)
+            /* reuse buffer and length for RFC1035-formatted string */
+            buffer = dname_enc(NULL, 0, buffer, &length);
+#endif
+        /* make a new option */
+        new = xmalloc(sizeof(*new));
+        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;
+#if ENABLE_FEATURE_RFC3397
+        if ((option->flags & TYPE_MASK) == OPTION_STR1035 && buffer != NULL)
+            free(buffer);
+#endif
+        return;
+    }
+    /* add it to an existing option */
+    DEBUG("Attaching option %s to existing member of list", option->name);
+    if (option->flags & OPTION_LIST) {
+#if ENABLE_FEATURE_RFC3397
+        if ((option->flags & TYPE_MASK) == OPTION_STR1035)
+            /* reuse buffer and length for RFC1035-formatted string */
+            buffer = dname_enc(existing->data + 2,
+                    existing->data[OPT_LEN], buffer, &length);
+#endif
+        if (existing->data[OPT_LEN] + length <= 255) {
+            existing->data = xrealloc(existing->data,
+                    existing->data[OPT_LEN] + length + 3);
+            if ((option->flags & TYPE_MASK) == OPTION_STRING) {
+                /* ' ' can bring us to 256 - bad */
+                if (existing->data[OPT_LEN] + length >= 255)
+                    return;
+                /* add space separator between STRING options in a list */
+                existing->data[existing->data[OPT_LEN] + 2] = ' ';
+                existing->data[OPT_LEN]++;
+            }
+            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 */
+#if ENABLE_FEATURE_RFC3397
+        if ((option->flags & TYPE_MASK) == OPTION_STR1035 && buffer != NULL)
+            free(buffer);
+#endif
+    } /* else, ignore the new data */
+}
+/* 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);
+            val = strtok(NULL, ", \t/-");
+            if (!val)
+                retval = 0;
+            if (retval)
+                retval = read_ip(val, buffer + 4);
+            break;
+        case OPTION_STRING:
+#if ENABLE_FEATURE_RFC3397
+        case OPTION_STR1035:
+#endif
+            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;
+        /* htonX are macros in older libc's, using temp var
+         * in code below for safety */
+        /* TODO: use bb_strtoX? */
+        case OPTION_U16: {
+            unsigned long tmp = strtoul(val, &endptr, 0);
+            *result_u16 = htons(tmp);
+            retval = (endptr[0] == '\0' /*&& tmp < 0x10000*/);
+            break;
+        }
+        case OPTION_S16: {
+            long tmp = strtol(val, &endptr, 0);
+            *result_u16 = htons(tmp);
+            retval = (endptr[0] == '\0');
+            break;
+        }
+        case OPTION_U32: {
+            unsigned long tmp = strtoul(val, &endptr, 0);
+            *result_u32 = htonl(tmp);
+            retval = (endptr[0] == '\0');
+            break;
+        }
+        case OPTION_S32: {
+            long tmp = strtol(val, &endptr, 0);
+            *result_u32 = htonl(tmp);
+            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;
+}
+struct config_keyword {
+    const char *keyword;
+    int (*handler)(const char *line, void *var);
+    void *var;
+    const char *def;
+};
+static const struct config_keyword keywords[] = {
+    /* keyword       handler   variable address               default */
+    {"start",        read_ip,  &(server_config.start_ip),     "192.168.0.20"},
+    {"end",          read_ip,  &(server_config.end_ip),       "192.168.0.254"},
+    {"interface",    read_str, &(server_config.interface),    "eth0"},
+    {"option",       read_opt, &(server_config.options),      ""},
+    {"opt",          read_opt, &(server_config.options),      ""},
+    /* Avoid "max_leases value not sane" warning by setting default
+     * to default_end_ip - default_start_ip + 1: */
+    {"max_leases",   read_u32, &(server_config.max_leases),   "235"},
+    {"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 */
+};
 /*
 …
 #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)) {
-        if ((host = gethostbyname(line)))
-            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 *dest = arg;
-    char *endptr;
-    *dest = strtoul(line, &endptr, 0);
-    return endptr[0] == '\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, struct dhcp_option *option, char *buffer, int length)
+{
-    struct option_set *existing, *new, **curr;
-    /* add it to an existing option */
-    if ((existing = find_option(*opt_list, option->code))) {
-        DEBUG(LOG_INFO, "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(LOG_INFO, "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;
-    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;
-    if (!(opt = strtok(line, " \t="))) return 0;
-    for (option = dhcp_options; option->code; option++)
-        if (!strcasecmp(option->name, opt))
-            break;
-    if (!option->code) return 0;
-    do {
-        if (!(val = strtok(NULL, ", \t"))) 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)
+{
 …
     int i, lm = 0;
     for (i = 0; keywords[i].keyword[0]; i++)
+    for (i = 0; i < ARRAY_SIZE(keywords); i++)
         if (keywords[i].def[0])
             keywords[i].handler(keywords[i].def, keywords[i].var);
     if (!(in = fopen(file, "r"))) {
         LOG(LOG_ERR, "unable to open config file: %s", file);
+    in = fopen_or_warn(file, "r");
+    if (!in) {
         return 0;
+    }
 …
     while (fgets(buffer, READ_CONFIG_BUF_SIZE, in)) {
         char debug_orig[READ_CONFIG_BUF_SIZE];
+        char *p;
         lm++;
+        if (strchr(buffer, '\n')) *(strchr(buffer, '\n')) = '\0';
+        p = strchr(buffer, '\n');
+        if (p) *p = '\0';
         if (ENABLE_FEATURE_UDHCP_DEBUG) strcpy(debug_orig, buffer);
+        if (strchr(buffer, '#')) *(strchr(buffer, '#')) = '\0';
+        p = strchr(buffer, '#');
+        if (p) *p = '\0';
         if (!(token = strtok(buffer, " \t"))) continue;
 …
         /* eat leading whitespace */
         line = line + strspn(line, " \t=");
+        line = skip_whitespace(line);
         /* eat trailing whitespace */
+        for (i = strlen(line); i > 0 && isspace(line[i - 1]); i--);
+        line[i] = '\0';
+        for (i = 0; keywords[i].keyword[0]; i++)
+        i = strlen(line) - 1;
+        while (i >= 0 && isspace(line[i]))
+            line[i--] = '\0';
+        for (i = 0; i < ARRAY_SIZE(keywords); i++)
             if (!strcasecmp(token, keywords[i].keyword))
                 if (!keywords[i].handler(line, keywords[i].var)) {
+                    LOG(LOG_ERR, "Failure parsing line %d of %s", lm, file);
+                    DEBUG(LOG_ERR, "unable to parse '%s'", debug_orig);
+                    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);
+    server_config.start_ip = ntohl(server_config.start_ip);
+    server_config.end_ip = ntohl(server_config.end_ip);
     return 1;
+}
 …
 void write_leases(void)
+{
+    FILE *fp;
+    unsigned int i;
+    char buf[255];
+    int fp;
+    unsigned i;
     time_t curr = time(0);
     unsigned long tmp_time;
     if (!(fp = fopen(server_config.lease_file, "w"))) {
         LOG(LOG_ERR, "Unable to open %s for writing", server_config.lease_file);
+    fp = open3_or_warn(server_config.lease_file, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+    if (fp < 0) {
         return;
+    }
 …
             } /* else stick with the time we got */
             leases[i].expires = htonl(leases[i].expires);
+            fwrite(&leases[i], sizeof(struct dhcpOfferedAddr), 1, fp);
+            /* Then restore it when done. */
+            // FIXME: error check??
+            full_write(fp, &leases[i], sizeof(leases[i]));
+            /* then restore it when done */
             leases[i].expires = tmp_time;
+        }
+    }
     fclose(fp);
+    close(fp);
     if (server_config.notify_file) {
+        sprintf(buf, "%s %s", server_config.notify_file, server_config.lease_file);
+        system(buf);
+        char *cmd = xasprintf("%s %s", server_config.notify_file, server_config.lease_file);
+        system(cmd);
+        free(cmd);
+    }
+}
 …
 void read_leases(const char *file)
+{
     FILE *fp;
+    int fp;
     unsigned int i = 0;
     struct dhcpOfferedAddr lease;
     if (!(fp = fopen(file, "r"))) {
         LOG(LOG_ERR, "Unable to open %s for reading", file);
+    fp = open_or_warn(file, O_RDONLY);
+    if (fp < 0) {
         return;
+    }
+    while (i < server_config.max_leases && (fread(&lease, sizeof lease, 1, fp) == 1)) {
+    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) {
+        uint32_t y = ntohl(lease.yiaddr);
+        if (y >= server_config.start_ip && y <= server_config.end_ip) {
             lease.expires = ntohl(lease.expires);
+            if (!server_config.remaining) lease.expires -= time(0);
+            if (!server_config.remaining)
+                lease.expires -= time(0);
             if (!(add_lease(lease.chaddr, lease.yiaddr, lease.expires))) {
                 LOG(LOG_WARNING, "Too many leases while loading %s\n", file);
+                bb_error_msg("too many leases while loading %s", file);
                 break;
+            }
 …
+        }
+    }
     DEBUG(LOG_INFO, "Read %d leases", i);
     fclose(fp);
+}
+    DEBUG("Read %d leases", i);
+    close(fp);
+}

branches/stable/mindi-busybox/networking/udhcp/leases.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * leases.c -- tools to manage DHCP leases
 …
  */
+#include <time.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "common.h"
 #include "dhcpd.h"
-#include "files.h"
-#include "options.h"
-#include "leases.h"
-#include "arpping.h"
-#include "common.h"
-#include "static_leases.h"
+uint8_t blank_chaddr[] = {[0 ... 15] = 0};
+/* Find the oldest expired lease, NULL if there are no expired leases */
+static struct dhcpOfferedAddr *oldest_expired_lease(void)
+{
+    struct dhcpOfferedAddr *oldest = NULL;
+// TODO: use monotonic_sec()
+    unsigned long oldest_lease = time(0);
+    unsigned 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;
+}
 /* clear every lease out that chaddr OR yiaddr matches and is nonzero */
 void clear_lease(uint8_t *chaddr, uint32_t yiaddr)
+static void clear_lease(const uint8_t *chaddr, uint32_t yiaddr)
+{
     unsigned int i, j;
+    unsigned i, j;
+    for (j = 0; j < 16 && !chaddr[j]; j++);
+    for (j = 0; j < 16 && !chaddr[j]; j++)
+        continue;
     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));
+        if ((j != 16 && memcmp(leases[i].chaddr, chaddr, 16) == 0)
+         || (yiaddr && leases[i].yiaddr == yiaddr)
+        ) {
+            memset(&(leases[i]), 0, sizeof(leases[i]));
+        }
+}
 …
 /* 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 *add_lease(const uint8_t *chaddr, uint32_t yiaddr, unsigned long lease)
+{
     struct dhcpOfferedAddr *oldest;
 …
 /* Find the oldest expired lease, NULL if there are no expired leases */
 struct dhcpOfferedAddr *oldest_expired_lease(void)
+/* Find the first lease that matches chaddr, NULL if no match */
+struct dhcpOfferedAddr *find_lease_by_chaddr(const uint8_t *chaddr)
+{
+    struct dhcpOfferedAddr *oldest = NULL;
+    unsigned long oldest_lease = time(0);
+    unsigned int i;
+    unsigned 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]);
+        if (!memcmp(leases[i].chaddr, chaddr, 16))
+            return &(leases[i]);
     return NULL;
 …
 struct dhcpOfferedAddr *find_lease_by_yiaddr(uint32_t yiaddr)
+{
     unsigned int i;
+    unsigned i;
     for (i = 0; i < server_config.max_leases; i++)
+        if (leases[i].yiaddr == yiaddr) return &(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)
+static int nobody_responds_to_arp(uint32_t addr)
+{
+    static const uint8_t blank_chaddr[16]; /* 16 zero bytes */
     struct in_addr temp;
+    int r;
+    if (arpping(addr, server_config.server, server_config.arp, server_config.interface) == 0) {
+        temp.s_addr = addr;
+        LOG(LOG_INFO, "%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;
+    r = arpping(addr, server_config.server, server_config.arp, server_config.interface);
+    if (r)
+        return r;
+    temp.s_addr = addr;
+    bb_info_msg("%s belongs to someone, reserving it for %u seconds",
+        inet_ntoa(temp), (unsigned)server_config.conflict_time);
+    add_lease(blank_chaddr, addr, server_config.conflict_time);
+    return 0;
+}
 /* find an assignable address, it check_expired is true, we check all the expired leases as well.
+/* find an assignable address, if 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)
 …
     struct dhcpOfferedAddr *lease = NULL;
+    addr = ntohl(server_config.start); /* addr is in host order here */
+    for (;addr <= ntohl(server_config.end); addr++) {
+    addr = server_config.start_ip; /* addr is in host order here */
+    for (; addr <= server_config.end_ip; addr++) {
         /* ie, 192.168.55.0 */
         if (!(addr & 0xFF)) continue;
+        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 */
+        if ((addr & 0xFF) == 0xFF)
+            continue;
+        /* Only do if it isn't assigned as a static lease */
         ret = htonl(addr);
         if ((!(lease = find_lease_by_yiaddr(ret)) ||
              /* or it expired and we are checking for expired leases */
              (check_expired  && lease_expired(lease))) &&
              /* and it isn't on the network */
              !check_ip(ret)) {
             return ret;
             break;
+        if (!reservedIp(server_config.static_leases, ret)) {
+            /* lease is not taken */
+            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)))
+             && nobody_responds_to_arp(ret) /* it isn't used on the network */
+            ) {
+                return ret;
+            }
+        }
+    }
+    }
     return 0;

branches/stable/mindi-busybox/networking/udhcp/options.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * options.c -- DHCP server option packet tools
 …
  */
-#include <stdlib.h>
-#include <string.h>
 #include "common.h"
 #include "dhcpd.h"
 #include "options.h"
-#include "files.h"
 /* supported options are easily added here */
+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},
+    {"tftp",    OPTION_STRING,              0x42},
+    {"bootfile",    OPTION_STRING,              0x43},
+    {"",        0x00,               0x00}
+const struct dhcp_option dhcp_options[] = {
+    /* name[12]     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_LIST | 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},
+#if ENABLE_FEATURE_RFC3397
+    {"search",      OPTION_STR1035 | OPTION_LIST | OPTION_REQ, 0x77},
+#endif
+    /* MSIE's "Web Proxy Autodiscovery Protocol" support */
+    {"wpad",        OPTION_STRING,                          0xfc},
+    {"",            0x00,                                   0x00}
 };
 /* Lengths of the different option types */
+int 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
+const unsigned char option_lengths[] ALIGN1 = {
+    [OPTION_IP] =      4,
+    [OPTION_IP_PAIR] = 8,
+    [OPTION_BOOLEAN] = 1,
+    [OPTION_STRING] =  1,
+#if ENABLE_FEATURE_RFC3397
+    [OPTION_STR1035] = 1,
+#endif
+    [OPTION_U8] =      1,
+    [OPTION_U16] =     2,
+    [OPTION_S16] =     2,
+    [OPTION_U32] =     4,
+    [OPTION_S32] =     4
 };
 …
     while (!done) {
         if (i >= length) {
             LOG(LOG_WARNING, "bogus packet, option fields too long.");
+            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) {
                 LOG(LOG_WARNING, "bogus packet, option fields too long.");
+                bb_error_msg("bogus packet, option fields too long");
                 return NULL;
+            }
 …
         case DHCP_OPTION_OVER:
             if (i + 1 + optionptr[i + OPT_LEN] >= length) {
                 LOG(LOG_WARNING, "bogus packet, option fields too long.");
+                bb_error_msg("bogus packet, option fields too long");
                 return NULL;
+            }
 …
     /* end position + string length + option code/length + end option */
     if (end + string[OPT_LEN] + 2 + 1 >= 308) {
+        LOG(LOG_ERR, "Option 0x%02x did not fit into the packet!", string[OPT_CODE]);
+        bb_error_msg("option 0x%02x did not fit into the packet",
+                string[OPT_CODE]);
         return 0;
+    }
     DEBUG(LOG_INFO, "adding option 0x%02x", string[OPT_CODE]);
+    DEBUG("adding option 0x%02x", string[OPT_CODE]);
     memcpy(optionptr + end, string, string[OPT_LEN] + 2);
     optionptr[end + string[OPT_LEN] + 2] = DHCP_END;
 …
 int add_simple_option(uint8_t *optionptr, uint8_t code, uint32_t data)
+{
     struct dhcp_option *dh;
+    const struct dhcp_option *dh;
     for (dh=dhcp_options; dh->code; dh++) {
+    for (dh = dhcp_options; dh->code; dh++) {
         if (dh->code == code) {
             uint8_t option[6], len;
 …
+    }
     DEBUG(LOG_ERR, "Could not add option 0x%02x", code);
+    bb_error_msg("cannot add option 0x%02x", code);
     return 0;
+}

branches/stable/mindi-busybox/networking/udhcp/options.h

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* options.h */
 #ifndef _OPTIONS_H
 #define _OPTIONS_H
-#include "packet.h"
 #define TYPE_MASK   0x0F
 …
     OPTION_IP_PAIR,
     OPTION_STRING,
+#if ENABLE_FEATURE_RFC3397
+    OPTION_STR1035, /* RFC1035 compressed domain name list */
+#endif
     OPTION_BOOLEAN,
     OPTION_U8,
 …
 #define OPTION_LIST 0x20 /* There can be a list of 1 or more of these */
+/*****************************************************************/
+/* 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 OPT_CODE 0
+#define OPT_LEN 1
+#define OPT_DATA 2
 struct dhcp_option {
     char name[10];
+    char name[12];
     char flags;
     uint8_t code;
 };
 extern struct dhcp_option dhcp_options[];
 extern int option_lengths[];
+extern const struct dhcp_option dhcp_options[];
+extern const unsigned char option_lengths[];
 uint8_t *get_option(struct dhcpMessage *packet, int code);
 …
 int add_option_string(uint8_t *optionptr, uint8_t *string);
 int add_simple_option(uint8_t *optionptr, uint8_t code, uint32_t data);
+#if ENABLE_FEATURE_RFC3397
+char *dname_dec(const uint8_t *cstr, int clen, const char *pre);
+uint8_t *dname_enc(const uint8_t *cstr, int clen, const char *src, int *retlen);
+#endif
 #endif

branches/stable/mindi-busybox/networking/udhcp/packet.c

-              r821
+              r1770
+#include <unistd.h>
+#include <string.h>
+/* vi: set sw=4 ts=4: */
 #include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <features.h>
+#if (__GLIBC__ >= 2 && __GLIBC_MINOR >= 1) || defined _NEWLIB_VERSION
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 …
 #include <linux/if_ether.h>
 #endif
-#include <errno.h>
 #include "common.h"
-#include "packet.h"
 #include "dhcpd.h"
 #include "options.h"
 …
 int udhcp_get_packet(struct dhcpMessage *packet, int fd)
+{
+#if 0
     static const char broken_vendors[][8] = {
         "MSFT 98",
         ""
     };
+#endif
     int bytes;
+    int i;
+    char unsigned *vendor;
+    memset(packet, 0, sizeof(struct dhcpMessage));
+    bytes = read(fd, packet, sizeof(struct dhcpMessage));
+    unsigned char *vendor;
+    memset(packet, 0, sizeof(*packet));
+    bytes = read(fd, packet, sizeof(*packet));
     if (bytes < 0) {
         DEBUG(LOG_INFO, "couldn't read on listening socket, ignoring");
+        DEBUG("cannot read on listening socket, ignoring");
         return -1;
+    }
     if (ntohl(packet->cookie) != DHCP_MAGIC) {
         LOG(LOG_ERR, "received bogus message, ignoring");
+        bb_error_msg("received bogus message, ignoring");
         return -2;
+    }
+    DEBUG(LOG_INFO, "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(LOG_INFO, "broken client (%s), forcing broadcast",
+                    broken_vendors[i]);
+    DEBUG("Received a packet");
+    if (packet->op == BOOTREQUEST) {
+        vendor = get_option(packet, DHCP_VENDOR);
+        if (vendor) {
+#if 0
+            int i;
+            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);
+                }
+            }
+#else
+            if (vendor[OPT_LEN - 2] == (uint8_t)(sizeof("MSFT 98")-1)
+             && memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0
+            ) {
+                DEBUG("broken client (%s), forcing broadcast", "MSFT 98");
                 packet->flags |= htons(BROADCAST_FLAG);
+            }
+#endif
+        }
+    }
 …
      *         beginning at location "addr".
      */
     register int32_t sum = 0;
+    int32_t sum = 0;
     uint16_t *source = (uint16_t *) addr;
 …
 /* Construct a ip/udp header for a packet, and specify the source and dest hardware address */
+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)
+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, const uint8_t *dest_arp, int ifindex)
+{
     int fd;
 …
     struct udp_dhcp_packet packet;
+    if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
+        DEBUG(LOG_ERR, "socket call failed: %m");
+    fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+    if (fd < 0) {
+        bb_perror_msg("socket");
         return -1;
+    }
 …
     memcpy(dest.sll_addr, dest_arp, 6);
     if (bind(fd, (struct sockaddr *)&dest, sizeof(struct sockaddr_ll)) < 0) {
         DEBUG(LOG_ERR, "bind call failed: %m");
+        bb_perror_msg("bind");
         close(fd);
         return -1;
 …
     packet.ip.check = udhcp_checksum(&(packet.ip), sizeof(packet.ip));
+    result = sendto(fd, &packet, sizeof(struct udp_dhcp_packet), 0, (struct sockaddr *) &dest, sizeof(dest));
+    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) {
         DEBUG(LOG_ERR, "write on socket failed: %m");
+        bb_perror_msg("sendto");
+    }
     close(fd);
 …
 /* 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 n = 1;
+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;
+    if ((fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
+        return -1;
+    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n)) == -1) {
+        close(fd);
+        return -1;
+    }
+    fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (fd < 0)
+        return -1;
+    setsockopt_reuseaddr(fd);
     memset(&client, 0, sizeof(client));
 …
     client.sin_addr.s_addr = source_ip;
     if (bind(fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1) {
+    if (bind(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
         close(fd);
         return -1;

branches/stable/mindi-busybox/networking/udhcp/script.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* script.c
+ *
 …
  */
-#include <string.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/types.h>
-#include <sys/wait.h>
 #include "common.h"
+#include "dhcpc.h"
 #include "options.h"
+#include "dhcpd.h"
+#include "dhcpc.h"
 /* get a rough idea of how long an option will be (rounding up...) */
 static const int max_option_length[] = {
+static const uint8_t max_option_length[] = {
     [OPTION_IP] =       sizeof("255.255.255.255 "),
     [OPTION_IP_PAIR] =  sizeof("255.255.255.255 ") * 2,
     [OPTION_STRING] =   1,
+#if ENABLE_FEATURE_RFC3397
+    [OPTION_STR1035] =  1,
+#endif
     [OPTION_BOOLEAN] =  sizeof("yes "),
     [OPTION_U8] =       sizeof("255 "),
 …
 static int sprintip(char *dest, char *pre, uint8_t *ip)
+static int sprintip(char *dest, const char *pre, const uint8_t *ip)
+{
     return sprintf(dest, "%s%d.%d.%d.%d", pre, ip[0], ip[1], ip[2], ip[3]);
 …
 /* Fill dest with the text of option 'option'. */
 static void fill_options(char *dest, uint8_t *option, struct dhcp_option *type_p)
+{
     int type, optlen;
+/* Allocate and fill with the text of option 'option'. */
+static char *alloc_fill_opts(uint8_t *option, const struct dhcp_option *type_p)
+{
+    int len, 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);
+    char *dest, *ret;
+    len = option[OPT_LEN - 2];
     type = type_p->flags & TYPE_MASK;
     optlen = option_lengths[type];
+    for(;;) {
+    dest = ret = xmalloc(upper_length(len, type) + strlen(type_p->name) + 2);
+    dest += sprintf(ret, "%s=", type_p->name);
+    for (;;) {
         switch (type) {
         case OPTION_IP_PAIR:
             dest += sprintip(dest, "", option);
             *(dest++) = '/';
+            *dest++ = '/';
             option += 4;
             optlen = 4;
 …
             memcpy(dest, option, len);
             dest[len] = '\0';
+            return;  /* Short circuit this case */
+            return ret;  /* Short circuit this case */
+#if ENABLE_FEATURE_RFC3397
+        case OPTION_STR1035:
+            /* unpack option into dest; use ret for prefix (i.e., "optname=") */
+            dest = dname_dec(option, len, ret);
+            free(ret);
+            return dest;
+#endif
+        }
         option += optlen;
 …
         dest += sprintf(dest, " ");
+    }
+    return ret;
+}
 …
     int i, j;
     char **envp;
+    char *var;
     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 (packet) {
+        for (i = 0; dhcp_options[i].code; i++) {
             if (get_option(packet, dhcp_options[i].code)) {
                 num_options++;
 …
                     num_options++; /* for mton */
+            }
+        if (packet->siaddr) num_options++;
+        if ((temp = get_option(packet, DHCP_OPTION_OVER)))
+        }
+        if (packet->siaddr)
+            num_options++;
+        temp = get_option(packet, DHCP_OPTION_OVER);
+        if (temp)
             over = *temp;
+        if (!(over & FILE_FIELD) && packet->file[0]) num_options++;
+        if (!(over & SNAME_FIELD) && packet->sname[0]) num_options++;
+        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++] = bb_xasprintf("interface=%s", client_config.interface);
+    envp[j++] = bb_xasprintf("PATH=%s",
+        getenv("PATH") ? : "/bin:/usr/bin:/sbin:/usr/sbin");
+    envp[j++] = bb_xasprintf("HOME=%s", getenv("HOME") ? : "/");
+    if (packet == NULL) return envp;
+    envp[j++] = xasprintf("interface=%s", client_config.interface);
+    var = getenv("PATH");
+    if (var)
+        envp[j++] = xasprintf("PATH=%s", var);
+    var = getenv("HOME");
+    if (var)
+        envp[j++] = xasprintf("HOME=%s", var);
+    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++) {
+        if (!(temp = get_option(packet, dhcp_options[i].code)))
+        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]);
+        envp[j++] = alloc_fill_opts(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++] = bb_xasprintf("mask=%d", mton(&subnet));
+            envp[j++] = xasprintf("mask=%d", mton(&subnet));
+        }
+    }
 …
         /* watch out for invalid packets */
         packet->file[sizeof(packet->file) - 1] = '\0';
         envp[j++] = bb_xasprintf("boot_file=%s", packet->file);
+        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++] = bb_xasprintf("sname=%s", packet->sname);
+        envp[j++] = xasprintf("sname=%s", packet->sname);
+    }
     return envp;
 …
         return;
     DEBUG(LOG_INFO, "vforking and execle'ing %s", client_config.script);
+    DEBUG("vfork'ing and execle'ing %s", client_config.script);
     envp = fill_envp(packet);
     /* call script */
+// can we use wait4pid(spawn(...)) here?
     pid = vfork();
+    if (pid) {
+        waitpid(pid, NULL, 0);
+        for (curr = envp; *curr; curr++) free(*curr);
+        free(envp);
+        return;
+    } else if (pid == 0) {
+    if (pid < 0) return;
+    if (pid == 0) {
         /* close fd's? */
         /* exec script */
         execle(client_config.script, client_config.script,
                name, NULL, envp);
+        LOG(LOG_ERR, "script %s failed: %m", client_config.script);
+        exit(1);
+    }
+}
+        bb_perror_msg_and_die("script %s failed", client_config.script);
+    }
+    waitpid(pid, NULL, 0);
+    for (curr = envp; *curr; curr++)
+        free(*curr);
+    free(envp);
+}

branches/stable/mindi-busybox/networking/udhcp/serverpacket.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* serverpacket.c
+ *
 …
  */
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <string.h>
-#include <time.h>
 #include "common.h"
-#include "serverpacket.h"
 #include "dhcpd.h"
 #include "options.h"
+#include "static_leases.h"
 /* send a packet to giaddr using the kernel ip stack */
 static int send_packet_to_relay(struct dhcpMessage *payload)
+{
     DEBUG(LOG_INFO, "Forwarding packet to relay");
+    DEBUG("Forwarding packet to relay");
     return udhcp_kernel_packet(payload, server_config.server, SERVER_PORT,
 …
 static int send_packet_to_client(struct dhcpMessage *payload, int force_broadcast)
+{
     uint8_t *chaddr;
+    const uint8_t *chaddr;
     uint32_t ciaddr;
     if (force_broadcast) {
         DEBUG(LOG_INFO, "broadcasting packet to client (NAK)");
+        DEBUG("broadcasting packet to client (NAK)");
         ciaddr = INADDR_BROADCAST;
         chaddr = MAC_BCAST_ADDR;
     } else if (payload->ciaddr) {
         DEBUG(LOG_INFO, "unicasting packet to client ciaddr");
+        DEBUG("unicasting packet to client ciaddr");
         ciaddr = payload->ciaddr;
         chaddr = payload->chaddr;
     } else if (ntohs(payload->flags) & BROADCAST_FLAG) {
         DEBUG(LOG_INFO, "broadcasting packet to client (requested)");
+        DEBUG("broadcasting packet to client (requested)");
         ciaddr = INADDR_BROADCAST;
         chaddr = MAC_BCAST_ADDR;
     } else {
         DEBUG(LOG_INFO, "unicasting packet to client yiaddr");
+        DEBUG("unicasting packet to client yiaddr");
         ciaddr = payload->yiaddr;
         chaddr = payload->chaddr;
 …
     /* ADDME: if static, short circuit */
+    if(!static_lease_ip)
+    {
+    /* the client is in our lease/offered table */
+    if ((lease = find_lease_by_chaddr(oldpacket->chaddr))) {
+        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? */
+    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) >= server_config.start_ip
+         && ntohl(req_align) <= server_config.end_ip
+         && !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 {
-            /* 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) {
-        LOG(LOG_WARNING, "no IP addresses to give -- OFFER abandoned");
-        return -1;
+    }
-    if (!add_lease(packet.chaddr, packet.yiaddr, server_config.offer_time)) {
-        LOG(LOG_WARNING, "lease pool is full -- OFFER abandoned");
-        return -1;
+    }
-    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;
+    }
-    /* 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;
 …
     addr.s_addr = packet.yiaddr;
     LOG(LOG_INFO, "sending OFFER of %s", inet_ntoa(addr));
+    bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
     return send_packet(&packet, 0);
+}
 …
     init_packet(&packet, oldpacket, DHCPNAK);
     DEBUG(LOG_INFO, "sending NAK");
+    DEBUG("Sending NAK");
     return send_packet(&packet, 1);
+}
 …
     packet.yiaddr = yiaddr;
+    if ((lease_time = get_option(oldpacket, DHCP_LEASE_TIME))) {
+    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);
 …
     addr.s_addr = packet.yiaddr;
     LOG(LOG_INFO, "sending ACK to %s", inet_ntoa(addr));
+    bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
     if (send_packet(&packet, 0) < 0)
 …
     add_lease(packet.chaddr, packet.yiaddr, lease_time_align);
+    if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
+        /* rewrite the file with leases at every new acceptance */
+        write_leases();
+    }
     return 0;

branches/stable/mindi-busybox/networking/udhcp/signalpipe.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /* signalpipe.c
+ *
 …
  */
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include "common.h"
-#include "signalpipe.h"
-#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)
+        DEBUG(LOG_ERR, "Could not send signal: %m");
+    unsigned char ch = sig; /* use char, avoid dealing with partial writes */
+    if (write(signal_pipe[1], &ch, 1) != 1)
+        bb_perror_msg("cannot send signal");
+}
 …
 void udhcp_sp_setup(void)
+{
+    socketpair(AF_UNIX, SOCK_STREAM, 0, signal_pipe);
+    /* was socketpair, but it needs AF_UNIX in kernel */
+    xpipe(signal_pipe);
     fcntl(signal_pipe[0], F_SETFD, FD_CLOEXEC);
     fcntl(signal_pipe[1], F_SETFD, FD_CLOEXEC);
+    fcntl(signal_pipe[1], F_SETFL, O_NONBLOCK);
     signal(SIGUSR1, signal_handler);
     signal(SIGUSR2, signal_handler);
 …
 int udhcp_sp_read(fd_set *rfds)
+{
     int sig;
+    unsigned char sig;
     if (!FD_ISSET(signal_pipe[0], rfds))
         return 0;
     if (read(signal_pipe[0], &sig, sizeof(sig)) < 0)
+    if (read(signal_pipe[0], &sig, 1) != 1)
         return -1;

branches/stable/mindi-busybox/networking/udhcp/socket.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * socket.c -- DHCP server client/server socket creation
 …
  */
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#include <string.h>
-#include <arpa/inet.h>
 #include <net/if.h>
-#include <errno.h>
 #include <features.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR >= 1) || defined _NEWLIB_VERSION
+#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
 #include <netpacket/packet.h>
 #include <net/ethernet.h>
 …
 #include "common.h"
-#include "socket.h"
+int read_interface(char *interface, int *ifindex, uint32_t *addr, uint8_t *arp)
+int read_interface(const char *interface, int *ifindex, uint32_t *addr, uint8_t *arp)
+{
     int fd;
 …
     struct sockaddr_in *our_ip;
+    memset(&ifr, 0, sizeof(struct ifreq));
+    if((fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) >= 0) {
+        ifr.ifr_addr.sa_family = AF_INET;
+        strcpy(ifr.ifr_name, interface);
+    memset(&ifr, 0, sizeof(ifr));
+    fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+        if (addr) {
+            if (ioctl(fd, SIOCGIFADDR, &ifr) == 0) {
+                our_ip = (struct sockaddr_in *) &ifr.ifr_addr;
+                *addr = our_ip->sin_addr.s_addr;
+                DEBUG(LOG_INFO, "%s (our ip) = %s", ifr.ifr_name, inet_ntoa(our_ip->sin_addr));
+            } else {
+                LOG(LOG_ERR, "SIOCGIFADDR failed, is the interface up and configured?: %m");
+                close(fd);
+                return -1;
+            }
+        }
+        if (ioctl(fd, SIOCGIFINDEX, &ifr) == 0) {
+            DEBUG(LOG_INFO, "adapter index %d", ifr.ifr_ifindex);
+            *ifindex = ifr.ifr_ifindex;
+        } else {
+            LOG(LOG_ERR, "SIOCGIFINDEX failed!: %m");
+    ifr.ifr_addr.sa_family = AF_INET;
+    strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
+    if (addr) {
+        if (ioctl_or_perror(fd, SIOCGIFADDR, &ifr,
+            "is interface %s up and configured?", interface)
+        ) {
             close(fd);
             return -1;
+        }
+        if (ioctl(fd, SIOCGIFHWADDR, &ifr) == 0) {
+            memcpy(arp, ifr.ifr_hwaddr.sa_data, 6);
+            DEBUG(LOG_INFO, "adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x",
+                arp[0], arp[1], arp[2], arp[3], arp[4], arp[5]);
+        } else {
+            LOG(LOG_ERR, "SIOCGIFHWADDR failed!: %m");
+        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_or_warn(fd, SIOCGIFINDEX, &ifr) != 0) {
             close(fd);
             return -1;
+        }
+    } else {
+        LOG(LOG_ERR, "socket failed!: %m");
+        return -1;
+        DEBUG("adapter index %d", ifr.ifr_ifindex);
+        *ifindex = ifr.ifr_ifindex;
+    }
+    if (arp) {
+        if (ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr) != 0) {
+            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]);
+    }
     close(fd);
     return 0;
+}
+/* 1. None of the callers expects it to ever fail */
+/* 2. ip was always INADDR_ANY */
+int listen_socket(/*uint32_t ip,*/ int port, const char *inf)
+{
+    int fd;
+    struct ifreq interface;
+    struct sockaddr_in addr;
+int listen_socket(uint32_t ip, int port, char *inf)
+{
+    struct ifreq interface;
+    int fd;
+    struct sockaddr_in addr;
+    int n = 1;
+    DEBUG("Opening listen socket on *:%d %s", port, inf);
+    fd = xsocket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    DEBUG(LOG_INFO, "Opening listen socket on 0x%08x:%d %s", ip, port, inf);
+    if ((fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+        DEBUG(LOG_ERR, "socket call failed: %m");
+        return -1;
+    }
+    setsockopt_reuseaddr(fd);
+    if (setsockopt_broadcast(fd) == -1)
+        bb_perror_msg_and_die("SO_BROADCAST");
+    strncpy(interface.ifr_name, inf, IFNAMSIZ);
+    if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &interface, sizeof(interface)) == -1)
+        bb_perror_msg_and_die("SO_BINDTODEVICE");
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = ip;
+    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n)) == -1) {
+        close(fd);
+        return -1;
+    }
+    if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *) &n, sizeof(n)) == -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;
+    }
+    /* addr.sin_addr.s_addr = ip; - all-zeros is INADDR_ANY */
+    xbind(fd, (struct sockaddr *)&addr, sizeof(addr));
     return fd;

branches/stable/mindi-busybox/networking/udhcp/static_leases.c

-              r821
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * static_leases.c -- Couple of functions to assist with storing and
 …
  */
+#include "common.h"
+#include "dhcpd.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "static_leases.h"
-#include "dhcpd.h"
 /* Takes the address of the pointer to the static_leases linked list,
 …
 int addStaticLease(struct static_lease **lease_struct, uint8_t *mac, uint32_t *ip)
+{
     struct static_lease *cur;
     struct static_lease *new_static_lease;
 …
     /* If it's the first node to be added... */
+    if(*lease_struct == NULL)
+    {
+    if (*lease_struct == NULL) {
         *lease_struct = new_static_lease;
+    }
+    else
+    {
+    } else {
         cur = *lease_struct;
+        while(cur->next != NULL)
+        {
+        while (cur->next) {
             cur = cur->next;
+        }
 …
     return 1;
+}
 …
     return_ip = 0;
+    while(cur != NULL)
+    {
+    while (cur) {
         /* If the client has the correct mac  */
+        if(memcmp(cur->mac, mac, 6) == 0)
+        {
+        if (memcmp(cur->mac, mac, 6) == 0) {
             return_ip = *(cur->ip);
+        }
 …
     return return_ip;
+}
 …
     uint32_t return_val = 0;
+    while(cur != NULL)
+    {
+    while (cur) {
         /* If the client has the correct ip  */
         if(*cur->ip == ip)
+        if (*cur->ip == ip)
             return_val = 1;
 …
     return return_val;
+}
 #ifdef CONFIG_FEATURE_UDHCP_DEBUG
+#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 */
 …
     struct static_lease *cur = *arg;
+    while(cur != NULL)
+    {
+    while (cur) {
         /* printf("PrintStaticLeases: Lease mac Address: %x\n", cur->mac); */
         printf("PrintStaticLeases: Lease mac Value: %x\n", *(cur->mac));
 …
         cur = cur->next;
+    }
+}
 #endif

branches/stable/mindi-busybox/networking/vconfig.c

-              r821
+              r1770
 /* BB_AUDIT SUSv3 N/A */
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include "libbb.h"
 #include <net/if.h>
-#include <string.h>
-#include <limits.h>
-#include "busybox.h"
 /* Stuff from linux/if_vlan.h, kernel version 2.4.23 */
 …
+}
 static const char cmds[] = {
+static const char cmds[] ALIGN1 = {
 , ADD_VLAN_CMD, 7,
     'a', 'd', 'd', 0,
 …
     'n', 'a', 'm', 'e', '_',
     't', 'y', 'p', 'e', 0,
 , SET_VLAN_FLAG_CMD, 12,
+, SET_VLAN_FLAG_CMD, 12,
     's', 'e', 't', '_',
     'f', 'l', 'a', 'g', 0,
 …
 };
 static const char name_types[] = {
+static const char name_types[] ALIGN1 = {
     VLAN_NAME_TYPE_PLUS_VID, 16,
     'V', 'L', 'A', 'N',
 …
 };
 static const char conf_file_name[] = "/proc/net/vlan/config";
+static const char conf_file_name[] ALIGN1 = "/proc/net/vlan/config";
+int vconfig_main(int argc, char **argv);
 int vconfig_main(int argc, char **argv)
+{
 …
     /* Don't bother closing the filedes.  It will be closed on cleanup. */
     /* Will die if 802.1q is not present */
     bb_xopen3(conf_file_name, O_RDONLY, 0);
+    xopen(conf_file_name, O_RDONLY);
     memset(&ifr, 0, sizeof(struct vlan_ioctl_args));
 …
     } else {
         if (strlen(argv[1]) >= IF_NAMESIZE) {
             bb_error_msg_and_die("if_name >= %d chars\n", IF_NAMESIZE);
+            bb_error_msg_and_die("if_name >= %d chars", IF_NAMESIZE);
+        }
         strcpy(ifr.device1, argv[1]);
 …
          * more of a pain. */
         if (ifr.cmd == SET_VLAN_FLAG_CMD) { /* set_flag */
+            ifr.u.flag = bb_xgetularg10_bnd(p, 0, 1);
+            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 = bb_xgetularg10_bnd(p, 0, VLAN_GROUP_ARRAY_LEN-1);
+            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 = bb_xgetularg10_bnd(p, 0, ULONG_MAX);
             ifr.vlan_qos = bb_xgetularg10_bnd(argv[3], 0, 7);
+            ifr.u.skb_priority = xatou(p);
+            ifr.vlan_qos = xatoul_range(argv[3], 0, 7);
+        }
+    }
+    fd = bb_xsocket(AF_INET, SOCK_STREAM, 0);
+    if (ioctl(fd, SIOCSIFVLAN, &ifr) < 0) {
+        bb_perror_msg_and_die("ioctl error for %s", *argv);
+    }
+    fd = xsocket(AF_INET, SOCK_STREAM, 0);
+    ioctl_or_perror_and_die(fd, SIOCSIFVLAN, &ifr,
+                        "ioctl error for %s", *argv);
     return 0;
+}

branches/stable/mindi-busybox/networking/wget.c

-              r821
+              r1770
  */
+#include "busybox.h"
+#include <errno.h>
+#include <signal.h>
+#include <sys/ioctl.h>
 #include <getopt.h>
+/* We want libc to give us xxx64 functions also */
+/* http://www.unix.org/version2/whatsnew/lfs20mar.html */
+//#define _LARGEFILE64_SOURCE 1
+#include <getopt.h> /* for struct option */
+#include "libbb.h"
 struct host_info {
+    // May be used if we ever will want to free() all xstrdup()s...
+    /* char *allocated; */
     char *host;
     int port;
 …
 static void parse_url(char *url, struct host_info *h);
 static FILE *open_socket(struct sockaddr_in *s_in);
+static FILE *open_socket(len_and_sockaddr *lsa);
 static char *gethdr(char *buf, size_t bufsiz, FILE *fp, int *istrunc);
 static int ftpcmd(char *s1, char *s2, FILE *fp, char *buf);
+static int ftpcmd(const char *s1, const char *s2, FILE *fp, char *buf);
 /* Globals (can be accessed from signal handlers */
+static off_t filesize;      /* content-length of the file */
+static int chunked;     /* chunked transfer encoding */
+#ifdef CONFIG_FEATURE_WGET_STATUSBAR
+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 bool 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. */
+static off_t transferred;   /* Number of bytes transferred so far. */
+/* For progressmeter() -- number of seconds before xfer considered "stalled" */
+static const char *curfile;             /* Name of current file being transferred */
 enum {
     STALLTIME = 5
+    STALLTIME = 5                   /* Seconds when xfer considered "stalled" */
 };
 #else
+static inline void progressmeter(int flag) {}
+#endif
+static void close_and_delete_outfile(FILE* output, char *fname_out, int do_continue)
+{
+    if (output != stdout && do_continue==0) {
+        fclose(output);
+        unlink(fname_out);
+    }
+}
+/* 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;
+static ALWAYS_INLINE void progressmeter(int flag) {}
+#endif
+/* Read NMEMB bytes into PTR from STREAM.  Returns the number of bytes read,
+ * and a short count if an eof or non-interrupt error is encountered.  */
+static size_t safe_fread(void *ptr, size_t nmemb, FILE *stream)
+{
+    size_t ret;
+    char *p = (char*)ptr;
     do {
         clearerr(stream);
+        ret += fread((char *)ptr + (ret * size), size, nmemb - ret, stream);
+    } while (ret < nmemb && ferror(stream) && errno == EINTR);
+    return ret;
+}
+/* Write NMEMB elements of SIZE bytes from PTR to STREAM.  Returns the
+ * number of elements written, and a short count if an eof or non-interrupt
+ * error is encountered.  */
+static size_t safe_fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+    size_t ret = 0;
+    do {
+        clearerr(stream);
+        ret += fwrite((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.
+        ret = fread(p, 1, nmemb, stream);
+        p += ret;
+        nmemb -= ret;
+    } while (nmemb && ferror(stream) && errno == EINTR);
+    return p - (char*)ptr;
+}
+/* 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)
 …
+}
+#define close_delete_and_die(s...) { \
+    close_and_delete_outfile(output, fname_out, do_continue); \
+    bb_error_msg_and_die(s); }
+#ifdef CONFIG_FEATURE_WGET_AUTHENTICATION
+/*
+ *  Base64-encode character string
+ *  oops... isn't something similar in uuencode.c?
+ *  XXX: It would be better to use already existing code
+ */
+static char *base64enc(unsigned char *p, char *buf, int len) {
+    char al[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+            "0123456789+/";
+    char *s = buf;
+    while(*p) {
+        if (s >= buf+len-4)
+            bb_error_msg_and_die("buffer overflow");
+        *(s++) = al[(*p >> 2) & 0x3F];
+        *(s++) = al[((*p << 4) & 0x30) | ((*(p+1) >> 4) & 0x0F)];
+        *s = *(s+1) = '=';
+        *(s+2) = 0;
+        if (! *(++p)) break;
+        *(s++) = al[((*p << 2) & 0x3C) | ((*(p+1) >> 6) & 0x03)];
+        if (! *(++p)) break;
+        *(s++) = al[*(p++) & 0x3F];
+    }
+#if ENABLE_FEATURE_WGET_AUTHENTICATION
+/* Base64-encode character string. buf is assumed to be char buf[512]. */
+static char *base64enc_512(char buf[512], const char *str)
+{
+    unsigned len = strlen(str);
+    if (len > 512/4*3 - 10) /* paranoia */
+        len = 512/4*3 - 10;
+    bb_uuencode(buf, str, len, bb_uuenc_tbl_base64);
     return buf;
+}
 #endif
+#define WGET_OPT_CONTINUE   1
+#define WGET_OPT_QUIET  2
+#define WGET_OPT_PASSIVE    4
+#define WGET_OPT_OUTNAME    8
+#define WGET_OPT_HEADER 16
+#define WGET_OPT_PREFIX 32
+#define WGET_OPT_PROXY  64
+#if ENABLE_WGET_LONG_OPTIONS
+static const struct option wget_long_options[] = {
+    { "continue",        0, NULL, 'c' },
+    { "quiet",           0, NULL, 'q' },
+    { "passive-ftp",     0, NULL, 139 },
+    { "output-document", 1, NULL, 'O' },
+    { "header",          1, NULL, 131 },
+    { "directory-prefix",1, NULL, 'P' },
+    { "proxy",           1, NULL, 'Y' },
+    { 0,                 0, 0, 0 }
+};
+#endif
+int wget_main(int argc, char **argv);
 int wget_main(int argc, char **argv)
+{
+    int n, try=5, status;
+    unsigned long opt;
+    char buf[512];
+    struct host_info server, target;
+    len_and_sockaddr *lsa;
+    int n, status;
     int port;
+    int try = 5;
+    unsigned opt;
+    char *str;
     char *proxy = 0;
+    char *dir_prefix=NULL;
+    char *s, buf[512];
+    struct stat sbuf;
+    char extra_headers[1024];
+    char *extra_headers_ptr = extra_headers;
+    int extra_headers_left = sizeof(extra_headers);
+    struct host_info server, target;
+    struct sockaddr_in s_in;
+    char *dir_prefix = NULL;
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    char *extra_headers = NULL;
     llist_t *headers_llist = 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 do_continue = 0;        /* continue a prev transfer (-c)    */
+    long beg_range = 0L;        /*   range at which continue begins */
+    int got_clen = 0;       /* got content-length: from server  */
+    FILE *output;           /* socket to web server         */
+    int quiet_flag = FALSE;     /* Be verry, verry quiet...     */
+    int use_proxy = 1;      /* Use proxies if env vars are set  */
+    char *proxy_flag = "on";    /* Use proxies if env vars are set  */
+    /*
+     * Crack command line.
+     */
+    bb_opt_complementally = "-1:\203::";
+#if ENABLE_WGET_LONG_OPTIONS
+    bb_applet_long_options = wget_long_options;
+#endif
+    opt = bb_getopt_ulflags(argc, argv, "cq\213O:\203:P:Y:",
+                    &fname_out, &headers_llist,
+                    &dir_prefix, &proxy_flag);
+    if (opt & WGET_OPT_CONTINUE) {
+        ++do_continue;
+    }
+    if (opt & WGET_OPT_QUIET) {
+        quiet_flag = TRUE;
+    }
+#endif
+    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)      */
+    bool got_clen = 0;              /* got content-length: from server  */
+    int output_fd = -1;
+    bool 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";/* "User-Agent" header field        */
+    static const char keywords[] ALIGN1 =
+        "content-length\0""transfer-encoding\0""chunked\0""location\0";
+    enum {
+        KEY_content_length = 1, KEY_transfer_encoding, KEY_chunked, KEY_location
+    };
+    enum {
+        WGET_OPT_CONTINUE   = 0x1,
+        WGET_OPT_SPIDER     = 0x2,
+        WGET_OPT_QUIET      = 0x4,
+        WGET_OPT_OUTNAME    = 0x8,
+        WGET_OPT_PREFIX     = 0x10,
+        WGET_OPT_PROXY      = 0x20,
+        WGET_OPT_USER_AGENT = 0x40,
+        WGET_OPT_PASSIVE    = 0x80,
+        WGET_OPT_HEADER     = 0x100,
+    };
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    static const char wget_longopts[] ALIGN1 =
+        /* name, has_arg, val */
+        "continue\0"         No_argument       "c"
+        "spider\0"           No_argument       "s"
+        "quiet\0"            No_argument       "q"
+        "output-document\0"  Required_argument "O"
+        "directory-prefix\0" Required_argument "P"
+        "proxy\0"            Required_argument "Y"
+        "user-agent\0"       Required_argument "U"
+        "passive-ftp\0"      No_argument       "\xff"
+        "header\0"           Required_argument "\xfe"
+        ;
+    applet_long_options = wget_longopts;
+#endif
+    /* server.allocated = target.allocated = NULL; */
+    opt_complementary = "-1" USE_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
+    opt = getopt32(argv, "csqO: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 the proxy if necessary */
         use_proxy = 0;
+    }
+    if (opt & WGET_OPT_HEADER) {
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    if (headers_llist) {
+        int size = 1;
+        char *cp;
+        llist_t *ll = headers_llist;
+        while (ll) {
+            size += strlen(ll->data) + 2;
+            ll = ll->link;
+        }
+        extra_headers = cp = xmalloc(size);
         while (headers_llist) {
+            int arglen = strlen(headers_llist->data);
+            if (extra_headers_left - arglen - 2 <= 0)
+                bb_error_msg_and_die("extra_headers buffer too small(need %i)", extra_headers_left - arglen);
+            strcpy(extra_headers_ptr, headers_llist->data);
+            extra_headers_ptr += arglen;
+            extra_headers_left -= ( arglen + 2 );
+            *extra_headers_ptr++ = '\r';
+            *extra_headers_ptr++ = '\n';
+            *(extra_headers_ptr + 1) = 0;
+            cp += sprintf(cp, "%s\r\n", headers_llist->data);
             headers_llist = headers_llist->link;
+        }
+    }
+#endif
     parse_url(argv[optind], &target);
 …
     server.port = target.port;
+    /*
+     * Use the proxy if necessary.
+     */
+    /* Use the proxy if necessary */
     if (use_proxy) {
         proxy = getenv(target.is_ftp ? "ftp_proxy" : "http_proxy");
         if (proxy && *proxy) {
             parse_url(bb_xstrdup(proxy), &server);
+            parse_url(proxy, &server);
         } else {
             use_proxy = 0;
 …
         // 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 =
 #ifdef CONFIG_FEATURE_WGET_STATUSBAR
                 curfile =
 #endif
                 bb_get_last_path_component(target.path);
+        }
         if (fname_out==NULL || strlen(fname_out)<1) {
             fname_out =
+#ifdef CONFIG_FEATURE_WGET_STATUSBAR
+                curfile =
+#endif
+                "index.html";
+        if (!last_char_is(target.path, '/')) {
+            fname_out = bb_get_last_path_component(target.path);
+#if ENABLE_FEATURE_WGET_STATUSBAR
+            curfile = fname_out;
+#endif
+        }
+        if (!fname_out || !fname_out[0]) {
+            /* bb_get_last_path_component writes
+             * to last '/' only. We don't have one here... */
+            fname_out = (char*)"index.html";
+#if ENABLE_FEATURE_WGET_STATUSBAR
+            curfile = fname_out;
+#endif
+        }
         if (dir_prefix != NULL)
             fname_out = concat_path_file(dir_prefix, fname_out);
 #ifdef CONFIG_FEATURE_WGET_STATUSBAR
+#if ENABLE_FEATURE_WGET_STATUSBAR
     } else {
         curfile = bb_get_last_path_component(fname_out);
 #endif
+    }
+    if (do_continue && !fname_out)
+        bb_error_msg_and_die("cannot specify continue (-c) without a filename (-O)");
+    /*
+     * Open the output file stream.
+     */
+    if (strcmp(fname_out, "-") == 0) {
+        output = stdout;
+        quiet_flag = TRUE;
+    } else {
+        output = bb_xfopen(fname_out, (do_continue ? "a" : "w"));
+    }
+    /*
+     * Determine where to start transfer.
+     */
+    if (do_continue) {
+        if (fstat(fileno(output), &sbuf) < 0)
+            bb_perror_msg_and_die("fstat()");
+        if (sbuf.st_size > 0)
+            beg_range = sbuf.st_size;
+        else
+            do_continue = 0;
+    /* 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 (LONE_DASH(fname_out)) {
+        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 */
+    }
 …
      * 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 (quiet_flag==FALSE) {
         fprintf(stdout, "Connecting to %s[%s]:%d\n",
                 server.host, inet_ntoa(s_in.sin_addr), ntohs(server.port));
+    lsa = xhost2sockaddr(server.host, server.port);
+    if (!(opt & WGET_OPT_QUIET)) {
+        fprintf(stderr, "Connecting to %s (%s)\n", server.host,
+                xmalloc_sockaddr2dotted(&lsa->sa));
+        /* We leak result of xmalloc_sockaddr2dotted */
+    }
 …
             got_clen = chunked = 0;
+            if (! --try)
+                close_delete_and_die("too many redirections");
+            /*
+             * Open socket to http server
+             */
+            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.
+             */
+            sfp = open_socket(lsa);
+            /* Send HTTP request.  */
             if (use_proxy) {
+                const char *format = "GET %stp://%s:%d/%s HTTP/1.1\r\n";
+#ifdef CONFIG_FEATURE_WGET_IP6_LITERAL
+                if (strchr(target.host, ':'))
+                    format = "GET %stp://[%s]:%d/%s HTTP/1.1\r\n";
+#endif
+                fprintf(sfp, format,
+                fprintf(sfp, "GET %stp://%s/%s HTTP/1.1\r\n",
                     target.is_ftp ? "f" : "ht", target.host,
                     ntohs(target.port), target.path);
+                    target.path);
             } else {
                 fprintf(sfp, "GET /%s HTTP/1.1\r\n", target.path);
+            }
+            fprintf(sfp, "Host: %s\r\nUser-Agent: Wget\r\n", target.host);
+#ifdef CONFIG_FEATURE_WGET_AUTHENTICATION
+            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)));
+                fprintf(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
+                    base64enc_512(buf, target.user));
+            }
             if (use_proxy && server.user) {
                 fprintf(sfp, "Proxy-Authorization: Basic %s\r\n",
                     base64enc((unsigned char*)server.user, buf, sizeof(buf)));
+                    base64enc_512(buf, server.user));
+            }
 #endif
+            if (do_continue)
+                fprintf(sfp, "Range: bytes=%ld-\r\n", beg_range);
+            if(extra_headers_left < sizeof(extra_headers))
+                fputs(extra_headers,sfp);
+            fprintf(sfp,"Connection: close\r\n\r\n");
+            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:
+ read_response:
             if (fgets(buf, sizeof(buf), sfp) == NULL)
+                close_delete_and_die("no response from server");
+            for (s = buf ; *s != '\0' && !isspace(*s) ; ++s)
+                ;
+            for ( ; isspace(*s) ; ++s)
+                ;
+            switch (status = atoi(s)) {
+                case 0:
+                case 100:
+                    while (gethdr(buf, sizeof(buf), sfp, &n) != NULL);
+                    goto read_response;
+                case 200:
+                    if (do_continue && output != stdout)
+                        output = freopen(fname_out, "w", output);
+                    do_continue = 0;
+                bb_error_msg_and_die("no response from server");
+            str = buf;
+            str = skip_non_whitespace(str);
+            str = skip_whitespace(str);
+            // FIXME: no error check
+            // xatou wouldn't work: "200 OK"
+            status = atoi(str);
+            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;
+                case 300:   /* redirection */
+                case 301:
+                case 302:
+                case 303:
+                    break;
+                case 206:
+                    if (do_continue)
+                        break;
+                    /*FALLTHRU*/
+                default:
+                    chomp(buf);
+                    close_delete_and_die("server returned error %d: %s", atoi(s), buf);
+                /*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) {
+                    unsigned long value;
+                    if (safe_strtoul(s, &value)) {
+                        close_delete_and_die("content-length %s is garbage", s);
+            while ((str = gethdr(buf, sizeof(buf), sfp, &n)) != NULL) {
+                /* gethdr did already convert the "FOO:" string to lowercase */
+                smalluint key = index_in_strings(keywords, *&buf) + 1;
+                if (key == KEY_content_length) {
+                    content_len = BB_STRTOOFF(str, NULL, 10);
+                    if (errno || content_len < 0) {
+                        bb_error_msg_and_die("content-length %s is garbage", str);
+                    }
-                    filesize = value;
                     got_clen = 1;
                     continue;
+                }
+                if (strcasecmp(buf, "transfer-encoding") == 0) {
+                    if (strcasecmp(s, "chunked") == 0) {
+                        chunked = got_clen = 1;
+                    } else {
+                        close_delete_and_die("server wants to do %s transfer encoding", s);
+                    }
+                if (key == KEY_transfer_encoding) {
+                    if (index_in_strings(keywords, str_tolower(str)) + 1 != KEY_chunked)
+                        bb_error_msg_and_die("server wants to do %s transfer encoding", str);
+                    chunked = got_clen = 1;
+                }
+                if (strcasecmp(buf, "location") == 0) {
+                    if (s[0] == '/')
+                        target.path = bb_xstrdup(s+1);
+                if (key == KEY_location) {
+                    if (str[0] == '/')
+                        /* free(target.allocated); */
+                        target.path = /* target.allocated = */ xstrdup(str+1);
                     else {
                         parse_url(bb_xstrdup(s), &target);
+                        parse_url(str, &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;
+                        free(lsa);
+                        lsa = xhost2sockaddr(server.host, server.port);
                         break;
+                    }
+                }
+            }
         } while(status >= 300);
+        } while (status >= 300);
         dfp = sfp;
+    }
     else
+    {
+    } else {
         /*
          *  FTP session
          */
         if (! target.user)
             target.user = bb_xstrdup("anonymous:busybox@");
         sfp = open_socket(&s_in);
+        if (!target.user)
+            target.user = xstrdup("anonymous:busybox@");
+        sfp = open_socket(lsa);
         if (ftpcmd(NULL, NULL, sfp, buf) != 220)
             close_delete_and_die("%s", buf+4);
+            bb_error_msg_and_die("%s", buf+4);
         /*
 …
          * trying to log in
          */
+        s = strchr(target.user, ':');
+        if (s)
+            *(s++) = '\0';
+        switch(ftpcmd("USER ", target.user, sfp, buf)) {
+            case 230:
+        str = strchr(target.user, ':');
+        if (str)
+            *(str++) = '\0';
+        switch (ftpcmd("USER ", target.user, sfp, buf)) {
+        case 230:
+            break;
+        case 331:
+            if (ftpcmd("PASS ", str, sfp, buf) == 230)
                 break;
+            case 331:
+                if (ftpcmd("PASS ", s, sfp, buf) == 230)
+                    break;
+                /* FALLTHRU (failed login) */
+            default:
+                close_delete_and_die("ftp login: %s", buf+4);
+            /* FALLTHRU (failed login) */
+        default:
+            bb_error_msg_and_die("ftp login: %s", buf+4);
+        }
 …
          */
         if (ftpcmd("SIZE ", target.path, sfp, buf) == 213) {
             unsigned long value;
             if (safe_strtoul(buf+4, &value)) {
                 close_delete_and_die("SIZE value is garbage");
+            content_len = BB_STRTOOFF(buf+4, NULL, 10);
+            if (errno || content_len < 0) {
+                bb_error_msg_and_die("SIZE value is garbage");
+            }
-            filesize = value;
             got_clen = 1;
+        }
 …
          * Entering passive mode
          */
+        if (ftpcmd("PASV", NULL, sfp, buf) !=  227)
+            close_delete_and_die("PASV: %s", buf+4);
+        s = strrchr(buf, ',');
+        *s = 0;
+        port = atoi(s+1);
+        s = strrchr(buf, ',');
+        port += atoi(s+1) * 256;
+        s_in.sin_port = htons(port);
+        dfp = open_socket(&s_in);
+        if (do_continue) {
+            sprintf(buf, "REST %ld", beg_range);
+            if (ftpcmd(buf, NULL, sfp, buf) != 350) {
+                if (output != stdout)
+                    output = freopen(fname_out, "w", output);
+                do_continue = 0;
+            } else
+                filesize -= beg_range;
+        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
+        str = strrchr(buf, ')');
+        if (str) str[0] = '\0';
+        str = strrchr(buf, ',');
+        if (!str) goto pasv_error;
+        port = xatou_range(str+1, 0, 255);
+        *str = '\0';
+        str = strrchr(buf, ',');
+        if (!str) goto pasv_error;
+        port += xatou_range(str+1, 0, 255) * 256;
+        set_nport(lsa, htons(port));
+        dfp = open_socket(lsa);
+        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)
+            close_delete_and_die("RETR: %s", buf+4);
+    }
+            bb_error_msg_and_die("bad response to RETR: %s", buf);
+    }
+    if (opt & WGET_OPT_SPIDER) {
+        if (ENABLE_FEATURE_CLEAN_UP)
+            fclose(sfp);
+        goto done;
+    }
     /*
 …
     if (chunked) {
         fgets(buf, sizeof(buf), dfp);
+        filesize = strtol(buf, (char **) NULL, 16);
+    }
+    if (quiet_flag==FALSE)
+        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 ((filesize > 0 || !got_clen) && (n = safe_fread(buf, 1, ((chunked || got_clen) && (filesize < sizeof(buf)) ? filesize : sizeof(buf)), dfp)) > 0) {
+            if (safe_fwrite(buf, 1, n, output) != n) {
+        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, rdsz, dfp);
+            if (n <= 0)
+                break;
+            if (full_write(output_fd, buf, n) != n) {
                 bb_perror_msg_and_die(bb_msg_write_error);
+            }
 #ifdef CONFIG_FEATURE_WGET_STATUSBAR
+#if ENABLE_FEATURE_WGET_STATUSBAR
             transferred += n;
 #endif
             if (got_clen) {
                 filesize -= n;
+                content_len -= n;
+            }
+        }
 …
             safe_fgets(buf, sizeof(buf), dfp); /* This is a newline */
             safe_fgets(buf, sizeof(buf), dfp);
+            filesize = strtol(buf, (char **) NULL, 16);
+            if (filesize==0) {
+            content_len = STRTOOFF(buf, NULL, 16);
+            /* FIXME: error check? */
+            if (content_len == 0) {
                 chunked = 0; /* all done! */
+            }
 …
     } while (chunked);
     if (quiet_flag==FALSE)
+    if (!(opt & WGET_OPT_QUIET))
         progressmeter(1);
 …
         ftpcmd("QUIT", NULL, sfp, buf);
+    }
+done:
     exit(EXIT_SUCCESS);
+}
+void parse_url(char *url, struct host_info *h)
+{
+    char *cp, *sp, *up, *pp;
+static void parse_url(char *src_url, struct host_info *h)
+{
+    char *url, *p, *sp;
+    /* h->allocated = */ url = xstrdup(src_url);
     if (strncmp(url, "http://", 7) == 0) {
 …
         h->is_ftp = 0;
     } else if (strncmp(url, "ftp://", 6) == 0) {
         h->port = bb_lookup_port("ftp", "tfp", 21);
+        h->port = bb_lookup_port("ftp", "tcp", 21);
         h->host = url + 6;
         h->is_ftp = 1;
 …
         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, '/');
+    if (sp) {
+        *sp++ = '\0';
+    p = strchr(h->host, '?'); if (!sp || (p && sp > p)) sp = p;
+    p = strchr(h->host, '#'); if (!sp || (p && sp > p)) sp = p;
+    if (!sp) {
+        /* must be writable because of bb_get_last_path_component() */
+        static char nullstr[] ALIGN1 = "";
+        h->path = nullstr;
+    } else if (*sp == '/') {
+        *sp = '\0';
+        h->path = sp + 1;
+    } 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;
     } else
+        h->path = bb_xstrdup("");
     up = strrchr(h->host, '@');
     if (up != NULL) {
+    }
+    sp = strrchr(h->host, '@');
+    h->user = NULL;
+    if (sp != NULL) {
         h->user = h->host;
+        *up++ = '\0';
+        h->host = up;
+    } else
+        h->user = NULL;
+    pp = h->host;
+#ifdef CONFIG_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(atoi(cp));
+    }
+}
+FILE *open_socket(struct sockaddr_in *s_in)
+        *sp = '\0';
+        h->host = sp + 1;
+    }
+    sp = h->host;
+}
+static FILE *open_socket(len_and_sockaddr *lsa)
+{
     FILE *fp;
+    fp = fdopen(xconnect(s_in), "r+");
+    /* glibc 2.4 seems to try seeking on it - ??! */
+    /* hopefully it understands what ESPIPE means... */
+    fp = fdopen(xconnect_stream(lsa), "r+");
     if (fp == NULL)
         bb_perror_msg_and_die("fdopen()");
+        bb_perror_msg_and_die("fdopen");
     return fp;
 …
 char *gethdr(char *buf, size_t bufsiz, FILE *fp, int *istrunc)
+static char *gethdr(char *buf, size_t bufsiz, FILE *fp, int *istrunc)
+{
     char *s, *hdrval;
 …
     /* see if we are at the end of the headers */
     for (s = buf ; *s == '\r' ; ++s)
+    for (s = buf; *s == '\r'; ++s)
+        ;
     if (s[0] == '\n')
 …
     /* convert the header name to lower case */
     for (s = buf ; isalnum(*s) || *s == '-' ; ++s)
+    for (s = buf; isalnum(*s) || *s == '-'; ++s)
         *s = tolower(*s);
 …
     /* locate the start of the header value */
     for (*s++ = '\0' ; *s == ' ' || *s == '\t' ; ++s)
+    for (*s++ = '\0'; *s == ' ' || *s == '\t'; ++s)
+        ;
     hdrval = s;
 …
+}
+static int ftpcmd(char *s1, char *s2, FILE *fp, char *buf)
+{
+static int ftpcmd(const char *s1, const char *s2, FILE *fp, char *buf)
+{
+    int result;
     if (s1) {
         if (!s2) s2="";
+        if (!s2) s2 = "";
         fprintf(fp, "%s%s\r\n", s1, s2);
         fflush(fp);
 …
         if (fgets(buf, 510, fp) == NULL) {
             bb_perror_msg_and_die("fgets()");
+            bb_perror_msg_and_die("error getting response");
+        }
         buf_ptr = strstr(buf, "\r\n");
 …
             *buf_ptr = '\0';
+        }
+    } while (! isdigit(buf[0]) || buf[3] != ' ');
+    return atoi(buf);
+}
+#ifdef CONFIG_FEATURE_WGET_STATUSBAR
+    } 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=0;
+    int width;
     get_terminal_width_height(0, &width, NULL);
     return (width);
+    return width;
+}
 …
+}
+static void
+alarmtimer(int wait)
+static void alarmtimer(int iwait)
+{
     struct itimerval itv;
     itv.it_value.tv_sec = wait;
+    itv.it_value.tv_sec = iwait;
     itv.it_value.tv_usec = 0;
     itv.it_interval = itv.it_value;
 …
+}
 static void
 progressmeter(int flag)
+{
+    static struct timeval lastupdate;
+    static unsigned lastupdate_sec;
+    static unsigned start_sec;
     static off_t lastsize, totalsize;
-    struct timeval now, td, wait;
     off_t abbrevsize;
+    int elapsed, ratio, barlength, i;
+    char buf[256];
+    if (flag == -1) {
+        (void) gettimeofday(&start, (struct timezone *) 0);
+        lastupdate = start;
+    unsigned since_last_update, elapsed;
+    unsigned ratio;
+    int barlength, i;
+    if (flag == -1) { /* first call to progressmeter */
+        start_sec = monotonic_sec();
+        lastupdate_sec = start_sec;
         lastsize = 0;
+        totalsize = filesize; /* as filesize changes.. */
+    }
+    (void) gettimeofday(&now, (struct timezone *) 0);
+        totalsize = content_len + beg_range; /* as content_len changes.. */
+    }
     ratio = 100;
     if (totalsize != 0 && !chunked) {
+        ratio = (int) (100 * transferred / totalsize);
+        ratio = MIN(ratio, 100);
+        /* long long helps to have it working even if !LFS */
+        ratio = (unsigned) (100ULL * (transferred+beg_range) / totalsize);
+        if (ratio > 100) ratio = 100;
+    }
     fprintf(stderr, "\r%-20.20s%4d%% ", curfile, ratio);
+    barlength = getttywidth() - 51;
+    if (barlength > 0 && barlength < sizeof(buf)) {
+    barlength = getttywidth() - 49;
+    if (barlength > 0) {
+        /* god bless gcc for variable arrays :) */
         i = barlength * ratio / 100;
+        memset(buf, '*', i);
+        memset(buf + i, ' ', barlength - i);
+        buf[barlength] = '\0';
+        fprintf(stderr, "|%s|", buf);
+        {
+            char buf[i+1];
+            memset(buf, '*', i);
+            buf[i] = '\0';
+            fprintf(stderr, "|%s%*s|", buf, barlength - i, "");
+        }
+    }
     i = 0;
     abbrevsize = transferred;
+    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, &wait);
+    /* see http://en.wikipedia.org/wiki/Tera */
+    fprintf(stderr, "%6d%c ", (int)abbrevsize, " kMGTPEZY"[i]);
+// Nuts! Ain't it easier to update progress meter ONLY when we transferred++?
+// FIXME: get rid of alarmtimer + updateprogressmeter mess
+    elapsed = monotonic_sec();
+    since_last_update = elapsed - lastupdate_sec;
     if (transferred > lastsize) {
         lastupdate = now;
+        lastupdate_sec = elapsed;
         lastsize = transferred;
+        if (wait.tv_sec >= STALLTIME)
+            timeradd(&start, &wait, &start);
+        wait.tv_sec = 0;
+    }
+    timersub(&now, &start, &td);
+    elapsed = td.tv_sec;
+    if (wait.tv_sec >= STALLTIME) {
+        if (since_last_update >= STALLTIME) {
+            /* We "cut off" these seconds from elapsed time
+             * by adjusting start time */
+            start_sec += since_last_update;
+        }
+        since_last_update = 0; /* we are un-stalled now */
+    }
+    elapsed -= start_sec; /* now it's "elapsed since start" */
+    if (since_last_update >= STALLTIME) {
         fprintf(stderr, " - stalled -");
-    } else if (transferred <= 0 || elapsed <= 0 || transferred > totalsize || chunked) {
-        fprintf(stderr, "--:--:-- ETA");
     } else {
+        /* totalsize / (transferred/elapsed) - elapsed: */
+        int eta = (int) (totalsize*elapsed/transferred - elapsed);
+        i = eta % 3600;
+        fprintf(stderr, "%02d:%02d:%02d ETA", eta / 3600, i / 60, i % 60);
+    }
+    if (flag == -1) {
+        off_t to_download = totalsize - beg_range;
+        if (transferred <= 0 || (int)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;
 …
         sigaction(SIGALRM, &sa, NULL);
         alarmtimer(1);
     } else if (flag == 1) {
+    } else if (flag == 1) { /* last call to progressmeter */
         alarmtimer(0);
         transferred = 0;
 …
+    }
+}
 #endif
+#endif /* FEATURE_WGET_STATUSBAR */
 /* Original copyright notice which applies to the CONFIG_FEATURE_WGET_STATUSBAR stuff,
 …
  * SUCH DAMAGE.
+ *
- *  $Id: wget.c,v 1.75 2004/10/08 08:27:40 andersen Exp $
  */

branches/stable/mindi-busybox/networking/zcip.c

-              r902
+              r1770
+/* vi: set sw=4 ts=4: */
 /*
  * RFC3927 ZeroConf IPv4 Link-Local addressing
 …
 // - link status monitoring (restart on link-up; stop on link-down)
-#include "busybox.h"
-#include <errno.h>
-#include <string.h>
 #include <syslog.h>
 #include <poll.h>
-#include <time.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>
+#include "libbb.h"
+/* We don't need more than 32 bits of the counter */
+#define MONOTONIC_US() ((unsigned)monotonic_us())
 struct arp_packet {
 …
 };
+/* Implicitly zero-initialized */
+static const struct in_addr null_ip;
+static const struct ether_addr null_addr;
+static int verbose;
+#define DBG(fmt,args...) \
+#define VDBG(fmt,args...) \
     do { } while (0)
-#define VDBG    DBG
 /**
 …
 static void pick(struct in_addr *ip)
+{
+    unsigned    tmp;
+    /* use cheaper math than lrand48() mod N */
+    unsigned tmp;
     do {
         tmp = (lrand48() >> 16) & IN_CLASSB_HOST;
+        tmp = rand() & IN_CLASSB_HOST;
     } while (tmp > (IN_CLASSB_HOST - 0x0200));
     ip->s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
 …
  * Broadcast an ARP packet.
  */
 static int arp(int fd, struct sockaddr *saddr, int op,
+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)
 …
     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_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));
+    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) {
+        perror("sendto");
+    xsendto(fd, &p, sizeof(p), saddr, sizeof(*saddr));
+    // Currently all callers ignore errors, that's why returns are
+    // commented out...
+    //return 0;
+}
+/**
+ * Run a script. argv[2] is already NULL.
+ */
+static int run(char *argv[3], const char *intf, struct in_addr *ip)
+{
+    int status;
+    VDBG("%s run %s %s\n", intf, argv[0], argv[1]);
+    if (ip) {
+        char *addr = inet_ntoa(*ip);
+        setenv("ip", addr, 1);
+        bb_info_msg("%s %s %s", argv[1], intf, addr);
+    }
+    status = wait4pid(spawn(argv));
+    if (status < 0) {
+        bb_perror_msg("%s %s", argv[1], intf);
         return -errno;
+    }
+    return 0;
+    if (status != 0)
+        bb_error_msg("script %s %s failed, exitcode=%d", argv[0], argv[1], status);
+    return status;
+}
 /**
  * Run a script.
  */
 static int run(char *script, char *arg, char *intf, struct in_addr *ip)
+ * Return milliseconds of random delay, up to "secs" seconds.
+ */
+static unsigned ALWAYS_INLINE ms_rdelay(unsigned secs)
+{
+    int pid, status;
+    char *why;
+    if (script != NULL) {
+        VDBG("%s run %s %s\n", intf, script, arg);
+        if (ip != NULL) {
+            char *addr = inet_ntoa(*ip);
+            setenv("ip", addr, 1);
+            syslog(LOG_INFO, "%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);
+            perror("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\n",
+                    script, WEXITSTATUS(status));
+            return -errno;
+    return rand() % (secs * 1000);
+}
+/**
+ * main program
+ */
+int zcip_main(int argc, char **argv);
+int zcip_main(int argc, char **argv)
+{
+    int state = PROBE;
+    struct ether_addr eth_addr;
+    const char *why;
+    int fd;
+    char *r_opt;
+    unsigned opts;
+    /* Ugly trick, but I want these zeroed in one go */
+    struct {
+        const struct in_addr null_ip;
+        const struct ether_addr null_addr;
+        struct sockaddr saddr;
+        struct in_addr ip;
+        struct ifreq ifr;
+        char *intf;
+        char *script_av[3];
+        int timeout_ms; /* must be signed */
+        unsigned conflicts;
+        unsigned nprobes;
+        unsigned nclaims;
+        int ready;
+        int verbose;
+    } L;
+#define null_ip    (L.null_ip   )
+#define null_addr  (L.null_addr )
+#define saddr      (L.saddr     )
+#define ip         (L.ip        )
+#define ifr        (L.ifr       )
+#define intf       (L.intf      )
+#define script_av  (L.script_av )
+#define timeout_ms (L.timeout_ms)
+#define conflicts  (L.conflicts )
+#define nprobes    (L.nprobes   )
+#define nclaims    (L.nclaims   )
+#define ready      (L.ready     )
+#define verbose    (L.verbose   )
+    memset(&L, 0, sizeof(L));
+#define FOREGROUND (opts & 1)
+#define QUIT       (opts & 2)
+    // parse commandline: prog [options] ifname script
+    // exactly 2 args; -v accumulates and implies -f
+    opt_complementary = "=2:vv:vf";
+    opts = getopt32(argv, "fqr:v", &r_opt, &verbose);
+    if (!FOREGROUND) {
+        /* Do it early, before all bb_xx_msg calls */
+        openlog(applet_name, 0, LOG_DAEMON);
+        logmode |= LOGMODE_SYSLOG;
+    }
+    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");
+        }
+    }
+    return 0;
+bad:
+    status = -errno;
+    syslog(LOG_ERR, "%s %s, %s error: %s",
+        arg, intf, why, strerror(errno));
+    return status;
+}
+/**
+ * Return milliseconds of random delay, up to "secs" seconds.
+ */
+static inline unsigned ms_rdelay(unsigned secs)
+{
+    return lrand48() % (secs * 1000);
+}
+/**
+ * main program
+ */
+int zcip_main(int argc, char *argv[])
+{
+    char *intf = NULL;
+    char *script = NULL;
+    int quit = 0;
+    int foreground = 0;
+    char *why;
+    struct sockaddr saddr;
+    struct ether_addr addr;
+    struct in_addr ip = { 0 };
+    int fd;
+    int ready = 0;
+    suseconds_t timeout = 0;    // milliseconds
+    unsigned conflicts = 0;
+    unsigned nprobes = 0;
+    unsigned nclaims = 0;
+    int t;
+    int state = PROBE;
+    // parse commandline: prog [options] ifname script
+    while ((t = getopt(argc, argv, "fqr:v")) != EOF) {
+        switch (t) {
+        case 'f':
+            foreground = 1;
+            continue;
+        case 'q':
+            quit = 1;
+            continue;
+        case 'r':
+            if (inet_aton(optarg, &ip) == 0
+                    || (ntohl(ip.s_addr) & IN_CLASSB_NET)
+                        != LINKLOCAL_ADDR) {
+                bb_error_msg_and_die("invalid link address");
+            }
+            continue;
+        case 'v':
+            verbose++;
+            foreground = 1;
+            continue;
+        default:
+            bb_error_msg_and_die("bad option");
+        }
+    }
+    if (optind < argc - 1) {
+        intf = argv[optind++];
+        setenv("interface", intf, 1);
+        script = argv[optind++];
+    }
+    if (optind != argc || !intf)
+        bb_show_usage();
+    openlog(bb_applet_name, 0, LOG_DAEMON);
+    // On NOMMU reexec early (or else we will rerun things twice)
+#if !BB_MMU
+    if (!FOREGROUND)
+        bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
+#endif
+    argc -= optind;
+    argv += optind;
+    intf = argv[0];
+    script_av[0] = argv[1];
+    setenv("interface", intf, 1);
     // initialize the interface (modprobe, ifup, etc)
+    if (run(script, "init", intf, NULL) < 0)
+    script_av[1] = (char*)"init";
+    if (run(script_av, intf, NULL))
         return EXIT_FAILURE;
     // initialize saddr
     memset(&saddr, 0, sizeof (saddr));
     safe_strncpy(saddr.sa_data, intf, sizeof (saddr.sa_data));
+    //memset(&saddr, 0, sizeof(saddr));
+    safe_strncpy(saddr.sa_data, intf, sizeof(saddr.sa_data));
     // open an ARP socket
+    if ((fd = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP))) < 0) {
+        why = "open";
+fail:
+        foreground = 1;
+        goto bad;
+    }
+    fd = xsocket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
     // bind to the interface's ARP socket
+    if (bind(fd, &saddr, sizeof (saddr)) < 0) {
+        why = "bind";
+        goto fail;
+    } else {
+        struct ifreq ifr;
+        unsigned short seed[3];
+        // 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) {
+            why = "get ethernet address";
+            goto fail;
+        }
+        memcpy(&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.
+        memcpy(seed, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
+        seed48(seed);
+        if (ip.s_addr == 0)
+            pick(&ip);
+    }
+    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));
+    xioctl(fd, SIOCGIFHWADDR, &ifr);
+    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.
+    srand(*(unsigned*)&ifr.ifr_hwaddr.sa_data);
+    if (ip.s_addr == 0)
+        pick(&ip);
     // FIXME cases to handle:
 …
     // daemonize now; don't delay system startup
+    if (!foreground) {
+        if (daemon(0, verbose) < 0) {
+            why = "daemon";
+            goto bad;
+        }
+        syslog(LOG_INFO, "start, interface %s", intf);
+    if (!FOREGROUND) {
+#if BB_MMU
+        bb_daemonize(DAEMON_CHDIR_ROOT);
+#endif
+        bb_info_msg("start, interface %s", intf);
+    }
 …
     while (1) {
         struct pollfd fds[1];
         struct timeval tv1;
+        unsigned deadline_us;
         struct arp_packet p;
+        int source_ip_conflict = 0;
+        int target_ip_conflict = 0;
         fds[0].fd = fd;
 …
         fds[0].revents = 0;
-        int source_ip_conflict = 0;
-        int target_ip_conflict = 0;
         // poll, being ready to adjust current timeout
         if (!timeout) {
             timeout = ms_rdelay(PROBE_WAIT);
+        if (!timeout_ms) {
+            timeout_ms = 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)) {
+        // set deadline_us to the point in time when we timeout
+        deadline_us = MONOTONIC_US() + timeout_ms * 1000;
+        VDBG("...wait %d %s nprobes=%u, nclaims=%u\n",
+                timeout_ms, intf, nprobes, nclaims);
+        switch (poll(fds, 1, timeout_ms)) {
         // timeout
 …
             switch (state) {
             case PROBE:
                 // timeouts in the PROBE state means no conflicting ARP packets
+                // 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",
+                    VDBG("probe/%u %s@%s\n",
                             nprobes, intf, inet_ntoa(ip));
                     (void)arp(fd, &saddr, ARPOP_REQUEST,
                             &addr, null_ip,
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, null_ip,
                             &null_addr, ip);
+                    timeout = PROBE_MIN * 1000;
+                    timeout += ms_rdelay(PROBE_MAX
+                            - PROBE_MIN);
+                    timeout_ms = PROBE_MIN * 1000;
+                    timeout_ms += ms_rdelay(PROBE_MAX - PROBE_MIN);
+                }
                 else {
 …
                     state = ANNOUNCE;
                     nclaims = 0;
                     VDBG("announce/%d %s@%s\n",
+                    VDBG("announce/%u %s@%s\n",
                             nclaims, intf, inet_ntoa(ip));
                     (void)arp(fd, &saddr, ARPOP_REQUEST,
                             &addr, ip,
                             &addr, ip);
                     timeout = ANNOUNCE_INTERVAL * 1000;
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, ip,
+                            &eth_addr, ip);
+                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
+                }
                 break;
             case RATE_LIMIT_PROBE:
                 // timeouts in the RATE_LIMIT_PROBE state means no conflicting ARP packets
+                // 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",
+                VDBG("announce/%u %s@%s\n",
                         nclaims, intf, inet_ntoa(ip));
                 (void)arp(fd, &saddr, ARPOP_REQUEST,
                         &addr, ip,
                         &addr, ip);
                 timeout = ANNOUNCE_INTERVAL * 1000;
+                arp(fd, &saddr, ARPOP_REQUEST,
+                        &eth_addr, ip,
+                        &eth_addr, ip);
+                timeout_ms = ANNOUNCE_INTERVAL * 1000;
                 break;
             case ANNOUNCE:
                 // timeouts in the ANNOUNCE state means no conflicting ARP packets
+                // 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",
+                    VDBG("announce/%u %s@%s\n",
                             nclaims, intf, inet_ntoa(ip));
                     (void)arp(fd, &saddr, ARPOP_REQUEST,
                             &addr, ip,
                             &addr, ip);
                     timeout = ANNOUNCE_INTERVAL * 1000;
+                    arp(fd, &saddr, ARPOP_REQUEST,
+                            &eth_addr, ip,
+                            &eth_addr, ip);
+                    timeout_ms = ANNOUNCE_INTERVAL * 1000;
+                }
                 else {
 …
                     // link is ok to use earlier
                     // FIXME update filters
+                    run(script, "config", intf, &ip);
+                    script_av[1] = (char*)"config";
+                    run(script_av, intf, &ip);
                     ready = 1;
                     conflicts = 0;
                     timeout = -1; // Never timeout in the monitor state.
                     // NOTE:  all other exit paths
+                    timeout_ms = -1; // Never timeout in the monitor state.
+                    // NOTE: all other exit paths
                     // should deconfig ...
                     if (quit)
+                    if (QUIT)
                         return EXIT_SUCCESS;
+                }
 …
                 // We won!  No ARP replies, so just go back to monitor.
                 state = MONITOR;
                 timeout = -1;
+                timeout_ms = -1;
                 conflicts = 0;
                 break;
 …
                 state = PROBE;
                 pick(&ip);
                 timeout = 0;
+                timeout_ms = 0;
                 nprobes = 0;
                 nclaims = 0;
 …
             // 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, <)) {
+            if (timeout_ms > 0) {
+                unsigned diff = deadline_us - MONOTONIC_US();
+                if ((int)(diff) < 0) {
                     // Current time is greater than the expected timeout time.
                     // Should never happen.
                     VDBG("missed an expected timeout\n");
                     timeout = 0;
+                    timeout_ms = 0;
                 } else {
                     VDBG("adjusting timeout\n");
+                    timersub(&tv1, &tv2, &tv1);
+                    timeout = 1000 * tv1.tv_sec
+                            + tv1.tv_usec / 1000;
+                    timeout_ms = diff / 1000;
+                    if (!timeout_ms) timeout_ms = 1;
+                }
+            }
 …
                     // FIXME: links routinely go down;
                     // this shouldn't necessarily exit.
                     bb_error_msg("%s: poll error\n", intf);
+                    bb_error_msg("%s: poll error", intf);
                     if (ready) {
                         run(script, "deconfig",
                                 intf, &ip);
+                        script_av[1] = (char*)"deconfig";
+                        run(script_av, intf, &ip);
+                    }
                     return EXIT_FAILURE;
 …
             // read ARP packet
             if (recv(fd, &p, sizeof (p), 0) < 0) {
+            if (recv(fd, &p, sizeof(p), 0) < 0) {
                 why = "recv";
                 goto bad;
 …
             if (memcmp(p.arp.arp_spa, &ip.s_addr, sizeof(struct in_addr)) == 0 &&
                 memcmp(&addr, &p.arp.arp_sha, ETH_ALEN) != 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(&addr, &p.arp.arp_tha, ETH_ALEN) != 0) {
+                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",
+            VDBG("state = %d, source ip conflict = %d, target ip conflict = %d\n",
                 state, source_ip_conflict, target_ip_conflict);
             switch (state) {
 …
                     if (conflicts >= MAX_CONFLICTS) {
                         VDBG("%s ratelimit\n", intf);
                         timeout = RATE_LIMIT_INTERVAL * 1000;
+                        timeout_ms = RATE_LIMIT_INTERVAL * 1000;
                         state = RATE_LIMIT_PROBE;
+                    }
 …
                     // restart the whole protocol
                     pick(&ip);
                     timeout = 0;
+                    timeout_ms = 0;
                     nprobes = 0;
                     nclaims = 0;
 …
                     VDBG("monitor conflict -- defending\n");
                     state = DEFEND;
                     timeout = DEFEND_INTERVAL * 1000;
                     (void)arp(fd, &saddr,
+                    timeout_ms = DEFEND_INTERVAL * 1000;
+                    arp(fd, &saddr,
                             ARPOP_REQUEST,
                             &addr, ip,
                             &addr, ip);
+                            &eth_addr, ip,
+                            &eth_addr, ip);
+                }
                 break;
 …
                     VDBG("defend conflict -- starting over\n");
                     ready = 0;
+                    run(script, "deconfig", intf, &ip);
+                    script_av[1] = (char*)"deconfig";
+                    run(script_av, intf, &ip);
                     // restart the whole protocol
                     pick(&ip);
                     timeout = 0;
+                    timeout_ms = 0;
                     nprobes = 0;
                     nclaims = 0;
 …
                 state = PROBE;
                 pick(&ip);
                 timeout = 0;
+                timeout_ms = 0;
                 nprobes = 0;
                 nclaims = 0;
 …
         } // switch poll
+    }
+bad:
+    if (foreground)
+        perror(why);
+    else
+        syslog(LOG_ERR, "%s %s, %s error: %s",
+            bb_applet_name, intf, why, strerror(errno));
+ bad:
+    bb_perror_msg("%s, %s", intf, why);
     return EXIT_FAILURE;
+}

Context Navigation

Changeset 1770 in MondoRescue for branches/stable/mindi-busybox/networking

Legend:

Download in other formats: