Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/networking/libiproute

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

Location:

branches/2.2.9/mindi-busybox/networking/libiproute

Files:

• Kbuild (modified) (2 diffs)
• Kbuild.src (added)
• ip_common.h (modified) (2 diffs)
• ip_parse_common_args.c (modified) (2 diffs)
• ipaddress.c (modified) (28 diffs)
• iplink.c (modified) (16 diffs)
• iproute.c (modified) (36 diffs)
• iprule.c (modified) (19 diffs)
• iptunnel.c (modified) (26 diffs)
• libnetlink.c (modified) (26 diffs)
• libnetlink.h (modified) (2 diffs)
• ll_addr.c (modified) (4 diffs)
• ll_map.c (modified) (12 diffs)
• ll_map.h (modified) (1 diff)
• ll_proto.c (modified) (4 diffs)
• ll_types.c (modified) (2 diffs)
• rt_names.c (modified) (8 diffs)
• rt_names.h (modified) (1 diff)
• rtm_map.c (modified) (6 diffs)
• rtm_map.h (modified) (1 diff)
• utils.c (modified) (10 diffs)
• utils.h (modified) (7 diffs)

branches/2.2.9/mindi-busybox/networking/libiproute/Kbuild

@@ +1 @@
+# DO NOT EDIT. This file is generated from Kbuild.src
 # Makefile for busybox
 #
 # Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
 #
-# Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+# Licensed under GPLv2 or later, see file LICENSE in this source tree.
 #
 
 lib-y:=
+
+
 
 lib-$(CONFIG_SLATTACH) += \
@@ -63 +66 @@
     rt_names.o \
     utils.o
-

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef _IP_COMMON_H
-#define _IP_COMMON_H 1
+#ifndef IP_COMMON_H
+#define IP_COMMON_H 1
 
 #include "libbb.h"
@@ -14 +14 @@
 #endif
 
-extern void ip_parse_common_args(int *argcp, char ***argvp);
-extern int print_neigh(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg);
-extern int ipaddr_list_or_flush(int argc, char **argv, int flush);
-extern int iproute_monitor(int argc, char **argv);
-extern void iplink_usage(void) ATTRIBUTE_NORETURN;
-extern void ipneigh_reset_filter(void);
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
-extern int do_ipaddr(int argc, char **argv);
-extern int do_iproute(int argc, char **argv);
-extern int do_iprule(int argc, char **argv);
-extern int do_ipneigh(int argc, char **argv);
-extern int do_iptunnel(int argc, char **argv);
-extern int do_iplink(int argc, char **argv);
-extern int do_ipmonitor(int argc, char **argv);
-extern int do_multiaddr(int argc, char **argv);
-extern int do_multiroute(int argc, char **argv);
-#endif /* ip_common.h */
+char FAST_FUNC **ip_parse_common_args(char **argv);
+//int FAST_FUNC print_neigh(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg);
+int FAST_FUNC ipaddr_list_or_flush(char **argv, int flush);
+//int FAST_FUNC iproute_monitor(char **argv);
+//void FAST_FUNC ipneigh_reset_filter(void);
+
+int FAST_FUNC do_ipaddr(char **argv);
+int FAST_FUNC do_iproute(char **argv);
+int FAST_FUNC do_iprule(char **argv);
+//int FAST_FUNC do_ipneigh(char **argv);
+int FAST_FUNC do_iptunnel(char **argv);
+int FAST_FUNC do_iplink(char **argv);
+//int FAST_FUNC do_ipmonitor(char **argv);
+//int FAST_FUNC do_multiaddr(char **argv);
+//int FAST_FUNC do_multiroute(char **argv);
+
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ip.c     "ip" utility frontend.
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
  *
- * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  */
 
@@ -19 +16 @@
 #include "utils.h"
 
-int preferred_family = AF_UNSPEC;
+family_t preferred_family = AF_UNSPEC;
 smallint oneline;
 char _SL_;
 
-void ip_parse_common_args(int *argcp, char ***argvp)
+char** FAST_FUNC ip_parse_common_args(char **argv)
 {
-    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";
+        "oneline" "\0"
+        "family" "\0"
+        "4" "\0"
+        "6" "\0"
+        "0" "\0"
+        ;
     enum {
-        ARG_family = 1,
-        ARG_inet,
-        ARG_inet6,
-        ARG_link,
+        ARG_oneline,
+        ARG_family,
         ARG_IPv4,
         ARG_IPv6,
         ARG_packet,
-        ARG_oneline
     };
-    smalluint arg;
+    static const family_t af_numbers[] = { AF_INET, AF_INET6, AF_PACKET };
+    int arg;
 
-    while (argc > 1) {
-        char *opt = argv[1];
+    while (*argv) {
+        char *opt = *argv;
 
-        if (strcmp(opt,"--") == 0) {
-            argc--;
-            argv++;
-            break;
-        }
         if (opt[0] != '-')
             break;
-        if (opt[1] == '-')
+        opt++;
+        if (opt[0] == '-') {
             opt++;
-        arg = index_in_strings(ip_common_commands, opt) + 1;
+            if (!opt[0]) { /* "--" */
+                argv++;
+                break;
+            }
+        }
+        arg = index_in_substrings(ip_common_commands, opt);
+        if (arg < 0)
+            bb_show_usage();
+        if (arg == ARG_oneline) {
+            oneline = 1;
+            argv++;
+            continue;
+        }
         if (arg == ARG_family) {
-            argc--;
+            static const char families[] ALIGN1 =
+                "inet" "\0" "inet6" "\0" "link" "\0";
             argv++;
-            if (!argv[1])
+            if (!*argv)
                 bb_show_usage();
-            arg = index_in_strings(ip_common_commands, argv[1]) + 1;
-            if (arg == ARG_inet)
-                preferred_family = AF_INET;
-            else if (arg == ARG_inet6)
-                preferred_family = AF_INET6;
-            else if (arg == ARG_link)
-                preferred_family = AF_PACKET;
-            else
-                invarg(argv[1], "protocol family");
-        } else if (arg == ARG_IPv4) {
-            preferred_family = AF_INET;
-        } else if (arg == ARG_IPv6) {
-            preferred_family = AF_INET6;
-        } else if (arg == ARG_packet) {
-            preferred_family = AF_PACKET;
-        } else if (arg == ARG_oneline) {
-            ++oneline;
+            arg = index_in_strings(families, *argv);
+            if (arg < 0)
+                invarg(*argv, "protocol family");
+            /* now arg == 0, 1 or 2 */
         } else {
-            bb_show_usage();
+            arg -= ARG_IPv4;
+            /* now arg == 0, 1 or 2 */
         }
-        argc--;
+        preferred_family = af_numbers[arg];
         argv++;
     }
     _SL_ = oneline ? '\\' : '\n';
-    *argcp = argc;
-    *argvp = argv;
+    return argv;
 }

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ipaddress.c      "ip address".
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
- *  Laszlo Valko <valko@linux.karinthy.hu> 990223: address label must be zero terminated
+ * Laszlo Valko <valko@linux.karinthy.hu> 990223: address label must be zero terminated
  */
 
-//#include <sys/socket.h>
-//#include <sys/ioctl.h>
 #include <fnmatch.h>
 #include <net/if.h>
@@ -21 +17 @@
 #include "utils.h"
 
-
-typedef struct filter_t {
-    int ifindex;
-    int family;
-    int oneline;
-    int showqueue;
-    inet_prefix pfx;
+#ifndef IFF_LOWER_UP
+/* from linux/if.h */
+#define IFF_LOWER_UP  0x10000  /* driver signals L1 up */
+#endif
+
+struct filter_t {
+    char *label;
+    char *flushb;
+    struct rtnl_handle *rth;
     int scope, scopemask;
     int flags, flagmask;
-    int up;
-    char *label;
-    int flushed;
-    char *flushb;
     int flushp;
     int flushe;
-    struct rtnl_handle *rth;
-} filter_t;
-
-#define filter (*(filter_t*)&bb_common_bufsiz1)
-
-
-static void print_link_flags(FILE *fp, unsigned flags, unsigned mdown)
-{
-    fprintf(fp, "<");
+    int ifindex;
+    family_t family;
+    smallint showqueue;
+    smallint oneline;
+    smallint up;
+    smallint flushed;
+    inet_prefix pfx;
+} FIX_ALIASING;
+typedef struct filter_t filter_t;
+
+#define G_filter (*(filter_t*)&bb_common_bufsiz1)
+
+
+static void print_link_flags(unsigned flags, unsigned mdown)
+{
+    static const int flag_masks[] = {
+        IFF_LOOPBACK, IFF_BROADCAST, IFF_POINTOPOINT,
+        IFF_MULTICAST, IFF_NOARP, IFF_UP, IFF_LOWER_UP };
+    static const char flag_labels[] ALIGN1 =
+        "LOOPBACK\0""BROADCAST\0""POINTOPOINT\0"
+        "MULTICAST\0""NOARP\0""UP\0""LOWER_UP\0";
+
+    bb_putchar('<');
+    if (flags & IFF_UP && !(flags & IFF_RUNNING))
+        printf("NO-CARRIER,");
     flags &= ~IFF_RUNNING;
-#define _PF(f) if (flags&IFF_##f) { \
-          flags &= ~IFF_##f; \
-          fprintf(fp, #f "%s", flags ? "," : ""); }
-    _PF(LOOPBACK);
-    _PF(BROADCAST);
-    _PF(POINTOPOINT);
-    _PF(MULTICAST);
-    _PF(NOARP);
 #if 0
     _PF(ALLMULTI);
@@ -65 +67 @@
     _PF(NOTRAILERS);
 #endif
-    _PF(UP);
-#undef _PF
+    flags = print_flags_separated(flag_masks, flag_labels, flags, ",");
     if (flags)
-        fprintf(fp, "%x", flags);
+        printf("%x", flags);
     if (mdown)
-        fprintf(fp, ",M-DOWN");
-    fprintf(fp, "> ");
+        printf(",M-DOWN");
+    printf("> ");
 }
 
@@ -84 +85 @@
 
     memset(&ifr, 0, sizeof(ifr));
-    strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, name);
     if (ioctl_or_warn(s, SIOCGIFTXQLEN, &ifr) < 0) {
         close(s);
@@ -95 +96 @@
 }
 
-static int print_linkinfo(struct sockaddr_nl ATTRIBUTE_UNUSED *who,
-        const struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
-{
-    FILE *fp = (FILE*)arg;
+static NOINLINE int print_linkinfo(const struct nlmsghdr *n)
+{
     struct ifinfomsg *ifi = NLMSG_DATA(n);
-    struct rtattr * tb[IFLA_MAX+1];
+    struct rtattr *tb[IFLA_MAX+1];
     int len = n->nlmsg_len;
-    unsigned m_flag = 0;
 
     if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK)
@@ -111 +109 @@
         return -1;
 
-    if (filter.ifindex && ifi->ifi_index != filter.ifindex)
-        return 0;
-    if (filter.up && !(ifi->ifi_flags&IFF_UP))
+    if (G_filter.ifindex && ifi->ifi_index != G_filter.ifindex)
+        return 0;
+    if (G_filter.up && !(ifi->ifi_flags & IFF_UP))
         return 0;
 
@@ -122 +120 @@
         return -1;
     }
-    if (filter.label
-     && (!filter.family || filter.family == AF_PACKET)
-     && fnmatch(filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0)
+    if (G_filter.label
+     && (!G_filter.family || G_filter.family == AF_PACKET)
+     && fnmatch(G_filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0)
     ) {
         return 0;
@@ -130 +128 @@
 
     if (n->nlmsg_type == RTM_DELLINK)
-        fprintf(fp, "Deleted ");
-
-    fprintf(fp, "%d: %s", ifi->ifi_index,
-        tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");
-
-    if (tb[IFLA_LINK]) {
-        SPRINT_BUF(b1);
-        int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
-        if (iflink == 0)
-            fprintf(fp, "@NONE: ");
-        else {
-            fprintf(fp, "@%s: ", ll_idx_n2a(iflink, b1));
-            m_flag = ll_index_to_flags(iflink);
-            m_flag = !(m_flag & IFF_UP);
-        }
-    } else {
-        fprintf(fp, ": ");
-    }
-    print_link_flags(fp, ifi->ifi_flags, m_flag);
+        printf("Deleted ");
+
+    printf("%d: %s", ifi->ifi_index,
+        /*tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>" - we checked tb[IFLA_IFNAME] above*/
+        (char*)RTA_DATA(tb[IFLA_IFNAME])
+    );
+
+    {
+        unsigned m_flag = 0;
+        if (tb[IFLA_LINK]) {
+            SPRINT_BUF(b1);
+            int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
+            if (iflink == 0)
+                printf("@NONE: ");
+            else {
+                printf("@%s: ", ll_idx_n2a(iflink, b1));
+                m_flag = ll_index_to_flags(iflink);
+                m_flag = !(m_flag & IFF_UP);
+            }
+        } else {
+            printf(": ");
+        }
+        print_link_flags(ifi->ifi_flags, m_flag);
+    }
 
     if (tb[IFLA_MTU])
-        fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
+        printf("mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
     if (tb[IFLA_QDISC])
-        fprintf(fp, "qdisc %s ", (char*)RTA_DATA(tb[IFLA_QDISC]));
+        printf("qdisc %s ", (char*)RTA_DATA(tb[IFLA_QDISC]));
 #ifdef IFLA_MASTER
     if (tb[IFLA_MASTER]) {
         SPRINT_BUF(b1);
-        fprintf(fp, "master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
+        printf("master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
     }
 #endif
-    if (filter.showqueue)
+    if (tb[IFLA_OPERSTATE]) {
+        static const char operstate_labels[] ALIGN1 =
+            "UNKNOWN\0""NOTPRESENT\0""DOWN\0""LOWERLAYERDOWN\0"
+            "TESTING\0""DORMANT\0""UP\0";
+        printf("state %s ", nth_string(operstate_labels,
+                    *(uint8_t *)RTA_DATA(tb[IFLA_OPERSTATE])));
+    }
+    if (G_filter.showqueue)
         print_queuelen((char*)RTA_DATA(tb[IFLA_IFNAME]));
 
-    if (!filter.family || filter.family == AF_PACKET) {
+    if (!G_filter.family || G_filter.family == AF_PACKET) {
         SPRINT_BUF(b1);
-        fprintf(fp, "%c    link/%s ", _SL_, ll_type_n2a(ifi->ifi_type, b1, sizeof(b1)));
+        printf("%c    link/%s ", _SL_, ll_type_n2a(ifi->ifi_type, b1));
 
         if (tb[IFLA_ADDRESS]) {
-            fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_ADDRESS]),
+            fputs(ll_addr_n2a(RTA_DATA(tb[IFLA_ADDRESS]),
                               RTA_PAYLOAD(tb[IFLA_ADDRESS]),
                               ifi->ifi_type,
-                              b1, sizeof(b1)));
+                              b1, sizeof(b1)), stdout);
         }
         if (tb[IFLA_BROADCAST]) {
-            if (ifi->ifi_flags&IFF_POINTOPOINT)
-                fprintf(fp, " peer ");
+            if (ifi->ifi_flags & IFF_POINTOPOINT)
+                printf(" peer ");
             else
-                fprintf(fp, " brd ");
-            fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_BROADCAST]),
+                printf(" brd ");
+            fputs(ll_addr_n2a(RTA_DATA(tb[IFLA_BROADCAST]),
                               RTA_PAYLOAD(tb[IFLA_BROADCAST]),
                               ifi->ifi_type,
-                              b1, sizeof(b1)));
-        }
-    }
-    fputc('\n', fp);
-    fflush(fp);
+                              b1, sizeof(b1)), stdout);
+        }
+    }
+    bb_putchar('\n');
+    /*fflush_all();*/
     return 0;
 }
@@ -191 +201 @@
 static int flush_update(void)
 {
-    if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
-        bb_perror_msg("failed to send flush request");
+    if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
+        bb_perror_msg("can't send flush request");
         return -1;
     }
-    filter.flushp = 0;
+    G_filter.flushp = 0;
     return 0;
 }
 
-static int print_addrinfo(struct sockaddr_nl ATTRIBUTE_UNUSED *who,
-        struct nlmsghdr *n, void ATTRIBUTE_UNUSED *arg)
-{
-    FILE *fp = (FILE*)arg;
+static int FAST_FUNC print_addrinfo(const struct sockaddr_nl *who UNUSED_PARAM,
+        struct nlmsghdr *n, void *arg UNUSED_PARAM)
+{
     struct ifaddrmsg *ifa = NLMSG_DATA(n);
     int len = n->nlmsg_len;
@@ -217 +226 @@
     }
 
-    if (filter.flushb && n->nlmsg_type != RTM_NEWADDR)
+    if (G_filter.flushb && n->nlmsg_type != RTM_NEWADDR)
         return 0;
 
@@ -228 +237 @@
         rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
 
-    if (filter.ifindex && filter.ifindex != ifa->ifa_index)
-        return 0;
-    if ((filter.scope^ifa->ifa_scope)&filter.scopemask)
-        return 0;
-    if ((filter.flags^ifa->ifa_flags)&filter.flagmask)
-        return 0;
-    if (filter.label) {
+    if (G_filter.ifindex && G_filter.ifindex != ifa->ifa_index)
+        return 0;
+    if ((G_filter.scope ^ ifa->ifa_scope) & G_filter.scopemask)
+        return 0;
+    if ((G_filter.flags ^ ifa->ifa_flags) & G_filter.flagmask)
+        return 0;
+    if (G_filter.label) {
         const char *label;
         if (rta_tb[IFA_LABEL])
@@ -240 +249 @@
         else
             label = ll_idx_n2a(ifa->ifa_index, b1);
-        if (fnmatch(filter.label, label, 0) != 0)
+        if (fnmatch(G_filter.label, label, 0) != 0)
             return 0;
     }
-    if (filter.pfx.family) {
+    if (G_filter.pfx.family) {
         if (rta_tb[IFA_LOCAL]) {
             inet_prefix dst;
@@ -249 +258 @@
             dst.family = ifa->ifa_family;
             memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL]));
-            if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
+            if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
                 return 0;
         }
     }
 
-    if (filter.flushb) {
+    if (G_filter.flushb) {
         struct nlmsghdr *fn;
-        if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
+        if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
             if (flush_update())
                 return -1;
         }
-        fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
+        fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
         memcpy(fn, n, n->nlmsg_len);
         fn->nlmsg_type = RTM_DELADDR;
         fn->nlmsg_flags = NLM_F_REQUEST;
-        fn->nlmsg_seq = ++filter.rth->seq;
-        filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
-        filter.flushed++;
+        fn->nlmsg_seq = ++G_filter.rth->seq;
+        G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
+        G_filter.flushed = 1;
         return 0;
     }
 
     if (n->nlmsg_type == RTM_DELADDR)
-        fprintf(fp, "Deleted ");
-
-    if (filter.oneline)
-        fprintf(fp, "%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));
+        printf("Deleted ");
+
+    if (G_filter.oneline)
+        printf("%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index));
     if (ifa->ifa_family == AF_INET)
-        fprintf(fp, "    inet ");
+        printf("    inet ");
     else if (ifa->ifa_family == AF_INET6)
-        fprintf(fp, "    inet6 ");
+        printf("    inet6 ");
     else
-        fprintf(fp, "    family %d ", ifa->ifa_family);
+        printf("    family %d ", ifa->ifa_family);
 
     if (rta_tb[IFA_LOCAL]) {
-        fprintf(fp, "%s", rt_addr_n2a(ifa->ifa_family,
-                          RTA_PAYLOAD(rta_tb[IFA_LOCAL]),
+        fputs(rt_addr_n2a(ifa->ifa_family,
                           RTA_DATA(rta_tb[IFA_LOCAL]),
-                          abuf, sizeof(abuf)));
-
-        if (rta_tb[IFA_ADDRESS] == NULL ||
-            memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), 4) == 0) {
-            fprintf(fp, "/%d ", ifa->ifa_prefixlen);
+                          abuf, sizeof(abuf)), stdout);
+
+        if (rta_tb[IFA_ADDRESS] == NULL
+         || memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), 4) == 0
+        ) {
+            printf("/%d ", ifa->ifa_prefixlen);
         } else {
-            fprintf(fp, " peer %s/%d ",
+            printf(" peer %s/%d ",
                 rt_addr_n2a(ifa->ifa_family,
-                        RTA_PAYLOAD(rta_tb[IFA_ADDRESS]),
                         RTA_DATA(rta_tb[IFA_ADDRESS]),
                         abuf, sizeof(abuf)),
@@ -302 +310 @@
 
     if (rta_tb[IFA_BROADCAST]) {
-        fprintf(fp, "brd %s ",
+        printf("brd %s ",
             rt_addr_n2a(ifa->ifa_family,
-                    RTA_PAYLOAD(rta_tb[IFA_BROADCAST]),
                     RTA_DATA(rta_tb[IFA_BROADCAST]),
                     abuf, sizeof(abuf)));
     }
     if (rta_tb[IFA_ANYCAST]) {
-        fprintf(fp, "any %s ",
+        printf("any %s ",
             rt_addr_n2a(ifa->ifa_family,
-                    RTA_PAYLOAD(rta_tb[IFA_ANYCAST]),
                     RTA_DATA(rta_tb[IFA_ANYCAST]),
                     abuf, sizeof(abuf)));
     }
-    fprintf(fp, "scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope, b1, sizeof(b1)));
-    if (ifa->ifa_flags&IFA_F_SECONDARY) {
+    printf("scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope, b1));
+    if (ifa->ifa_flags & IFA_F_SECONDARY) {
         ifa->ifa_flags &= ~IFA_F_SECONDARY;
-        fprintf(fp, "secondary ");
-    }
-    if (ifa->ifa_flags&IFA_F_TENTATIVE) {
+        printf("secondary ");
+    }
+    if (ifa->ifa_flags & IFA_F_TENTATIVE) {
         ifa->ifa_flags &= ~IFA_F_TENTATIVE;
-        fprintf(fp, "tentative ");
-    }
-    if (ifa->ifa_flags&IFA_F_DEPRECATED) {
+        printf("tentative ");
+    }
+    if (ifa->ifa_flags & IFA_F_DEPRECATED) {
         ifa->ifa_flags &= ~IFA_F_DEPRECATED;
-        fprintf(fp, "deprecated ");
-    }
-    if (!(ifa->ifa_flags&IFA_F_PERMANENT)) {
-        fprintf(fp, "dynamic ");
+        printf("deprecated ");
+    }
+    if (!(ifa->ifa_flags & IFA_F_PERMANENT)) {
+        printf("dynamic ");
     } else
         ifa->ifa_flags &= ~IFA_F_PERMANENT;
     if (ifa->ifa_flags)
-        fprintf(fp, "flags %02x ", ifa->ifa_flags);
+        printf("flags %02x ", ifa->ifa_flags);
     if (rta_tb[IFA_LABEL])
-        fprintf(fp, "%s", (char*)RTA_DATA(rta_tb[IFA_LABEL]));
+        fputs((char*)RTA_DATA(rta_tb[IFA_LABEL]), stdout);
     if (rta_tb[IFA_CACHEINFO]) {
         struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
         char buf[128];
-        fputc(_SL_, fp);
+        bb_putchar(_SL_);
         if (ci->ifa_valid == 0xFFFFFFFFU)
             sprintf(buf, "valid_lft forever");
@@ -348 +354 @@
         else
             sprintf(buf+strlen(buf), " preferred_lft %dsec", ci->ifa_prefered);
-        fprintf(fp, "       %s", buf);
-    }
-    fputc('\n', fp);
-    fflush(fp);
+        printf("       %s", buf);
+    }
+    bb_putchar('\n');
+    /*fflush_all();*/
     return 0;
 }
 
 
-struct nlmsg_list
-{
+struct nlmsg_list {
     struct nlmsg_list *next;
-    struct nlmsghdr   h;
+    struct nlmsghdr   h;
 };
 
-static int print_selected_addrinfo(int ifindex, struct nlmsg_list *ainfo, FILE *fp)
+static int print_selected_addrinfo(int ifindex, struct nlmsg_list *ainfo)
 {
     for (; ainfo; ainfo = ainfo->next) {
@@ -370 +375 @@
         if (n->nlmsg_type != RTM_NEWADDR)
             continue;
-
         if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifa)))
             return -1;
-
-        if (ifa->ifa_index != ifindex ||
-            (filter.family && filter.family != ifa->ifa_family))
+        if (ifa->ifa_index != ifindex
+         || (G_filter.family && G_filter.family != ifa->ifa_family)
+        ) {
             continue;
-
-        print_addrinfo(NULL, n, fp);
+        }
+        print_addrinfo(NULL, n, NULL);
     }
     return 0;
@@ -384 +388 @@
 
 
-static int store_nlmsg(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
+static int FAST_FUNC store_nlmsg(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
 {
     struct nlmsg_list **linfo = (struct nlmsg_list**)arg;
@@ -390 +394 @@
     struct nlmsg_list **lp;
 
-    h = malloc(n->nlmsg_len+sizeof(void*));
-    if (h == NULL)
-        return -1;
+    h = xzalloc(n->nlmsg_len + sizeof(void*));
 
     memcpy(&h->h, n, n->nlmsg_len);
-    h->next = NULL;
-
-    for (lp = linfo; *lp; lp = &(*lp)->next) /* NOTHING */;
+    /*h->next = NULL; - xzalloc did it */
+
+    for (lp = linfo; *lp; lp = &(*lp)->next)
+        continue;
     *lp = h;
 
@@ -406 +409 @@
 static void ipaddr_reset_filter(int _oneline)
 {
-    memset(&filter, 0, sizeof(filter));
-    filter.oneline = _oneline;
+    memset(&G_filter, 0, sizeof(G_filter));
+    G_filter.oneline = _oneline;
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-int ipaddr_list_or_flush(int argc, char **argv, int flush)
+int FAST_FUNC ipaddr_list_or_flush(char **argv, int flush)
 {
     static const char option[] ALIGN1 = "to\0""scope\0""up\0""label\0""dev\0";
@@ -423 +426 @@
 
     ipaddr_reset_filter(oneline);
-    filter.showqueue = 1;
-
-    if (filter.family == AF_UNSPEC)
-        filter.family = preferred_family;
+    G_filter.showqueue = 1;
+
+    if (G_filter.family == AF_UNSPEC)
+        G_filter.family = preferred_family;
 
     if (flush) {
-        if (argc <= 0) {
+        if (!*argv) {
             bb_error_msg_and_die(bb_msg_requires_arg, "flush");
         }
-        if (filter.family == AF_PACKET) {
-            bb_error_msg_and_die("cannot flush link addresses");
-        }
-    }
-
-    while (argc > 0) {
-        const int option_num = index_in_strings(option, *argv);
-        switch (option_num) {
-            case 0: /* to */
+        if (G_filter.family == AF_PACKET) {
+            bb_error_msg_and_die("can't flush link addresses");
+        }
+    }
+
+    while (*argv) {
+        const smalluint key = index_in_strings(option, *argv);
+        if (key == 0) { /* to */
+            NEXT_ARG();
+            get_prefix(&G_filter.pfx, *argv, G_filter.family);
+            if (G_filter.family == AF_UNSPEC) {
+                G_filter.family = G_filter.pfx.family;
+            }
+        } else if (key == 1) { /* scope */
+            uint32_t scope = 0;
+            NEXT_ARG();
+            G_filter.scopemask = -1;
+            if (rtnl_rtscope_a2n(&scope, *argv)) {
+                if (strcmp(*argv, "all") != 0) {
+                    invarg(*argv, "scope");
+                }
+                scope = RT_SCOPE_NOWHERE;
+                G_filter.scopemask = 0;
+            }
+            G_filter.scope = scope;
+        } else if (key == 2) { /* up */
+            G_filter.up = 1;
+        } else if (key == 3) { /* label */
+            NEXT_ARG();
+            G_filter.label = *argv;
+        } else {
+            if (key == 4) /* dev */
                 NEXT_ARG();
-                get_prefix(&filter.pfx, *argv, filter.family);
-                if (filter.family == AF_UNSPEC) {
-                    filter.family = filter.pfx.family;
-                }
-                break;
-            case 1: /* scope */
-            {
-                uint32_t scope = 0;
-                NEXT_ARG();
-                filter.scopemask = -1;
-                if (rtnl_rtscope_a2n(&scope, *argv)) {
-                    if (strcmp(*argv, "all") != 0) {
-                        invarg(*argv, "scope");
-                    }
-                    scope = RT_SCOPE_NOWHERE;
-                    filter.scopemask = 0;
-                }
-                filter.scope = scope;
-                break;
-            }
-            case 2: /* up */
-                filter.up = 1;
-                break;
-            case 3: /* label */
-                NEXT_ARG();
-                filter.label = *argv;
-                break;
-            case 4: /* dev */
-                NEXT_ARG();
-            default:
-                if (filter_dev) {
-                    duparg2("dev", *argv);
-                }
-                filter_dev = *argv;
+            if (filter_dev)
+                duparg2("dev", *argv);
+            filter_dev = *argv;
         }
         argv++;
-        argc--;
     }
 
@@ -487 +481 @@
 
     if (filter_dev) {
-        filter.ifindex = xll_name_to_index(filter_dev);
+        G_filter.ifindex = xll_name_to_index(filter_dev);
     }
 
@@ -493 +487 @@
         char flushb[4096-512];
 
-        filter.flushb = flushb;
-        filter.flushp = 0;
-        filter.flushe = sizeof(flushb);
-        filter.rth = &rth;
+        G_filter.flushb = flushb;
+        G_filter.flushp = 0;
+        G_filter.flushe = sizeof(flushb);
+        G_filter.rth = &rth;
 
         for (;;) {
-            xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);
-            filter.flushed = 0;
-            xrtnl_dump_filter(&rth, print_addrinfo, stdout);
-            if (filter.flushed == 0) {
+            xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETADDR);
+            G_filter.flushed = 0;
+            xrtnl_dump_filter(&rth, print_addrinfo, NULL);
+            if (G_filter.flushed == 0) {
                 return 0;
             }
-            if (flush_update() < 0)
+            if (flush_update() < 0) {
                 return 1;
-        }
-    }
-
-    if (filter.family != AF_PACKET) {
-        xrtnl_wilddump_request(&rth, filter.family, RTM_GETADDR);
+            }
+        }
+    }
+
+    if (G_filter.family != AF_PACKET) {
+        xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETADDR);
         xrtnl_dump_filter(&rth, store_nlmsg, &ainfo);
     }
 
 
-    if (filter.family && filter.family != AF_PACKET) {
+    if (G_filter.family && G_filter.family != AF_PACKET) {
         struct nlmsg_list **lp;
-        lp=&linfo;
-
-        if (filter.oneline)
+        lp = &linfo;
+
+        if (G_filter.oneline)
             no_link = 1;
 
-        while ((l=*lp)!=NULL) {
+        while ((l = *lp) != NULL) {
             int ok = 0;
             struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
             struct nlmsg_list *a;
 
-            for (a=ainfo; a; a=a->next) {
+            for (a = ainfo; a; a = a->next) {
                 struct nlmsghdr *n = &a->h;
                 struct ifaddrmsg *ifa = NLMSG_DATA(n);
 
-                if (ifa->ifa_index != ifi->ifi_index ||
-                    (filter.family && filter.family != ifa->ifa_family))
+                if (ifa->ifa_index != ifi->ifi_index
+                 || (G_filter.family && G_filter.family != ifa->ifa_family)
+                ) {
                     continue;
-                if ((filter.scope^ifa->ifa_scope)&filter.scopemask)
+                }
+                if ((G_filter.scope ^ ifa->ifa_scope) & G_filter.scopemask)
                     continue;
-                if ((filter.flags^ifa->ifa_flags)&filter.flagmask)
+                if ((G_filter.flags ^ ifa->ifa_flags) & G_filter.flagmask)
                     continue;
-                if (filter.pfx.family || filter.label) {
+                if (G_filter.pfx.family || G_filter.label) {
                     struct rtattr *tb[IFA_MAX+1];
                     memset(tb, 0, sizeof(tb));
@@ -546 +543 @@
                         tb[IFA_LOCAL] = tb[IFA_ADDRESS];
 
-                    if (filter.pfx.family && tb[IFA_LOCAL]) {
+                    if (G_filter.pfx.family && tb[IFA_LOCAL]) {
                         inet_prefix dst;
                         memset(&dst, 0, sizeof(dst));
                         dst.family = ifa->ifa_family;
                         memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));
-                        if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
+                        if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
                             continue;
                     }
-                    if (filter.label) {
+                    if (G_filter.label) {
                         SPRINT_BUF(b1);
                         const char *label;
@@ -561 +558 @@
                         else
                             label = ll_idx_n2a(ifa->ifa_index, b1);
-                        if (fnmatch(filter.label, label, 0) != 0)
+                        if (fnmatch(G_filter.label, label, 0) != 0)
                             continue;
                     }
@@ -577 +574 @@
 
     for (l = linfo; l; l = l->next) {
-        if (no_link || print_linkinfo(NULL, &l->h, stdout) == 0) {
+        if (no_link || print_linkinfo(&l->h) == 0) {
             struct ifinfomsg *ifi = NLMSG_DATA(&l->h);
-            if (filter.family != AF_PACKET)
-                print_selected_addrinfo(ifi->ifi_index, ainfo, stdout);
-        }
-        fflush(stdout); /* why? */
+            if (G_filter.family != AF_PACKET)
+                print_selected_addrinfo(ifi->ifi_index, ainfo);
+        }
     }
 
@@ -598 +594 @@
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int ipaddr_modify(int cmd, int argc, char **argv)
+static int ipaddr_modify(int cmd, char **argv)
 {
     static const char option[] ALIGN1 =
@@ -626 +622 @@
     req.ifa.ifa_family = preferred_family;
 
-    while (argc > 0) {
-        const int option_num = index_in_strings(option, *argv);
-        switch (option_num) {
-            case 0: /* peer */
-            case 1: /* remote */
+    while (*argv) {
+        const smalluint arg = index_in_strings(option, *argv);
+        if (arg <= 1) { /* peer, remote */
+            NEXT_ARG();
+
+            if (peer_len) {
+                duparg("peer", *argv);
+            }
+            get_prefix(&peer, *argv, req.ifa.ifa_family);
+            peer_len = peer.bytelen;
+            if (req.ifa.ifa_family == AF_UNSPEC) {
+                req.ifa.ifa_family = peer.family;
+            }
+            addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &peer.data, peer.bytelen);
+            req.ifa.ifa_prefixlen = peer.bitlen;
+        } else if (arg <= 3) { /* broadcast, brd */
+            inet_prefix addr;
+            NEXT_ARG();
+            if (brd_len) {
+                duparg("broadcast", *argv);
+            }
+            if (LONE_CHAR(*argv, '+')) {
+                brd_len = -1;
+            } else if (LONE_DASH(*argv)) {
+                brd_len = -2;
+            } else {
+                get_addr(&addr, *argv, req.ifa.ifa_family);
+                if (req.ifa.ifa_family == AF_UNSPEC)
+                    req.ifa.ifa_family = addr.family;
+                addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &addr.data, addr.bytelen);
+                brd_len = addr.bytelen;
+            }
+        } else if (arg == 4) { /* anycast */
+            inet_prefix addr;
+            NEXT_ARG();
+            if (any_len) {
+                duparg("anycast", *argv);
+            }
+            get_addr(&addr, *argv, req.ifa.ifa_family);
+            if (req.ifa.ifa_family == AF_UNSPEC) {
+                req.ifa.ifa_family = addr.family;
+            }
+            addattr_l(&req.n, sizeof(req), IFA_ANYCAST, &addr.data, addr.bytelen);
+            any_len = addr.bytelen;
+        } else if (arg == 5) { /* scope */
+            uint32_t scope = 0;
+            NEXT_ARG();
+            if (rtnl_rtscope_a2n(&scope, *argv)) {
+                invarg(*argv, "scope");
+            }
+            req.ifa.ifa_scope = scope;
+            scoped = 1;
+        } else if (arg == 6) { /* dev */
+            NEXT_ARG();
+            d = *argv;
+        } else if (arg == 7) { /* label */
+            NEXT_ARG();
+            l = *argv;
+            addattr_l(&req.n, sizeof(req), IFA_LABEL, l, strlen(l) + 1);
+        } else {
+            if (arg == 8) /* local */
                 NEXT_ARG();
-
-                if (peer_len) {
-                    duparg("peer", *argv);
-                }
-                get_prefix(&peer, *argv, req.ifa.ifa_family);
-                peer_len = peer.bytelen;
-                if (req.ifa.ifa_family == AF_UNSPEC) {
-                    req.ifa.ifa_family = peer.family;
-                }
-                addattr_l(&req.n, sizeof(req), IFA_ADDRESS, &peer.data, peer.bytelen);
-                req.ifa.ifa_prefixlen = peer.bitlen;
-                break;
-            case 2: /* broadcast */
-            case 3: /* brd */
-            {
-                inet_prefix addr;
-                NEXT_ARG();
-                if (brd_len) {
-                    duparg("broadcast", *argv);
-                }
-                if (LONE_CHAR(*argv, '+')) {
-                    brd_len = -1;
-                }
-                else if (LONE_DASH(*argv)) {
-                    brd_len = -2;
-                } else {
-                    get_addr(&addr, *argv, req.ifa.ifa_family);
-                    if (req.ifa.ifa_family == AF_UNSPEC)
-                        req.ifa.ifa_family = addr.family;
-                    addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &addr.data, addr.bytelen);
-                    brd_len = addr.bytelen;
-                }
-                break;
-            }
-            case 4: /* anycast */
-            {
-                inet_prefix addr;
-                NEXT_ARG();
-                if (any_len) {
-                    duparg("anycast", *argv);
-                }
-                get_addr(&addr, *argv, req.ifa.ifa_family);
-                if (req.ifa.ifa_family == AF_UNSPEC) {
-                    req.ifa.ifa_family = addr.family;
-                }
-                addattr_l(&req.n, sizeof(req), IFA_ANYCAST, &addr.data, addr.bytelen);
-                any_len = addr.bytelen;
-                break;
-            }
-            case 5: /* scope */
-            {
-                uint32_t scope = 0;
-                NEXT_ARG();
-                if (rtnl_rtscope_a2n(&scope, *argv)) {
-                    invarg(*argv, "scope");
-                }
-                req.ifa.ifa_scope = scope;
-                scoped = 1;
-                break;
-            }
-            case 6: /* dev */
-                NEXT_ARG();
-                d = *argv;
-                break;
-            case 7: /* label */
-                NEXT_ARG();
-                l = *argv;
-                addattr_l(&req.n, sizeof(req), IFA_LABEL, l, strlen(l)+1);
-                break;
-            case 8: /* local */
-                NEXT_ARG();
-            default:
-                if (local_len) {
-                    duparg2("local", *argv);
-                }
-                get_prefix(&lcl, *argv, req.ifa.ifa_family);
-                if (req.ifa.ifa_family == AF_UNSPEC) {
-                    req.ifa.ifa_family = lcl.family;
-                }
-                addattr_l(&req.n, sizeof(req), IFA_LOCAL, &lcl.data, lcl.bytelen);
-                local_len = lcl.bytelen;
-        }
-        argc--;
+            if (local_len) {
+                duparg2("local", *argv);
+            }
+            get_prefix(&lcl, *argv, req.ifa.ifa_family);
+            if (req.ifa.ifa_family == AF_UNSPEC) {
+                req.ifa.ifa_family = lcl.family;
+            }
+            addattr_l(&req.n, sizeof(req), IFA_LOCAL, &lcl.data, lcl.bytelen);
+            local_len = lcl.bytelen;
+        }
         argv++;
     }
 
-    if (d == NULL) {
-        bb_error_msg(bb_msg_requires_arg,"\"dev\"");
-        return -1;
+    if (!d) {
+        /* There was no "dev IFACE", but we need that */
+        bb_error_msg_and_die("need \"dev IFACE\"");
     }
     if (l && strncmp(d, l, strlen(d)) != 0) {
@@ -767 +746 @@
 
 /* Return value becomes exitcode. It's okay to not return at all */
-int do_ipaddr(int argc, char **argv)
+int FAST_FUNC do_ipaddr(char **argv)
 {
     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 */
-
+    smalluint cmd = 2;
     if (*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);
-}
+        cmd = index_in_substrings(commands, *argv);
+        if (cmd > 5)
+            bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        argv++;
+        if (cmd <= 1)
+            return ipaddr_modify((cmd == 0) ? RTM_NEWADDR : RTM_DELADDR, argv);
+    }
+    /* 2 == list, 3 == show, 4 == lst */
+    return ipaddr_list_or_flush(argv, cmd == 5);
+}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * iplink.c "ip link".
- *
  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
-//#include <sys/ioctl.h>
-//#include <sys/socket.h>
 #include <net/if.h>
 #include <net/if_packet.h>
@@ -19 +14 @@
 #include "utils.h"
 
+#ifndef IFLA_LINKINFO
+# define IFLA_LINKINFO 18
+# define IFLA_INFO_KIND 1
+#endif
+
 /* taken from linux/sockios.h */
-#define SIOCSIFNAME 0x8923      /* set interface name */
-
-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);
-}
+#define SIOCSIFNAME  0x8923  /* set interface name */
 
 /* Exits on error */
@@ -48 +42 @@
     int fd;
 
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     fd = get_ctl_fd();
     xioctl(fd, SIOCGIFFLAGS, &ifr);
@@ -65 +59 @@
     int fd;
 
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
-    strncpy(ifr.ifr_newname, newdev, sizeof(ifr.ifr_newname));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
+    strncpy_IFNAMSIZ(ifr.ifr_newname, newdev);
     fd = get_ctl_fd();
     xioctl(fd, SIOCSIFNAME, &ifr);
@@ -80 +74 @@
     s = get_ctl_fd();
     memset(&ifr, 0, sizeof(ifr));
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     ifr.ifr_qlen = qlen;
     xioctl(s, SIOCSIFTXQLEN, &ifr);
@@ -94 +88 @@
     s = get_ctl_fd();
     memset(&ifr, 0, sizeof(ifr));
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     ifr.ifr_mtu = mtu;
     xioctl(s, SIOCSIFMTU, &ifr);
@@ -111 +105 @@
 
     memset(&ifr, 0, sizeof(ifr));
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     xioctl(s, SIOCGIFINDEX, &ifr);
 
@@ -119 +113 @@
     me.sll_protocol = htons(ETH_P_LOOP);
     xbind(s, (struct sockaddr*)&me, sizeof(me));
-
     alen = sizeof(me);
-    if (getsockname(s, (struct sockaddr*)&me, &alen) == -1) {
-        bb_perror_msg_and_die("getsockname");
-    }
+    getsockname(s, (struct sockaddr*)&me, &alen);
+    //never happens:
+    //if (getsockname(s, (struct sockaddr*)&me, &alen) == -1)
+    //  bb_perror_msg_and_die("getsockname");
     close(s);
     *htype = me.sll_hatype;
@@ -135 +129 @@
 
     memset(ifr, 0, sizeof(*ifr));
-    strncpy(ifr->ifr_name, dev, sizeof(ifr->ifr_name));
+    strncpy_IFNAMSIZ(ifr->ifr_name, dev);
     ifr->ifr_hwaddr.sa_family = hatype;
-    alen = ll_addr_a2n((unsigned char *)(ifr->ifr_hwaddr.sa_data), 14, lla);
+
+    alen = hatype == 1/*ARPHRD_ETHER*/ ? 14/*ETH_HLEN*/ : 19/*INFINIBAND_HLEN*/;
+    alen = ll_addr_a2n((unsigned char *)(ifr->ifr_hwaddr.sa_data), alen, lla);
     if (alen < 0)
-        exit(1);
+        exit(EXIT_FAILURE);
     if (alen != halen) {
         bb_error_msg_and_die("wrong address (%s) length: expected %d bytes", lla, halen);
@@ -159 +155 @@
 
 
+static void die_must_be_on_off(const char *msg) NORETURN;
+static void die_must_be_on_off(const char *msg)
+{
+    bb_error_msg_and_die("argument of \"%s\" must be \"on\" or \"off\"", msg);
+}
+
 /* Return value becomes exitcode. It's okay to not return at all */
-static int do_set(int argc, char **argv)
+static int do_set(char **argv)
 {
     char *dev = NULL;
@@ -173 +175 @@
     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 };
+        "up\0""down\0""name\0""mtu\0""qlen\0""multicast\0"
+        "arp\0""address\0""dev\0";
+    enum { ARG_up = 0, ARG_down, ARG_name, ARG_mtu, ARG_qlen, ARG_multicast,
+        ARG_arp, ARG_addr, ARG_dev };
+    static const char str_on_off[] ALIGN1 = "on\0""off\0";
+    enum { PARM_on = 0, PARM_off };
     smalluint key;
 
-    while (argc > 0) {
-        key = index_in_strings(keywords, *argv) + 1;
+    while (*argv) {
+        /* substring search ensures that e.g. "addr" and "address"
+         * are both accepted */
+        key = index_in_substrings(keywords, *argv);
         if (key == ARG_up) {
             mask |= IFF_UP;
@@ -194 +200 @@
             if (mtu != -1)
                 duparg("mtu", *argv);
-            if (get_integer(&mtu, *argv, 0))
-                invarg(*argv, "mtu");
-        } else if (key == ARG_multicast) {
-            NEXT_ARG();
-            mask |= IFF_MULTICAST;
-            key = index_in_strings(keywords, *argv) + 1;
-            if (key == PARM_on) {
-                flags |= IFF_MULTICAST;
-            } else if (key == PARM_off) {
-                flags &= ~IFF_MULTICAST;
-            } else
-                on_off("multicast");
-        } else if (key == ARG_arp) {
-            NEXT_ARG();
-            mask |= IFF_NOARP;
-            key = index_in_strings(keywords, *argv) + 1;
-            if (key == PARM_on) {
-                flags &= ~IFF_NOARP;
-            } else if (key == PARM_off) {
-                flags |= IFF_NOARP;
-            } else
-                on_off("arp");
+            mtu = get_unsigned(*argv, "mtu");
+        } else if (key == ARG_qlen) {
+            NEXT_ARG();
+            if (qlen != -1)
+                duparg("qlen", *argv);
+            qlen = get_unsigned(*argv, "qlen");
         } else if (key == ARG_addr) {
             NEXT_ARG();
             newaddr = *argv;
-        } else {
+        } else if (key >= ARG_dev) {
             if (key == ARG_dev) {
                 NEXT_ARG();
@@ -226 +216 @@
                 duparg2("dev", *argv);
             dev = *argv;
-        }
-        argc--; argv++;
+        } else {
+            int param;
+            NEXT_ARG();
+            param = index_in_strings(str_on_off, *argv);
+            if (key == ARG_multicast) {
+                if (param < 0)
+                    die_must_be_on_off("multicast");
+                mask |= IFF_MULTICAST;
+                if (param == PARM_on)
+                    flags |= IFF_MULTICAST;
+                else
+                    flags &= ~IFF_MULTICAST;
+            } else if (key == ARG_arp) {
+                if (param < 0)
+                    die_must_be_on_off("arp");
+                mask |= IFF_NOARP;
+                if (param == PARM_on)
+                    flags &= ~IFF_NOARP;
+                else
+                    flags |= IFF_NOARP;
+            }
+        }
+        argv++;
     }
 
@@ -238 +249 @@
         if (newaddr) {
             parse_address(dev, htype, halen, newaddr, &ifr0);
+            set_address(&ifr0, 0);
         }
         if (newbrd) {
             parse_address(dev, htype, halen, newbrd, &ifr1);
+            set_address(&ifr1, 1);
         }
     }
@@ -254 +267 @@
         set_mtu(dev, mtu);
     }
-    if (newaddr || newbrd) {
-        if (newbrd) {
-            set_address(&ifr1, 1);
-        }
-        if (newaddr) {
-            set_address(&ifr0, 0);
-        }
-    }
     if (mask)
         do_chflags(dev, flags, mask);
@@ -267 +272 @@
 }
 
-static int ipaddr_list_link(int argc, char **argv)
+static int ipaddr_list_link(char **argv)
 {
     preferred_family = AF_PACKET;
-    return ipaddr_list_or_flush(argc, argv, 0);
-}
-
+    return ipaddr_list_or_flush(argv, 0);
+}
+
+#ifndef NLMSG_TAIL
+#define NLMSG_TAIL(nmsg) \
+    ((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
+#endif
 /* Return value becomes exitcode. It's okay to not return at all */
-int do_iplink(int argc, char **argv)
+static int do_change(char **argv, const unsigned rtm)
 {
     static const char keywords[] ALIGN1 =
-        "set\0""show\0""lst\0""list\0";
-    smalluint key;
-    if (argc <= 0)
-        return ipaddr_list_link(0, NULL);
-    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);
-}
+        "link\0""name\0""type\0""dev\0";
+    enum {
+        ARG_link,
+        ARG_name,
+        ARG_type,
+        ARG_dev,
+    };
+    struct rtnl_handle rth;
+    struct {
+        struct nlmsghdr  n;
+        struct ifinfomsg i;
+        char             buf[1024];
+    } req;
+    smalluint arg;
+    char *name_str = NULL, *link_str = NULL, *type_str = NULL, *dev_str = NULL;
+
+    memset(&req, 0, sizeof(req));
+
+    req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
+    req.n.nlmsg_flags = NLM_F_REQUEST;
+    req.n.nlmsg_type = rtm;
+    req.i.ifi_family = preferred_family;
+    if (rtm == RTM_NEWLINK)
+        req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
+
+    while (*argv) {
+        arg = index_in_substrings(keywords, *argv);
+        if (arg == ARG_link) {
+            NEXT_ARG();
+            link_str = *argv;
+        } else if (arg == ARG_name) {
+            NEXT_ARG();
+            name_str = *argv;
+        } else if (arg == ARG_type) {
+            NEXT_ARG();
+            type_str = *argv;
+        } else {
+            if (arg == ARG_dev) {
+                if (dev_str)
+                    duparg(*argv, "dev");
+                NEXT_ARG();
+            }
+            dev_str = *argv;
+        }
+        argv++;
+    }
+    xrtnl_open(&rth);
+    ll_init_map(&rth);
+    if (type_str) {
+        struct rtattr *linkinfo = NLMSG_TAIL(&req.n);
+
+        addattr_l(&req.n, sizeof(req), IFLA_LINKINFO, NULL, 0);
+        addattr_l(&req.n, sizeof(req), IFLA_INFO_KIND, type_str,
+                strlen(type_str));
+        linkinfo->rta_len = (void *)NLMSG_TAIL(&req.n) - (void *)linkinfo;
+    }
+    if (rtm != RTM_NEWLINK) {
+        if (!dev_str)
+            return 1; /* Need a device to delete */
+        req.i.ifi_index = xll_name_to_index(dev_str);
+    } else {
+        if (!name_str)
+            name_str = dev_str;
+        if (link_str) {
+            int idx = xll_name_to_index(link_str);
+            addattr_l(&req.n, sizeof(req), IFLA_LINK, &idx, 4);
+        }
+    }
+    if (name_str) {
+        const size_t name_len = strlen(name_str) + 1;
+        if (name_len < 2 || name_len > IFNAMSIZ)
+            invarg(name_str, "name");
+        addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name_str, name_len);
+    }
+    if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+        return 2;
+    return 0;
+}
+
+/* Return value becomes exitcode. It's okay to not return at all */
+int FAST_FUNC do_iplink(char **argv)
+{
+    static const char keywords[] ALIGN1 =
+        "add\0""delete\0""set\0""show\0""lst\0""list\0";
+    if (*argv) {
+        smalluint key = index_in_substrings(keywords, *argv);
+        if (key > 5) /* invalid argument */
+            bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        argv++;
+        if (key <= 1) /* add/delete */
+            return do_change(argv, key ? RTM_DELLINK : RTM_NEWLINK);
+        else if (key == 2) /* set */
+            return do_set(argv);
+    }
+    /* show, lst, list */
+    return ipaddr_list_link(argv);
+}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * iproute.c        "ip route".
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
  *
- * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
  */
 
-#include "ip_common.h"  /* #include "libbb.h" is inside */
+#include "ip_common.h"  /* #include "libbb.h" is inside */
 #include "rt_names.h"
 #include "utils.h"
@@ -23 +20 @@
 
 
-typedef struct filter_t {
+struct filter_t {
     int tb;
-    int flushed;
+    smallint flushed;
     char *flushb;
     int flushp;
     int flushe;
     struct rtnl_handle *rth;
-    int protocol, protocolmask;
-    int scope, scopemask;
-    int type, typemask;
-    int tos, tosmask;
+    //int protocol, protocolmask; - write-only fields?!
+    //int scope, scopemask; - unused
+    //int type; - read-only
+    //int typemask; - unused
+    //int tos, tosmask; - unused
     int iif, iifmask;
     int oif, oifmask;
-    int realm, realmmask;
-    inet_prefix rprefsrc;
+    //int realm, realmmask; - unused
+    //inet_prefix rprefsrc; - read-only
     inet_prefix rvia;
     inet_prefix rdst;
@@ -43 +41 @@
     inet_prefix rsrc;
     inet_prefix msrc;
-} filter_t;
-
-#define filter (*(filter_t*)&bb_common_bufsiz1)
+} FIX_ALIASING;
+typedef struct filter_t filter_t;
+
+#define G_filter (*(filter_t*)&bb_common_bufsiz1)
 
 static int flush_update(void)
 {
-    if (rtnl_send(filter.rth, filter.flushb, filter.flushp) < 0) {
-        bb_perror_msg("failed to send flush request");
+    if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
+        bb_perror_msg("can't send flush request");
         return -1;
     }
-    filter.flushp = 0;
+    G_filter.flushp = 0;
     return 0;
 }
@@ -65 +64 @@
         return hz_internal;
 
-    fp = fopen("/proc/net/psched", "r");
+    fp = fopen_for_read("/proc/net/psched");
     if (fp) {
         unsigned nom, denom;
@@ -79 +78 @@
 }
 
-static int print_route(struct sockaddr_nl *who ATTRIBUTE_UNUSED,
-        struct nlmsghdr *n, void *arg)
+static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
+        struct nlmsghdr *n, void *arg UNUSED_PARAM)
 {
-    FILE *fp = (FILE*)arg;
     struct rtmsg *r = NLMSG_DATA(n);
     int len = n->nlmsg_len;
@@ -92 +90 @@
     SPRINT_BUF(b1);
 
-
     if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
         fprintf(stderr, "Not a route: %08x %08x %08x\n",
@@ -98 +95 @@
         return 0;
     }
-    if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
+    if (G_filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
         return 0;
     len -= NLMSG_LENGTH(sizeof(*r));
@@ -110 +107 @@
 
     if (r->rtm_family == AF_INET6) {
-        if (filter.tb) {
-            if (filter.tb < 0) {
-                if (!(r->rtm_flags&RTM_F_CLONED)) {
+        if (G_filter.tb) {
+            if (G_filter.tb < 0) {
+                if (!(r->rtm_flags & RTM_F_CLONED)) {
                     return 0;
                 }
             } else {
-                if (r->rtm_flags&RTM_F_CLONED) {
+                if (r->rtm_flags & RTM_F_CLONED) {
                     return 0;
                 }
-                if (filter.tb == RT_TABLE_LOCAL) {
+                if (G_filter.tb == RT_TABLE_LOCAL) {
                     if (r->rtm_type != RTN_LOCAL) {
                         return 0;
                     }
-                } else if (filter.tb == RT_TABLE_MAIN) {
+                } else if (G_filter.tb == RT_TABLE_MAIN) {
                     if (r->rtm_type == RTN_LOCAL) {
                         return 0;
@@ -133 +130 @@
         }
     } else {
-        if (filter.tb > 0 && filter.tb != r->rtm_table) {
+        if (G_filter.tb > 0 && G_filter.tb != r->rtm_table) {
             return 0;
         }
     }
-    if (filter.rdst.family &&
-        (r->rtm_family != filter.rdst.family || filter.rdst.bitlen > r->rtm_dst_len)) {
-        return 0;
-    }
-    if (filter.mdst.family &&
-        (r->rtm_family != filter.mdst.family ||
-         (filter.mdst.bitlen >= 0 && filter.mdst.bitlen < r->rtm_dst_len))) {
-        return 0;
-    }
-    if (filter.rsrc.family &&
-        (r->rtm_family != filter.rsrc.family || filter.rsrc.bitlen > r->rtm_src_len)) {
-        return 0;
-    }
-    if (filter.msrc.family &&
-        (r->rtm_family != filter.msrc.family ||
-         (filter.msrc.bitlen >= 0 && filter.msrc.bitlen < r->rtm_src_len))) {
+    if (G_filter.rdst.family
+     && (r->rtm_family != G_filter.rdst.family || G_filter.rdst.bitlen > r->rtm_dst_len)
+    ) {
+        return 0;
+    }
+    if (G_filter.mdst.family
+     && (r->rtm_family != G_filter.mdst.family
+        || (G_filter.mdst.bitlen >= 0 && G_filter.mdst.bitlen < r->rtm_dst_len)
+        )
+    ) {
+        return 0;
+    }
+    if (G_filter.rsrc.family
+     && (r->rtm_family != G_filter.rsrc.family || G_filter.rsrc.bitlen > r->rtm_src_len)
+    ) {
+        return 0;
+    }
+    if (G_filter.msrc.family
+     && (r->rtm_family != G_filter.msrc.family
+        || (G_filter.msrc.bitlen >= 0 && G_filter.msrc.bitlen < r->rtm_src_len)
+        )
+    ) {
         return 0;
     }
@@ -159 +162 @@
     parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 
-    if (filter.rdst.family && inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))
-        return 0;
-    if (filter.mdst.family && filter.mdst.bitlen >= 0 &&
-        inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
-        return 0;
-
-    if (filter.rsrc.family && inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))
-        return 0;
-    if (filter.msrc.family && filter.msrc.bitlen >= 0 &&
-        inet_addr_match(&src, &filter.msrc, r->rtm_src_len))
-        return 0;
-
-    if (filter.flushb &&
-        r->rtm_family == AF_INET6 &&
-        r->rtm_dst_len == 0 &&
-        r->rtm_type == RTN_UNREACHABLE &&
-        tb[RTA_PRIORITY] &&
-        *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1)
-        return 0;
-
-    if (filter.flushb) {
+    if (G_filter.rdst.family
+     && inet_addr_match(&dst, &G_filter.rdst, G_filter.rdst.bitlen)
+    ) {
+        return 0;
+    }
+    if (G_filter.mdst.family
+     && G_filter.mdst.bitlen >= 0
+     && inet_addr_match(&dst, &G_filter.mdst, r->rtm_dst_len)
+    ) {
+        return 0;
+    }
+    if (G_filter.rsrc.family
+     && inet_addr_match(&src, &G_filter.rsrc, G_filter.rsrc.bitlen)
+    ) {
+        return 0;
+    }
+    if (G_filter.msrc.family && G_filter.msrc.bitlen >= 0
+     && inet_addr_match(&src, &G_filter.msrc, r->rtm_src_len)
+    ) {
+        return 0;
+    }
+    if (G_filter.flushb
+     && r->rtm_family == AF_INET6
+     && r->rtm_dst_len == 0
+     && r->rtm_type == RTN_UNREACHABLE
+     && tb[RTA_PRIORITY]
+     && *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1
+    ) {
+        return 0;
+    }
+
+    if (G_filter.flushb) {
         struct nlmsghdr *fn;
-        if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
+        if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
             if (flush_update())
                 bb_error_msg_and_die("flush");
         }
-        fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
+        fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
         memcpy(fn, n, n->nlmsg_len);
         fn->nlmsg_type = RTM_DELROUTE;
         fn->nlmsg_flags = NLM_F_REQUEST;
-        fn->nlmsg_seq = ++filter.rth->seq;
-        filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
-        filter.flushed++;
+        fn->nlmsg_seq = ++G_filter.rth->seq;
+        G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
+        G_filter.flushed = 1;
         return 0;
     }
 
     if (n->nlmsg_type == RTM_DELROUTE) {
-        fprintf(fp, "Deleted ");
-    }
-    if (r->rtm_type != RTN_UNICAST && !filter.type) {
-        fprintf(fp, "%s ", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
+        printf("Deleted ");
+    }
+    if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) {
+        printf("%s ", rtnl_rtntype_n2a(r->rtm_type, b1));
     }
 
     if (tb[RTA_DST]) {
         if (r->rtm_dst_len != host_len) {
-            fprintf(fp, "%s/%u ", rt_addr_n2a(r->rtm_family,
-                             RTA_PAYLOAD(tb[RTA_DST]),
-                             RTA_DATA(tb[RTA_DST]),
-                             abuf, sizeof(abuf)),
-                r->rtm_dst_len
-                );
+            printf("%s/%u ", rt_addr_n2a(r->rtm_family,
+                        RTA_DATA(tb[RTA_DST]),
+                        abuf, sizeof(abuf)),
+                    r->rtm_dst_len
+                    );
         } else {
-            fprintf(fp, "%s ", format_host(r->rtm_family,
-                               RTA_PAYLOAD(tb[RTA_DST]),
-                               RTA_DATA(tb[RTA_DST]),
-                               abuf, sizeof(abuf))
-                );
+            printf("%s ", format_host(r->rtm_family,
+                        RTA_PAYLOAD(tb[RTA_DST]),
+                        RTA_DATA(tb[RTA_DST]),
+                        abuf, sizeof(abuf))
+                    );
         }
     } else if (r->rtm_dst_len) {
-        fprintf(fp, "0/%d ", r->rtm_dst_len);
+        printf("0/%d ", r->rtm_dst_len);
     } else {
-        fprintf(fp, "default ");
+        printf("default ");
     }
     if (tb[RTA_SRC]) {
         if (r->rtm_src_len != host_len) {
-            fprintf(fp, "from %s/%u ", rt_addr_n2a(r->rtm_family,
-                             RTA_PAYLOAD(tb[RTA_SRC]),
-                             RTA_DATA(tb[RTA_SRC]),
-                             abuf, sizeof(abuf)),
-                r->rtm_src_len
-                );
+            printf("from %s/%u ", rt_addr_n2a(r->rtm_family,
+                        RTA_DATA(tb[RTA_SRC]),
+                        abuf, sizeof(abuf)),
+                    r->rtm_src_len
+                    );
         } else {
-            fprintf(fp, "from %s ", format_host(r->rtm_family,
-                               RTA_PAYLOAD(tb[RTA_SRC]),
-                               RTA_DATA(tb[RTA_SRC]),
-                               abuf, sizeof(abuf))
-                );
+            printf("from %s ", format_host(r->rtm_family,
+                        RTA_PAYLOAD(tb[RTA_SRC]),
+                        RTA_DATA(tb[RTA_SRC]),
+                        abuf, sizeof(abuf))
+                    );
         }
     } else if (r->rtm_src_len) {
-        fprintf(fp, "from 0/%u ", r->rtm_src_len);
-    }
-    if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len) {
-        fprintf(fp, "via %s ",
-            format_host(r->rtm_family,
-                    RTA_PAYLOAD(tb[RTA_GATEWAY]),
-                    RTA_DATA(tb[RTA_GATEWAY]),
-                    abuf, sizeof(abuf)));
-    }
-    if (tb[RTA_OIF] && filter.oifmask != -1) {
-        fprintf(fp, "dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
-    }
-
-    if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {
+        printf("from 0/%u ", r->rtm_src_len);
+    }
+    if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) {
+        printf("via %s ", format_host(r->rtm_family,
+                    RTA_PAYLOAD(tb[RTA_GATEWAY]),
+                    RTA_DATA(tb[RTA_GATEWAY]),
+                    abuf, sizeof(abuf)));
+    }
+    if (tb[RTA_OIF] && G_filter.oifmask != -1) {
+        printf("dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
+    }
+
+    if (tb[RTA_PREFSRC] && /*G_filter.rprefsrc.bitlen - always 0*/ 0 != host_len) {
         /* Do not use format_host(). It is our local addr
            and symbolic name will not be useful.
          */
-        fprintf(fp, " src %s ",
-            rt_addr_n2a(r->rtm_family,
-                    RTA_PAYLOAD(tb[RTA_PREFSRC]),
-                    RTA_DATA(tb[RTA_PREFSRC]),
-                    abuf, sizeof(abuf)));
+        printf(" src %s ", rt_addr_n2a(r->rtm_family,
+                    RTA_DATA(tb[RTA_PREFSRC]),
+                    abuf, sizeof(abuf)));
     }
     if (tb[RTA_PRIORITY]) {
-        fprintf(fp, " metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
+        printf(" metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
     }
     if (r->rtm_family == AF_INET6) {
@@ -271 +280 @@
         if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
             if (r->rtm_flags & RTM_F_CLONED) {
-                fprintf(fp, "%c    cache ", _SL_);
+                printf("%c    cache ", _SL_);
             }
             if (ci->rta_expires) {
-                fprintf(fp, " expires %dsec", ci->rta_expires / get_hz());
+                printf(" expires %dsec", ci->rta_expires / get_hz());
             }
             if (ci->rta_error != 0) {
-                fprintf(fp, " error %d", ci->rta_error);
+                printf(" error %d", ci->rta_error);
             }
         } else if (ci) {
             if (ci->rta_error != 0)
-                fprintf(fp, " error %d", ci->rta_error);
-        }
-    }
-    if (tb[RTA_IIF] && filter.iifmask != -1) {
-        fprintf(fp, " iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
-    }
-    fputc('\n', fp);
-    fflush(fp);
+                printf(" error %d", ci->rta_error);
+        }
+    }
+    if (tb[RTA_IIF] && G_filter.iifmask != -1) {
+        printf(" iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
+    }
+    bb_putchar('\n');
     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 int iproute_modify(int cmd, unsigned flags, 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";
+        "src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
+        "dev\0""oif\0""to\0""metric\0";
     enum {
         ARG_src,
@@ -303 +311 @@
         ARG_mtu, PARM_lock,
         ARG_protocol,
-USE_FEATURE_IP_RULE(ARG_table,)
+IF_FEATURE_IP_RULE(ARG_table,)
         ARG_dev,
         ARG_oif,
-        ARG_to
+        ARG_to,
+        ARG_metric,
     };
     enum {
@@ -316 +325 @@
     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 mxbuf[256];
@@ -330 +339 @@
 
     req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
-    req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+    req.n.nlmsg_flags = NLM_F_REQUEST | flags;
     req.n.nlmsg_type = cmd;
     req.r.rtm_family = preferred_family;
-    req.r.rtm_table = RT_TABLE_MAIN;
-    req.r.rtm_scope = RT_SCOPE_NOWHERE;
+    if (RT_TABLE_MAIN) /* if it is zero, memset already did it */
+        req.r.rtm_table = RT_TABLE_MAIN;
+    if (RT_SCOPE_NOWHERE)
+        req.r.rtm_scope = RT_SCOPE_NOWHERE;
 
     if (cmd != RTM_DELROUTE) {
@@ -345 +356 @@
     mxrta->rta_len = RTA_LENGTH(0);
 
-    while (argc > 0) {
+    while (*argv) {
         arg = index_in_substrings(keywords, *argv);
         if (arg == ARG_src) {
@@ -367 +378 @@
             NEXT_ARG();
             if (index_in_strings(keywords, *argv) == PARM_lock) {
-                mxlock |= (1<<RTAX_MTU);
-                NEXT_ARG();
-            }
-            if (get_unsigned(&mtu, *argv, 0))
-                invarg(*argv, "mtu");
+                mxlock |= (1 << RTAX_MTU);
+                NEXT_ARG();
+            }
+            mtu = get_unsigned(*argv, "mtu");
             rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
         } else if (arg == ARG_protocol) {
@@ -391 +401 @@
             NEXT_ARG();
             d = *argv;
+        } else if (arg == ARG_metric) {
+            uint32_t metric;
+            NEXT_ARG();
+            metric = get_u32(*argv, "metric");
+            addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
         } else {
             int type;
@@ -399 +414 @@
             }
             if ((**argv < '0' || **argv > '9')
-                && rtnl_rtntype_a2n(&type, *argv) == 0) {
+             && rtnl_rtntype_a2n(&type, *argv) == 0) {
                 NEXT_ARG();
                 req.r.rtm_type = type;
@@ -418 +433 @@
             }
         }
-        argc--; argv++;
+        argv++;
     }
 
@@ -443 +458 @@
     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)
+    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)
@@ -478 +496 @@
 
     req.nlh.nlmsg_len = sizeof(req);
-    req.nlh.nlmsg_type = RTM_GETROUTE;
-    req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
-    req.nlh.nlmsg_pid = 0;
+    if (RTM_GETROUTE)
+        req.nlh.nlmsg_type = RTM_GETROUTE;
+    if (NLM_F_ROOT | NLM_F_REQUEST)
+        req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST;
+    /*req.nlh.nlmsg_pid = 0; - memset did it already */
     req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
     req.rtm.rtm_family = family;
-    req.rtm.rtm_flags |= RTM_F_CLONED;
+    if (RTM_F_CLONED)
+        req.rtm.rtm_flags = RTM_F_CLONED;
 
     return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr));
@@ -498 +519 @@
 
     if (write(flush_fd, "-1", 2) < 2) {
-        bb_perror_msg("cannot flush routing cache");
+        bb_perror_msg("can't flush routing cache");
         return;
     }
@@ -506 +527 @@
 static void iproute_reset_filter(void)
 {
-    memset(&filter, 0, sizeof(filter));
-    filter.mdst.bitlen = -1;
-    filter.msrc.bitlen = -1;
+    memset(&G_filter, 0, sizeof(G_filter));
+    G_filter.mdst.bitlen = -1;
+    G_filter.msrc.bitlen = -1;
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int iproute_list_or_flush(int argc, char **argv, int flush)
+static int iproute_list_or_flush(char **argv, int flush)
 {
     int do_ipv6 = preferred_family;
@@ -519 +540 @@
     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*/;
+        /* "ip route list/flush" parameters: */
+        "protocol\0" "dev\0"   "oif\0"   "iif\0"
+        "via\0"      "table\0" "cache\0"
+        "from\0"     "to\0"
+        /* and possible further keywords */
+        "all\0"
+        "root\0"
+        "match\0"
+        "exact\0"
+        "main\0"
+        ;
     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*/
+        KW_proto, KW_dev,   KW_oif,  KW_iif,
+        KW_via,   KW_table, KW_cache,
+        KW_from,  KW_to,
+        /* */
+        KW_all,
+        KW_root,
+        KW_match,
+        KW_exact,
+        KW_main,
     };
     int arg, parm;
+
     iproute_reset_filter();
-    filter.tb = RT_TABLE_MAIN;
-
-    if (flush && argc <= 0)
+    G_filter.tb = RT_TABLE_MAIN;
+
+    if (flush && !*argv)
         bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
 
-    while (argc > 0) {
+    while (*argv) {
         arg = index_in_substrings(keywords, *argv);
-        if (arg == ARG_proto) {
+        if (arg == KW_proto) {
             uint32_t prot = 0;
             NEXT_ARG();
-            filter.protocolmask = -1;
+            //G_filter.protocolmask = -1;
             if (rtnl_rtprot_a2n(&prot, *argv)) {
-                if (index_in_strings(keywords, *argv) != PARM_all)
+                if (index_in_strings(keywords, *argv) != KW_all)
                     invarg(*argv, "protocol");
                 prot = 0;
-                filter.protocolmask = 0;
-            }
-            filter.protocol = prot;
-        } else if (arg == ARG_dev || arg == ARG_oif) {
+                //G_filter.protocolmask = 0;
+            }
+            //G_filter.protocol = prot;
+        } else if (arg == KW_dev || arg == KW_oif) {
             NEXT_ARG();
             od = *argv;
-        } else if (arg == ARG_iif) {
+        } else if (arg == KW_iif) {
             NEXT_ARG();
             id = *argv;
-        } else if (arg == ARG_via) {
-            NEXT_ARG();
-            get_prefix(&filter.rvia, *argv, do_ipv6);
-        } else if (arg == ARG_table) {
+        } else if (arg == KW_via) {
+            NEXT_ARG();
+            get_prefix(&G_filter.rvia, *argv, do_ipv6);
+        } else if (arg == KW_table) { /* table all/cache/main */
             NEXT_ARG();
             parm = index_in_substrings(keywords, *argv);
-            if (parm == PARM_cache)
-                filter.tb = -1;
-            else if (parm == PARM_all)
-                filter.tb = 0;
-            else
+            if (parm == KW_cache)
+                G_filter.tb = -1;
+            else if (parm == KW_all)
+                G_filter.tb = 0;
+            else if (parm != KW_main) {
+#if ENABLE_FEATURE_IP_RULE
+                uint32_t tid;
+                if (rtnl_rttable_a2n(&tid, *argv))
+                    invarg(*argv, "table");
+                G_filter.tb = tid;
+#else
                 invarg(*argv, "table");
-        } else if (arg == ARG_from) {
+#endif
+            }
+        } else if (arg == KW_cache) {
+            /* The command 'ip route flush cache' is used by OpenSWAN.
+             * Assuming it's a synonym for 'ip route flush table cache' */
+            G_filter.tb = -1;
+        } else if (arg == KW_from) {
             NEXT_ARG();
             parm = index_in_substrings(keywords, *argv);
-            if (parm == PARM_root) {
-                NEXT_ARG();
-                get_prefix(&filter.rsrc, *argv, do_ipv6);
-            } else if (parm == PARM_match) {
-                NEXT_ARG();
-                get_prefix(&filter.msrc, *argv, do_ipv6);
+            if (parm == KW_root) {
+                NEXT_ARG();
+                get_prefix(&G_filter.rsrc, *argv, do_ipv6);
+            } else if (parm == KW_match) {
+                NEXT_ARG();
+                get_prefix(&G_filter.msrc, *argv, do_ipv6);
             } else {
-                if (parm == PARM_exact)
+                if (parm == KW_exact)
                     NEXT_ARG();
-                get_prefix(&filter.msrc, *argv, do_ipv6);
-                filter.rsrc = filter.msrc;
-            }
-        } else {
-            /* parm = arg; // would be more plausible, we reuse arg here */
-            if (arg == ARG_to) {
+                get_prefix(&G_filter.msrc, *argv, do_ipv6);
+                G_filter.rsrc = G_filter.msrc;
+            }
+        } else { /* "to" is the default parameter */
+            if (arg == KW_to) {
                 NEXT_ARG();
                 arg = index_in_substrings(keywords, *argv);
             }
-            if (arg == PARM_root) {
-                NEXT_ARG();
-                get_prefix(&filter.rdst, *argv, do_ipv6);
-            } else if (arg == PARM_match) {
-                NEXT_ARG();
-                get_prefix(&filter.mdst, *argv, do_ipv6);
-            } else {
-                if (arg == PARM_exact)
+            /* parm = arg; - would be more plausible, but we reuse 'arg' here */
+            if (arg == KW_root) {
+                NEXT_ARG();
+                get_prefix(&G_filter.rdst, *argv, do_ipv6);
+            } else if (arg == KW_match) {
+                NEXT_ARG();
+                get_prefix(&G_filter.mdst, *argv, do_ipv6);
+            } else { /* "to exact" is the default */
+                if (arg == KW_exact)
                     NEXT_ARG();
-                get_prefix(&filter.mdst, *argv, do_ipv6);
-                filter.rdst = filter.mdst;
-            }
-        }
-        argc--;
+                get_prefix(&G_filter.mdst, *argv, do_ipv6);
+                G_filter.rdst = G_filter.mdst;
+            }
+        }
         argv++;
     }
 
-    if (do_ipv6 == AF_UNSPEC && filter.tb) {
+    if (do_ipv6 == AF_UNSPEC && G_filter.tb) {
         do_ipv6 = AF_INET;
     }
 
     xrtnl_open(&rth);
-
     ll_init_map(&rth);
 
@@ -620 +662 @@
         if (id) {
             idx = xll_name_to_index(id);
-            filter.iif = idx;
-            filter.iifmask = -1;
+            G_filter.iif = idx;
+            G_filter.iifmask = -1;
         }
         if (od) {
             idx = xll_name_to_index(od);
-            filter.oif = idx;
-            filter.oifmask = -1;
+            G_filter.oif = idx;
+            G_filter.oifmask = -1;
         }
     }
@@ -633 +675 @@
         char flushb[4096-512];
 
-        if (filter.tb == -1) {
+        if (G_filter.tb == -1) { /* "flush table cache" */
             if (do_ipv6 != AF_INET6)
                 iproute_flush_cache();
@@ -640 +682 @@
         }
 
-        filter.flushb = flushb;
-        filter.flushp = 0;
-        filter.flushe = sizeof(flushb);
-        filter.rth = &rth;
+        G_filter.flushb = flushb;
+        G_filter.flushp = 0;
+        G_filter.flushe = sizeof(flushb);
+        G_filter.rth = &rth;
 
         for (;;) {
             xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
-            filter.flushed = 0;
-            xrtnl_dump_filter(&rth, print_route, stdout);
-            if (filter.flushed == 0)
+            G_filter.flushed = 0;
+            xrtnl_dump_filter(&rth, print_route, NULL);
+            if (G_filter.flushed == 0)
                 return 0;
             if (flush_update())
@@ -656 +698 @@
     }
 
-    if (filter.tb != -1) {
+    if (G_filter.tb != -1) {
         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);
+        bb_perror_msg_and_die("can't send dump request");
+    }
+    xrtnl_dump_filter(&rth, print_route, NULL);
 
     return 0;
@@ -668 +710 @@
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int iproute_get(int argc, char **argv)
+static int iproute_get(char **argv)
 {
     struct rtnl_handle rth;
@@ -688 +730 @@
 
     req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
-    req.n.nlmsg_flags = NLM_F_REQUEST;
-    req.n.nlmsg_type = RTM_GETROUTE;
+    if (NLM_F_REQUEST)
+        req.n.nlmsg_flags = NLM_F_REQUEST;
+    if (RTM_GETROUTE)
+        req.n.nlmsg_type = RTM_GETROUTE;
     req.r.rtm_family = preferred_family;
-    req.r.rtm_table = 0;
-    req.r.rtm_protocol = 0;
-    req.r.rtm_scope = 0;
-    req.r.rtm_type = 0;
-    req.r.rtm_src_len = 0;
-    req.r.rtm_dst_len = 0;
-    req.r.rtm_tos = 0;
-
-    while (argc > 0) {
+    /*req.r.rtm_table = 0; - memset did this already */
+    /*req.r.rtm_protocol = 0;*/
+    /*req.r.rtm_scope = 0;*/
+    /*req.r.rtm_type = 0;*/
+    /*req.r.rtm_src_len = 0;*/
+    /*req.r.rtm_dst_len = 0;*/
+    /*req.r.rtm_tos = 0;*/
+
+    while (*argv) {
         switch (index_in_strings(options, *argv)) {
             case 0: /* from */
@@ -745 +789 @@
                 req.r.rtm_dst_len = addr.bitlen;
             }
-            argc--; argv++;
-        }
+        }
+        argv++;
     }
 
@@ -783 +827 @@
         struct rtattr * tb[RTA_MAX+1];
 
-        print_route(NULL, &req.n, (void*)stdout);
+        print_route(NULL, &req.n, NULL);
 
         if (req.n.nlmsg_type != RTM_NEWROUTE) {
@@ -800 +844 @@
             r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
         } else if (!tb[RTA_SRC]) {
-            bb_error_msg_and_die("failed to connect the route");
+            bb_error_msg_and_die("can't connect the route");
         }
         if (!odev && tb[RTA_OIF]) {
@@ -818 +862 @@
         }
     }
-    print_route(NULL, &req.n, (void*)stdout);
+    print_route(NULL, &req.n, NULL);
     return 0;
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-int do_iproute(int argc, char **argv)
+int FAST_FUNC do_iproute(char **argv)
 {
     static const char ip_route_commands[] ALIGN1 =
@@ -829 +873 @@
     /*4-7*/ "delete\0""get\0""list\0""show\0"
     /*8..*/ "prepend\0""replace\0""test\0""flush\0";
-    int command_num = 6;
+    int command_num;
     unsigned flags = 0;
     int cmd = RTM_NEWROUTE;
 
+    if (!*argv)
+        return iproute_list_or_flush(argv, 0);
+
     /* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
     /* It probably means that it is using "first match" rule */
-    if (*argv) {
-        command_num = index_in_substrings(ip_route_commands, *argv);
-    }
+    command_num = index_in_substrings(ip_route_commands, *argv);
+
     switch (command_num) {
         case 0: /* add */
@@ -853 +899 @@
             break;
         case 5: /* get */
-            return iproute_get(argc-1, argv+1);
+            return iproute_get(argv+1);
         case 6: /* list */
         case 7: /* show */
-            return iproute_list_or_flush(argc-1, argv+1, 0);
+            return iproute_list_or_flush(argv+1, 0);
         case 8: /* prepend */
             flags = NLM_F_CREATE;
+            break;
         case 9: /* replace */
             flags = NLM_F_CREATE|NLM_F_REPLACE;
+            break;
         case 10: /* test */
             flags = NLM_F_EXCL;
+            break;
         case 11: /* flush */
-            return iproute_list_or_flush(argc-1, argv+1, 1);
+            return iproute_list_or_flush(argv+1, 1);
         default:
             bb_error_msg_and_die("unknown command %s", *argv);
     }
 
-    return iproute_modify(cmd, flags, argc-1, argv+1);
+    return iproute_modify(cmd, flags, argv+1);
 }

branches/2.2.9/mindi-busybox/networking/libiproute/iprule.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * iprule.c     "ip rule".
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
  *
- * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
- * initially integrated into busybox by Bernhard Fischer
+ * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * initially integrated into busybox by Bernhard Reutner-Fischer
  */
 
-#include <syslog.h>
-//#include <sys/socket.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
@@ -43 +38 @@
 */
 
-static int print_rule(struct sockaddr_nl *who ATTRIBUTE_UNUSED,
-                    struct nlmsghdr *n, void *arg)
-{
-    FILE *fp = (FILE*)arg;
+static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
+                    struct nlmsghdr *n, void *arg UNUSED_PARAM)
+{
     struct rtmsg *r = NLMSG_DATA(n);
     int len = n->nlmsg_len;
@@ -73 +67 @@
         host_len = 80;
 */
-    if (tb[RTA_PRIORITY])
-        fprintf(fp, "%u:\t", *(unsigned*)RTA_DATA(tb[RTA_PRIORITY]));
-    else
-        fprintf(fp, "0:\t");
-
-    fprintf(fp, "from ");
+    printf("%u:\t", tb[RTA_PRIORITY] ?
+                    *(unsigned*)RTA_DATA(tb[RTA_PRIORITY])
+                    : 0);
+    printf("from ");
     if (tb[RTA_SRC]) {
         if (r->rtm_src_len != host_len) {
-            fprintf(fp, "%s/%u", rt_addr_n2a(r->rtm_family,
-                             RTA_PAYLOAD(tb[RTA_SRC]),
+            printf("%s/%u", rt_addr_n2a(r->rtm_family,
                              RTA_DATA(tb[RTA_SRC]),
                              abuf, sizeof(abuf)),
@@ -88 +79 @@
                 );
         } else {
-            fprintf(fp, "%s", format_host(r->rtm_family,
+            fputs(format_host(r->rtm_family,
                                RTA_PAYLOAD(tb[RTA_SRC]),
                                RTA_DATA(tb[RTA_SRC]),
-                               abuf, sizeof(abuf))
-                );
+                               abuf, sizeof(abuf)), stdout);
         }
     } else if (r->rtm_src_len) {
-        fprintf(fp, "0/%d", r->rtm_src_len);
+        printf("0/%d", r->rtm_src_len);
     } else {
-        fprintf(fp, "all");
-    }
-    fprintf(fp, " ");
+        printf("all");
+    }
+    bb_putchar(' ');
 
     if (tb[RTA_DST]) {
         if (r->rtm_dst_len != host_len) {
-            fprintf(fp, "to %s/%u ", rt_addr_n2a(r->rtm_family,
-                             RTA_PAYLOAD(tb[RTA_DST]),
+            printf("to %s/%u ", rt_addr_n2a(r->rtm_family,
                              RTA_DATA(tb[RTA_DST]),
                              abuf, sizeof(abuf)),
@@ -110 +99 @@
                 );
         } else {
-            fprintf(fp, "to %s ", format_host(r->rtm_family,
+            printf("to %s ", format_host(r->rtm_family,
                                RTA_PAYLOAD(tb[RTA_DST]),
                                RTA_DATA(tb[RTA_DST]),
@@ -116 +105 @@
         }
     } else if (r->rtm_dst_len) {
-        fprintf(fp, "to 0/%d ", r->rtm_dst_len);
+        printf("to 0/%d ", r->rtm_dst_len);
     }
 
     if (r->rtm_tos) {
-        fprintf(fp, "tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1)));
+        printf("tos %s ", rtnl_dsfield_n2a(r->rtm_tos, b1));
     }
     if (tb[RTA_PROTOINFO]) {
-        fprintf(fp, "fwmark %#x ", *(uint32_t*)RTA_DATA(tb[RTA_PROTOINFO]));
+        printf("fwmark %#x ", *(uint32_t*)RTA_DATA(tb[RTA_PROTOINFO]));
     }
 
     if (tb[RTA_IIF]) {
-        fprintf(fp, "iif %s ", (char*)RTA_DATA(tb[RTA_IIF]));
+        printf("iif %s ", (char*)RTA_DATA(tb[RTA_IIF]));
     }
 
     if (r->rtm_table)
-        fprintf(fp, "lookup %s ", rtnl_rttable_n2a(r->rtm_table, b1, sizeof(b1)));
+        printf("lookup %s ", rtnl_rttable_n2a(r->rtm_table, b1));
 
     if (tb[RTA_FLOW]) {
@@ -138 +127 @@
         to &= 0xFFFF;
         if (from) {
-            fprintf(fp, "realms %s/",
-                rtnl_rtrealm_n2a(from, b1, sizeof(b1)));
+            printf("realms %s/",
+                rtnl_rtrealm_n2a(from, b1));
         }
-        fprintf(fp, "%s ",
-            rtnl_rtrealm_n2a(to, b1, sizeof(b1)));
+        printf("%s ",
+            rtnl_rtrealm_n2a(to, b1));
     }
 
     if (r->rtm_type == RTN_NAT) {
         if (tb[RTA_GATEWAY]) {
-            fprintf(fp, "map-to %s ",
+            printf("map-to %s ",
                 format_host(r->rtm_family,
                         RTA_PAYLOAD(tb[RTA_GATEWAY]),
@@ -153 +142 @@
                         abuf, sizeof(abuf)));
         } else
-            fprintf(fp, "masquerade");
+            printf("masquerade");
     } else if (r->rtm_type != RTN_UNICAST)
-        fprintf(fp, "%s", rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));
-
-    fputc('\n', fp);
-    fflush(fp);
+        fputs(rtnl_rtntype_n2a(r->rtm_type, b1), stdout);
+
+    bb_putchar('\n');
+    /*fflush_all();*/
     return 0;
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int iprule_list(int argc, char **argv)
+static int iprule_list(char **argv)
 {
     struct rtnl_handle rth;
@@ -171 +160 @@
         af = AF_INET;
 
-    if (argc > 0) {
+    if (*argv) {
         //bb_error_msg("\"rule show\" needs no arguments");
-        bb_warn_ignoring_args(argc);
+        bb_warn_ignoring_args(*argv);
         return -1;
     }
@@ -180 +169 @@
 
     xrtnl_wilddump_request(&rth, af, RTM_GETRULE);
-    xrtnl_dump_filter(&rth, print_rule, stdout);
+    xrtnl_dump_filter(&rth, print_rule, NULL);
 
     return 0;
@@ -186 +175 @@
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int iprule_modify(int cmd, int argc, char **argv)
+static int iprule_modify(int cmd, char **argv)
 {
     static const char keywords[] ALIGN1 =
@@ -200 +189 @@
     struct rtnl_handle rth;
     struct {
-        struct nlmsghdr n;
-        struct rtmsg    r;
-        char        buf[1024];
+        struct nlmsghdr n;
+        struct rtmsg    r;
+        char            buf[1024];
     } req;
     smalluint key;
@@ -222 +211 @@
     }
 
-    while (argc > 0) {
+    while (*argv) {
         key = index_in_substrings(keywords, *argv) + 1;
         if (key == 0) /* no match found in keywords array, bail out. */
@@ -240 +229 @@
         } else if (key == ARG_preference ||
                key == ARG_order ||
-               key == ARG_priority) {
+               key == ARG_priority
+        ) {
             uint32_t pref;
             NEXT_ARG();
-            if (get_u32(&pref, *argv, 0))
-                invarg(*argv, "preference");
+            pref = get_u32(*argv, "preference");
             addattr32(&req.n, sizeof(req), RTA_PRIORITY, pref);
         } else if (key == ARG_tos) {
@@ -255 +244 @@
             uint32_t fwmark;
             NEXT_ARG();
-            if (get_u32(&fwmark, *argv, 0))
-                invarg(*argv, "fwmark");
+            fwmark = get_u32(*argv, "fwmark");
             addattr32(&req.n, sizeof(req), RTA_PROTOINFO, fwmark);
         } else if (key == ARG_realms) {
@@ -265 +253 @@
             addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
         } else if (key == ARG_table ||
-               key == ARG_lookup) {
+               key == ARG_lookup
+        ) {
             uint32_t tid;
             NEXT_ARG();
@@ -273 +262 @@
             table_ok = 1;
         } else if (key == ARG_dev ||
-               key == ARG_iif) {
+               key == ARG_iif
+        ) {
             NEXT_ARG();
             addattr_l(&req.n, sizeof(req), RTA_IIF, *argv, strlen(*argv)+1);
         } else if (key == ARG_nat ||
-               key == ARG_map_to) {
+               key == ARG_map_to
+        ) {
             NEXT_ARG();
             addattr32(&req.n, sizeof(req), RTA_GATEWAY, get_addr32(*argv));
@@ -293 +284 @@
             req.r.rtm_type = type;
         }
-        argc--;
         argv++;
     }
@@ -312 +302 @@
 
 /* Return value becomes exitcode. It's okay to not return at all */
-int do_iprule(int argc, char **argv)
+int FAST_FUNC do_iprule(char **argv)
 {
     static const char ip_rule_commands[] ALIGN1 =
         "add\0""delete\0""list\0""show\0";
-    int cmd = 2; /* list */
-
-    if (argc < 1)
-        return iprule_list(0, NULL);
-    if (*argv)
-        cmd = index_in_substrings(ip_rule_commands, *argv);
-
-    switch (cmd) {
-        case 0: /* add */
-            cmd = RTM_NEWRULE;
-            break;
-        case 1: /* delete */
-            cmd = RTM_DELRULE;
-            break;
-        case 2: /* list */
-        case 3: /* show */
-            return iprule_list(argc-1, argv+1);
-            break;
-        default:
-            bb_error_msg_and_die("unknown command %s", *argv);
-    }
-    return iprule_modify(cmd, argc-1, argv+1);
-}
+    if (*argv) {
+        smalluint cmd = index_in_substrings(ip_rule_commands, *argv);
+        if (cmd > 3)
+            bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+        argv++;
+        if (cmd < 2)
+            return iprule_modify((cmd == 0) ? RTM_NEWRULE : RTM_DELRULE, argv);
+    }
+    return iprule_list(argv);
+}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * iptunnel.c          "ip tunnel"
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
  *
- * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
- * Rani Assaf <rani@magic.metawire.com> 980930: do not allow key for ipip/sit
- * Phil Karn <karn@ka9q.ampr.org>   990408: "pmtudisc" flag
+ * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * Rani Assaf <rani@magic.metawire.com> 980930: do not allow key for ipip/sit
+ * Phil Karn <karn@ka9q.ampr.org>       990408: "pmtudisc" flag
  */
 
@@ -19 +16 @@
 #include <net/if_arp.h>
 #include <asm/types.h>
+
 #ifndef __constant_htons
 #define __constant_htons htons
 #endif
-#include <linux/if_tunnel.h>
+
+// FYI: #define SIOCDEVPRIVATE 0x89F0
+
+/* From linux/if_tunnel.h. #including it proved troublesome
+ * (redefiniton errors due to name collisions in linux/ and net[inet]/) */
+#define SIOCGETTUNNEL   (SIOCDEVPRIVATE + 0)
+#define SIOCADDTUNNEL   (SIOCDEVPRIVATE + 1)
+#define SIOCDELTUNNEL   (SIOCDEVPRIVATE + 2)
+#define SIOCCHGTUNNEL   (SIOCDEVPRIVATE + 3)
+//#define SIOCGETPRL      (SIOCDEVPRIVATE + 4)
+//#define SIOCADDPRL      (SIOCDEVPRIVATE + 5)
+//#define SIOCDELPRL      (SIOCDEVPRIVATE + 6)
+//#define SIOCCHGPRL      (SIOCDEVPRIVATE + 7)
+#define GRE_CSUM        __constant_htons(0x8000)
+//#define GRE_ROUTING     __constant_htons(0x4000)
+#define GRE_KEY         __constant_htons(0x2000)
+#define GRE_SEQ         __constant_htons(0x1000)
+//#define GRE_STRICT      __constant_htons(0x0800)
+//#define GRE_REC         __constant_htons(0x0700)
+//#define GRE_FLAGS       __constant_htons(0x00F8)
+//#define GRE_VERSION     __constant_htons(0x0007)
+struct ip_tunnel_parm {
+    char            name[IFNAMSIZ];
+    int             link;
+    uint16_t        i_flags;
+    uint16_t        o_flags;
+    uint32_t        i_key;
+    uint32_t        o_key;
+    struct iphdr    iph;
+};
+/* SIT-mode i_flags */
+//#define SIT_ISATAP 0x0001
+//struct ip_tunnel_prl {
+//  uint32_t          addr;
+//  uint16_t          flags;
+//  uint16_t          __reserved;
+//  uint32_t          datalen;
+//  uint32_t          __reserved2;
+//  /* data follows */
+//};
+///* PRL flags */
+//#define PRL_DEFAULT 0x0001
 
 #include "ip_common.h"  /* #include "libbb.h" is inside */
@@ -35 +74 @@
     int fd;
 
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     fd = xsocket(AF_INET, SOCK_DGRAM, 0);
     xioctl(fd, SIOCGIFINDEX, &ifr);
@@ -48 +87 @@
     int err;
 
-    strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, dev);
     fd = xsocket(AF_INET, SOCK_DGRAM, 0);
     err = ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr);
@@ -74 +113 @@
     int err;
 
-    strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+    strncpy_IFNAMSIZ(ifr.ifr_name, basedev);
     ifr.ifr_ifru.ifru_data = (void*)p;
     fd = xsocket(AF_INET, SOCK_DGRAM, 0);
@@ -89 +128 @@
 
     if (cmd == SIOCCHGTUNNEL && p->name[0]) {
-        strncpy(ifr.ifr_name, p->name, sizeof(ifr.ifr_name));
+        strncpy_IFNAMSIZ(ifr.ifr_name, p->name);
     } else {
-        strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+        strncpy_IFNAMSIZ(ifr.ifr_name, basedev);
     }
     ifr.ifr_ifru.ifru_data = (void*)p;
@@ -115 +154 @@
 
     if (p->name[0]) {
-        strncpy(ifr.ifr_name, p->name, sizeof(ifr.ifr_name));
+        strncpy_IFNAMSIZ(ifr.ifr_name, p->name);
     } else {
-        strncpy(ifr.ifr_name, basedev, sizeof(ifr.ifr_name));
+        strncpy_IFNAMSIZ(ifr.ifr_name, basedev);
     }
     ifr.ifr_ifru.ifru_data = (void*)p;
@@ -127 +166 @@
 
 /* Dies on error */
-static void parse_args(int argc, char **argv, int cmd, struct ip_tunnel_parm *p)
+static void parse_args(char **argv, int cmd, struct ip_tunnel_parm *p)
 {
     static const char keywords[] ALIGN1 =
@@ -149 +188 @@
 
     memset(p, 0, sizeof(*p));
-    memset(&medium, 0, sizeof(medium));
+    medium[0] = '\0';
 
     p->iph.version = 4;
@@ -158 +197 @@
     p->iph.frag_off = htons(IP_DF);
 
-    while (argc > 0) {
+    while (*argv) {
         key = index_in_strings(keywords, *argv);
         if (key == ARG_mode) {
@@ -164 +203 @@
             key = index_in_strings(keywords, *argv);
             if (key == ARG_ipip ||
-                key == ARG_ip_ip) {
+                key == ARG_ip_ip
+            ) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_IPIP) {
-                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                    bb_error_msg_and_die("%s tunnel mode", "you managed to ask for more than one");
                 }
                 p->iph.protocol = IPPROTO_IPIP;
             } else if (key == ARG_gre ||
-                   key == ARG_gre_ip) {
+                   key == ARG_gre_ip
+            ) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_GRE) {
-                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                    bb_error_msg_and_die("%s tunnel mode", "you managed to ask for more than one");
                 }
                 p->iph.protocol = IPPROTO_GRE;
             } else if (key == ARG_sit ||
-                   key == ARG_ip6_ip) {
+                   key == ARG_ip6_ip
+            ) {
                 if (p->iph.protocol && p->iph.protocol != IPPROTO_IPV6) {
-                    bb_error_msg_and_die("you managed to ask for more than one tunnel mode");
+                    bb_error_msg_and_die("%s tunnel mode", "you managed to ask for more than one");
                 }
                 p->iph.protocol = IPPROTO_IPV6;
             } else {
-                bb_error_msg_and_die("cannot guess tunnel mode");
+                bb_error_msg_and_die("%s tunnel mode", "can't guess");
             }
         } else if (key == ARG_key) {
@@ -192 +234 @@
                 p->i_key = p->o_key = get_addr32(*argv);
             else {
-                if (get_unsigned(&uval, *argv, 0)<0) {
-                    bb_error_msg_and_die("invalid value of \"key\"");
-                }
+                uval = get_unsigned(*argv, "key");
                 p->i_key = p->o_key = htonl(uval);
             }
@@ -204 +244 @@
                 p->o_key = get_addr32(*argv);
             else {
-                if (get_unsigned(&uval, *argv, 0)<0) {
-                    bb_error_msg_and_die("invalid value of \"ikey\"");
-                }
+                uval = get_unsigned(*argv, "ikey");
                 p->i_key = htonl(uval);
             }
@@ -216 +254 @@
                 p->o_key = get_addr32(*argv);
             else {
-                if (get_unsigned(&uval, *argv, 0)<0) {
-                    bb_error_msg_and_die("invalid value of \"okey\"");
-                }
+                uval = get_unsigned(*argv, "okey");
                 p->o_key = htonl(uval);
             }
@@ -251 +287 @@
         } else if (key == ARG_dev) {
             NEXT_ARG();
-            strncpy(medium, *argv, IFNAMSIZ-1);
+            strncpy_IFNAMSIZ(medium, *argv);
         } else if (key == ARG_ttl) {
             unsigned uval;
@@ -257 +293 @@
             key = index_in_strings(keywords, *argv);
             if (key != ARG_inherit) {
-                if (get_unsigned(&uval, *argv, 0))
-                    invarg(*argv, "TTL");
+                uval = get_unsigned(*argv, "TTL");
                 if (uval > 255)
                     invarg(*argv, "TTL must be <=255");
@@ -264 +299 @@
             }
         } else if (key == ARG_tos ||
-               key == ARG_dsfield) {
+               key == ARG_dsfield
+        ) {
             uint32_t uval;
             NEXT_ARG();
@@ -280 +316 @@
             if (p->name[0])
                 duparg2("name", *argv);
-            strncpy(p->name, *argv, IFNAMSIZ);
+            strncpy_IFNAMSIZ(p->name, *argv);
             if (cmd == SIOCCHGTUNNEL && count == 0) {
                 struct ip_tunnel_parm old_p;
                 memset(&old_p, 0, sizeof(old_p));
                 if (do_get_ioctl(*argv, &old_p))
-                    exit(1);
+                    exit(EXIT_FAILURE);
                 *p = old_p;
             }
         }
         count++;
-        argc--;
         argv++;
     }
@@ -326 +361 @@
 }
 
-
 /* Return value becomes exitcode. It's okay to not return at all */
-static int do_add(int cmd, int argc, char **argv)
+static int do_add(int cmd, char **argv)
 {
     struct ip_tunnel_parm p;
 
-    parse_args(argc, argv, cmd, &p);
+    parse_args(argv, cmd, &p);
 
     if (p.iph.ttl && p.iph.frag_off == 0) {
@@ -346 +380 @@
         return do_add_ioctl(cmd, "sit0", &p);
     default:
-        bb_error_msg_and_die("cannot determine tunnel mode (ipip, gre or sit)");
+        bb_error_msg_and_die("can't 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)
+static int do_del(char **argv)
 {
     struct ip_tunnel_parm p;
 
-    parse_args(argc, argv, SIOCDELTUNNEL, &p);
+    parse_args(argv, SIOCDELTUNNEL, &p);
 
     switch (p.iph.protocol) {
@@ -405 +439 @@
         if (p->iph.tos & ~1)
             printf("%c%s ", p->iph.tos & 1 ? '/' : ' ',
-                   rtnl_dsfield_n2a(p->iph.tos & ~1, b1, sizeof(b1)));
+                   rtnl_dsfield_n2a(p->iph.tos & ~1, b1));
     }
     if (!(p->iph.frag_off & htons(IP_DF)))
@@ -444 +478 @@
         return;
     }
-
+    /* skip headers */
     fgets(buf, sizeof(buf), fp);
     fgets(buf, sizeof(buf), fp);
@@ -454 +488 @@
         ptr = strchr(buf, ':');
         if (ptr == NULL ||
-            (*ptr++ = 0, sscanf(buf, "%s", name) != 1)) {
+            (*ptr++ = 0, sscanf(buf, "%s", name) != 1)
+        ) {
             bb_error_msg("wrong format of /proc/net/dev");
             return;
@@ -468 +503 @@
         type = do_ioctl_get_iftype(name);
         if (type == -1) {
-            bb_error_msg("cannot get type of [%s]", name);
+            bb_error_msg("can't get type of [%s]", name);
             continue;
         }
@@ -480 +515 @@
             (p->iph.daddr && p1.iph.daddr != p->iph.daddr) ||
             (p->iph.saddr && p1.iph.saddr != p->iph.saddr) ||
-            (p->i_key && p1.i_key != p->i_key))
+            (p->i_key && p1.i_key != p->i_key)
+        ) {
             continue;
+        }
         print_tunnel(&p1);
-        puts("");
+        bb_putchar('\n');
     }
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-static int do_show(int argc, char **argv)
+static int do_show(char **argv)
 {
     int err;
     struct ip_tunnel_parm p;
 
-    parse_args(argc, argv, SIOCGETTUNNEL, &p);
+    parse_args(argv, SIOCGETTUNNEL, &p);
 
     switch (p.iph.protocol) {
@@ -513 +550 @@
 
     print_tunnel(&p);
-    puts("");
+    bb_putchar('\n');
     return 0;
 }
 
 /* Return value becomes exitcode. It's okay to not return at all */
-int do_iptunnel(int argc, char **argv)
+int FAST_FUNC do_iptunnel(char **argv)
 {
     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)
+
+    if (*argv) {
+        smalluint key = index_in_substrings(keywords, *argv);
+        if (key > 5)
             bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
-        --argc;
-        ++argv;
+        argv++;
         if (key == ARG_add)
-            return do_add(SIOCADDTUNNEL, argc, argv);
+            return do_add(SIOCADDTUNNEL, argv);
         if (key == ARG_change)
-            return do_add(SIOCCHGTUNNEL, argc, argv);
+            return do_add(SIOCCHGTUNNEL, argv);
         if (key == ARG_del)
-            return do_del(argc, argv);
-    }
-    return do_show(argc, argv);
-}
+            return do_del(argv);
+    }
+    return do_show(argv);
+}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * libnetlink.c RTnetlink service routines.
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 
@@ -18 +15 @@
 #include "libnetlink.h"
 
-void rtnl_close(struct rtnl_handle *rth)
-{
-    close(rth->fd);
-}
-
-int xrtnl_open(struct rtnl_handle *rth/*, unsigned subscriptions*/)
+void FAST_FUNC xrtnl_open(struct rtnl_handle *rth/*, unsigned subscriptions*/)
 {
     socklen_t addr_len;
 
-    memset(rth, 0, sizeof(rth));
-
+    memset(rth, 0, sizeof(*rth));
     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;*/
@@ -37 +26 @@
     xbind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local));
     addr_len = sizeof(rth->local);
+    getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len);
+
+/* too much paranoia
     if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0)
-        bb_perror_msg_and_die("cannot getsockname");
+        bb_perror_msg_and_die("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 xrtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
+}
+
+int FAST_FUNC xrtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
 {
     struct {
@@ -53 +45 @@
         struct rtgenmsg g;
     } req;
-    struct sockaddr_nl nladdr;
-
-    memset(&nladdr, 0, sizeof(nladdr));
-    nladdr.nl_family = AF_NETLINK;
 
     req.nlh.nlmsg_len = sizeof(req);
@@ -65 +53 @@
     req.g.rtgen_family = family;
 
-    return xsendto(rth->fd, (void*)&req, sizeof(req),
-                 (struct sockaddr*)&nladdr, sizeof(nladdr));
-}
-
-int rtnl_send(struct rtnl_handle *rth, char *buf, int len)
+    return rtnl_send(rth, (void*)&req, sizeof(req));
+}
+
+int FAST_FUNC rtnl_send(struct rtnl_handle *rth, char *buf, int len)
 {
     struct sockaddr_nl nladdr;
@@ -79 +66 @@
 }
 
-int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
+int FAST_FUNC rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
 {
     struct nlmsghdr nlh;
@@ -86 +73 @@
     struct msghdr msg = {
         (void*)&nladdr, sizeof(nladdr),
-        iov,    2,
-        NULL,   0,
+        iov,  2,
+        NULL, 0,
         0
     };
@@ -104 +91 @@
 
 static int rtnl_dump_filter(struct rtnl_handle *rth,
-        int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
+        int (*filter)(const struct sockaddr_nl *, struct nlmsghdr *n, void *) FAST_FUNC,
         void *arg1/*,
         int (*junk)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
         void *arg2*/)
 {
-    char buf[8192];
+    int retval = -1;
+    char *buf = xmalloc(8*1024); /* avoid big stack buffer */
     struct sockaddr_nl nladdr;
-    struct iovec iov = { buf, sizeof(buf) };
+    struct iovec iov = { buf, 8*1024 };
 
     while (1) {
@@ -119 +107 @@
         struct msghdr msg = {
             (void*)&nladdr, sizeof(nladdr),
-            &iov,   1,
-            NULL,   0,
+            &iov, 1,
+            NULL, 0,
             0
         };
@@ -134 +122 @@
         if (status == 0) {
             bb_error_msg("EOF on netlink");
-            return -1;
+            goto ret;
         }
         if (msg.msg_namelen != sizeof(nladdr)) {
@@ -146 +134 @@
             if (nladdr.nl_pid != 0 ||
                 h->nlmsg_pid != rth->local.nl_pid ||
-                h->nlmsg_seq != rth->dump) {
-/*              if (junk) {
-                    err = junk(&nladdr, h, arg2);
-                    if (err < 0)
-                        return err;
-                } */
+                h->nlmsg_seq != rth->dump
+            ) {
+//              if (junk) {
+//                  err = junk(&nladdr, h, arg2);
+//                  if (err < 0) {
+//                      retval = err;
+//                      goto ret;
+//                  }
+//              }
                 goto skip_it;
             }
 
             if (h->nlmsg_type == NLMSG_DONE) {
-                return 0;
+                goto ret_0;
             }
             if (h->nlmsg_type == NLMSG_ERROR) {
@@ -166 +157 @@
                     bb_perror_msg("RTNETLINK answers");
                 }
-                return -1;
+                goto ret;
             }
             err = filter(&nladdr, h, arg1);
-            if (err < 0)
-                return err;
-
-skip_it:
+            if (err < 0) {
+                retval = err;
+                goto ret;
+            }
+
+ skip_it:
             h = NLMSG_NEXT(h, status);
         }
@@ -182 +175 @@
             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 *),
+    } /* while (1) */
+ ret_0:
+    retval++; /* = 0 */
+ ret:
+    free(buf);
+    return retval;
+}
+
+int FAST_FUNC xrtnl_dump_filter(struct rtnl_handle *rth,
+        int (*filter)(const struct sockaddr_nl *, struct nlmsghdr *, void *) FAST_FUNC,
         void *arg1)
 {
@@ -195 +193 @@
 }
 
-int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
-          unsigned groups, struct nlmsghdr *answer,
-          int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
-          void *jarg)
-{
+int FAST_FUNC rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n,
+        pid_t peer, unsigned groups,
+        struct nlmsghdr *answer,
+        int (*junk)(struct sockaddr_nl *, struct nlmsghdr *, void *),
+        void *jarg)
+{
+/* bbox doesn't use parameters no. 3, 4, 6, 7, they are stubbed out */
+#define peer   0
+#define groups 0
+#define junk   NULL
+#define jarg   NULL
+    int retval = -1;
     int status;
     unsigned seq;
@@ -205 +210 @@
     struct sockaddr_nl nladdr;
     struct iovec iov = { (void*)n, n->nlmsg_len };
-    char   buf[8192];
+    char   *buf = xmalloc(8*1024); /* avoid big stack buffer */
     struct msghdr msg = {
         (void*)&nladdr, sizeof(nladdr),
-        &iov,   1,
-        NULL,   0,
+        &iov, 1,
+        NULL, 0,
         0
     };
@@ -215 +220 @@
     memset(&nladdr, 0, sizeof(nladdr));
     nladdr.nl_family = AF_NETLINK;
-    nladdr.nl_pid = peer;
-    nladdr.nl_groups = groups;
+//  nladdr.nl_pid = peer;
+//  nladdr.nl_groups = groups;
 
     n->nlmsg_seq = seq = ++rtnl->seq;
@@ -225 +230 @@
 
     if (status < 0) {
-        bb_perror_msg("cannot talk to rtnetlink");
-        return -1;
+        bb_perror_msg("can't talk to rtnetlink");
+        goto ret;
     }
 
@@ -232 +237 @@
 
     while (1) {
-        iov.iov_len = sizeof(buf);
+        iov.iov_len = 8*1024;
         status = recvmsg(rtnl->fd, &msg, 0);
 
@@ -244 +249 @@
         if (status == 0) {
             bb_error_msg("EOF on netlink");
-            return -1;
+            goto ret;
         }
         if (msg.msg_namelen != sizeof(nladdr)) {
             bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
         }
-        for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
-            int l_err;
+        for (h = (struct nlmsghdr*)buf; status >= (int)sizeof(*h); ) {
+//          int l_err;
             int len = h->nlmsg_len;
             int l = len - sizeof(*h);
 
-            if (l<0 || len>status) {
+            if (l < 0 || len > status) {
                 if (msg.msg_flags & MSG_TRUNC) {
                     bb_error_msg("truncated message");
-                    return -1;
+                    goto ret;
                 }
                 bb_error_msg_and_die("malformed message: len=%d!", len);
@@ -264 +269 @@
             if (nladdr.nl_pid != peer ||
                 h->nlmsg_pid != rtnl->local.nl_pid ||
-                h->nlmsg_seq != seq) {
-                if (junk) {
-                    l_err = junk(&nladdr, h, jarg);
-                    if (l_err < 0) {
-                        return l_err;
-                    }
-                }
+                h->nlmsg_seq != seq
+            ) {
+//              if (junk) {
+//                  l_err = junk(&nladdr, h, jarg);
+//                  if (l_err < 0) {
+//                      retval = l_err;
+//                      goto ret;
+//                  }
+//              }
                 continue;
             }
@@ -276 +283 @@
             if (h->nlmsg_type == NLMSG_ERROR) {
                 struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
-                if (l < sizeof(struct nlmsgerr)) {
+                if (l < (int)sizeof(struct nlmsgerr)) {
                     bb_error_msg("ERROR truncated");
                 } else {
-                    errno = -err->error;
+                    errno = - err->error;
                     if (errno == 0) {
                         if (answer) {
                             memcpy(answer, h, h->nlmsg_len);
                         }
-                        return 0;
+                        goto ret_0;
                     }
                     bb_perror_msg("RTNETLINK answers");
                 }
-                return -1;
+                goto ret;
             }
             if (answer) {
                 memcpy(answer, h, h->nlmsg_len);
-                return 0;
+                goto ret_0;
             }
 
@@ -307 +314 @@
             bb_error_msg_and_die("remnant of size %d!", status);
         }
-    }
-}
-
-int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
+    } /* while (1) */
+ ret_0:
+    retval++; /* = 0 */
+ ret:
+    free(buf);
+    return retval;
+}
+
+int FAST_FUNC addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
 {
     int len = RTA_LENGTH(4);
     struct rtattr *rta;
-    if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
+
+    if ((int)(NLMSG_ALIGN(n->nlmsg_len) + len) > maxlen) {
         return -1;
+    }
     rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
     rta->rta_type = type;
     rta->rta_len = len;
-    memcpy(RTA_DATA(rta), &data, 4);
+    move_to_unaligned32(RTA_DATA(rta), data);
     n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
     return 0;
 }
 
-int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
+int FAST_FUNC addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
 {
     int len = RTA_LENGTH(alen);
     struct rtattr *rta;
 
-    if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
+    if ((int)(NLMSG_ALIGN(n->nlmsg_len) + len) > maxlen) {
         return -1;
+    }
     rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
     rta->rta_type = type;
@@ -339 +354 @@
 }
 
-int rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data)
+int FAST_FUNC rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data)
 {
     int len = RTA_LENGTH(4);
@@ -350 +365 @@
     subrta->rta_type = type;
     subrta->rta_len = len;
-    memcpy(RTA_DATA(subrta), &data, 4);
+    move_to_unaligned32(RTA_DATA(subrta), data);
     rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
     return 0;
 }
 
-int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
+int FAST_FUNC rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
 {
     struct rtattr *subrta;
@@ -372 +387 @@
 
 
-int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
+void FAST_FUNC parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
 {
     while (RTA_OK(rta, len)) {
@@ -383 +398 @@
         bb_error_msg("deficit %d, rta_len=%d!", len, rta->rta_len);
     }
-    return 0;
-}
+}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef __LIBNETLINK_H__
-#define __LIBNETLINK_H__ 1
+#ifndef LIBNETLINK_H
+#define LIBNETLINK_H 1
 
 #include <linux/types.h>
@@ -9 +9 @@
 #include <linux/rtnetlink.h>
 
-struct rtnl_handle
-{
-    int         fd;
-    struct sockaddr_nl  local;
-    struct sockaddr_nl  peer;
-    uint32_t        seq;
-    uint32_t        dump;
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
+
+struct rtnl_handle {
+    int                fd;
+    struct sockaddr_nl local;
+    struct sockaddr_nl peer;
+    uint32_t           seq;
+    uint32_t           dump;
 };
 
-extern int xrtnl_open(struct rtnl_handle *rth);
-extern void rtnl_close(struct rtnl_handle *rth);
-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 void xrtnl_open(struct rtnl_handle *rth) FAST_FUNC;
+#define rtnl_close(rth) (close((rth)->fd))
+extern int xrtnl_wilddump_request(struct rtnl_handle *rth, int fam, int type) FAST_FUNC;
+extern int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len) FAST_FUNC;
 extern int xrtnl_dump_filter(struct rtnl_handle *rth,
-            int (*filter)(struct sockaddr_nl*, struct nlmsghdr *n, void*),
-            void *arg1);
+        int (*filter)(const struct sockaddr_nl*, struct nlmsghdr *n, void*) FAST_FUNC,
+        void *arg1) FAST_FUNC;
+
+/* bbox doesn't use parameters no. 3, 4, 6, 7, stub them out */
+#define rtnl_talk(rtnl, n, peer, groups, answer, junk, jarg) \
+    rtnl_talk(rtnl, n, answer)
 extern int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
-            unsigned groups, struct nlmsghdr *answer,
-            int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
-            void *jarg);
-extern int rtnl_send(struct rtnl_handle *rth, char *buf, int);
+        unsigned groups, struct nlmsghdr *answer,
+        int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
+        void *jarg) FAST_FUNC;
+
+extern int rtnl_send(struct rtnl_handle *rth, char *buf, int) FAST_FUNC;
 
 
-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, uint32_t data);
-extern int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen);
+extern int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data) FAST_FUNC;
+extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen) FAST_FUNC;
+extern int rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data) FAST_FUNC;
+extern int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen) FAST_FUNC;
 
-extern int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len);
+extern void parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len) FAST_FUNC;
 
-#endif /* __LIBNETLINK_H__ */
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ll_addr.c
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 
@@ -18 +16 @@
 
 
-const char *ll_addr_n2a(unsigned char *addr, int alen, int type, char *buf, int blen)
+const char* FAST_FUNC ll_addr_n2a(unsigned char *addr, int alen, int type, char *buf, int blen)
 {
     int i;
     int l;
 
-    if (alen == 4 &&
-        (type == ARPHRD_TUNNEL || type == ARPHRD_SIT || type == ARPHRD_IPGRE)) {
+    if (alen == 4
+     && (type == ARPHRD_TUNNEL || type == ARPHRD_SIT || type == ARPHRD_IPGRE)
+    ) {
         return inet_ntop(AF_INET, addr, buf, blen);
     }
     l = 0;
-    for (i=0; i<alen; i++) {
-        if (i==0) {
-            snprintf(buf+l, blen, ":%02x"+1, addr[i]);
+    for (i = 0; i < alen; i++) {
+        if (i == 0) {
+            snprintf(buf + l, blen, ":%02x"+1, addr[i]);
             blen -= 2;
             l += 2;
         } else {
-            snprintf(buf+l, blen, ":%02x", addr[i]);
+            snprintf(buf + l, blen, ":%02x", addr[i]);
             blen -= 3;
             l += 3;
@@ -42 +41 @@
 }
 
-int ll_addr_a2n(unsigned char *lladdr, int len, char *arg)
+int FAST_FUNC ll_addr_a2n(unsigned char *lladdr, int len, char *arg)
 {
+    int i;
+
     if (strchr(arg, '.')) {
         inet_prefix pfx;
@@ -55 +56 @@
         memcpy(lladdr, pfx.data, 4);
         return 4;
-    } else {
-        int i;
+    }
 
-        for (i=0; i<len; i++) {
-            int temp;
-            char *cp = strchr(arg, ':');
-            if (cp) {
-                *cp = 0;
-                cp++;
-            }
-            if (sscanf(arg, "%x", &temp) != 1) {
-                bb_error_msg("\"%s\" is invalid lladdr", arg);
-                return -1;
-            }
-            if (temp < 0 || temp > 255) {
-                bb_error_msg("\"%s\" is invalid lladdr", arg);
-                return -1;
-            }
-            lladdr[i] = temp;
-            if (!cp) {
-                break;
-            }
-            arg = cp;
+    for (i = 0; i < len; i++) {
+        int temp;
+        char *cp = strchr(arg, ':');
+        if (cp) {
+            *cp = 0;
+            cp++;
         }
-        return i+1;
+        if (sscanf(arg, "%x", &temp) != 1 || (temp < 0 || temp > 255)) {
+            bb_error_msg("\"%s\" is invalid lladdr", arg);
+            return -1;
+        }
+        lladdr[i] = temp;
+        if (!cp) {
+            break;
+        }
+        arg = cp;
     }
+    return i+1;
 }

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ll_map.c
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 
-#include <net/if.h> /* struct ifreq and co. */
+#include <net/if.h>  /* struct ifreq and co. */
 
 #include "libbb.h"
@@ -28 +25 @@
 };
 
-static struct idxmap *idxmap[16];
+static struct idxmap **idxmap; /* treat as *idxmap[16] */
 
 static struct idxmap *find_by_index(int idx)
@@ -34 +31 @@
     struct idxmap *im;
 
-    for (im = idxmap[idx & 0xF]; im; im = im->next)
-        if (im->index == idx)
-            return im;
+    if (idxmap)
+        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)
+int FAST_FUNC ll_remember_index(const struct sockaddr_nl *who UNUSED_PARAM,
+        struct nlmsghdr *n,
+        void *arg UNUSED_PARAM)
 {
     int h;
@@ -58 +58 @@
         return 0;
 
+    if (!idxmap)
+        idxmap = xzalloc(sizeof(idxmap[0]) * 16);
+
     h = ifi->ifi_index & 0xF;
-
     for (imp = &idxmap[h]; (im = *imp) != NULL; imp = &im->next)
         if (im->index == ifi->ifi_index)
@@ -74 +76 @@
         int alen;
         im->alen = alen = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
-        if (alen > sizeof(im->addr))
+        if (alen > (int)sizeof(im->addr))
             alen = sizeof(im->addr);
         memcpy(im->addr, RTA_DATA(tb[IFLA_ADDRESS]), alen);
@@ -85 +87 @@
 }
 
-const char *ll_idx_n2a(int idx, char *buf)
+const char FAST_FUNC *ll_idx_n2a(int idx, char *buf)
 {
     struct idxmap *im;
@@ -99 +101 @@
 
 
-const char *ll_index_to_name(int idx)
+const char FAST_FUNC *ll_index_to_name(int idx)
 {
     static char nbuf[16];
@@ -120 +122 @@
 #endif
 
-unsigned ll_index_to_flags(int idx)
+unsigned FAST_FUNC ll_index_to_flags(int idx)
 {
     struct idxmap *im;
@@ -132 +134 @@
 }
 
-int xll_name_to_index(const char *const name)
+int FAST_FUNC xll_name_to_index(const char *name)
 {
     int ret = 0;
@@ -151 +153 @@
         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);
-                ret = im->index;
-                goto out;
+    if (idxmap) {
+        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);
+                    ret = im->index;
+                    goto out;
+                }
             }
         }
@@ -171 +175 @@
 
     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sock_fd) {
+    if (sock_fd >= 0) {
         struct ifreq ifr;
         int tmp;
 
-        strncpy(ifr.ifr_name, name, IFNAMSIZ);
+        strncpy_IFNAMSIZ(ifr.ifr_name, name);
         ifr.ifr_ifindex = -1;
         tmp = ioctl(sock_fd, SIOCGIFINDEX, &ifr);
@@ -187 +191 @@
 /* out:*/
     if (ret <= 0)
-        bb_error_msg_and_die("cannot find device \"%s\"", name);
+        bb_error_msg_and_die("can't find device '%s'", name);
     return ret;
 }
 
-int ll_init_map(struct rtnl_handle *rth)
+int FAST_FUNC ll_init_map(struct rtnl_handle *rth)
 {
     xrtnl_wilddump_request(rth, AF_UNSPEC, RTM_GETLINK);
-    xrtnl_dump_filter(rth, ll_remember_index, &idxmap);
+    xrtnl_dump_filter(rth, ll_remember_index, NULL);
     return 0;
 }

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef __LL_MAP_H__
-#define __LL_MAP_H__ 1
+#ifndef LL_MAP_H
+#define LL_MAP_H 1
 
-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);
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
+
+int ll_remember_index(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) FAST_FUNC;
+int ll_init_map(struct rtnl_handle *rth) FAST_FUNC;
+int xll_name_to_index(const char *name) FAST_FUNC;
+const char *ll_index_to_name(int idx) FAST_FUNC;
+const char *ll_idx_n2a(int idx, char *buf) FAST_FUNC;
 /* int ll_index_to_type(int idx); */
-unsigned ll_index_to_flags(int idx);
+unsigned ll_index_to_flags(int idx) FAST_FUNC;
 
-#endif /* __LL_MAP_H__ */
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ll_proto.c
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 
@@ -20 +18 @@
 #include <linux/if_ether.h>
 #endif
+
+#if !ENABLE_WERROR
+#warning de-bloat
+#endif
+/* Before re-enabling this, please (1) conditionalize exotic protocols
+ * on CONFIG_something, and (2) decouple strings and numbers
+ * (use llproto_ids[] = n,n,n..; and llproto_names[] = "loop\0" "pup\0" ...;)
+ */
 
 #define __PF(f,n) { ETH_P_##f, #n },
@@ -91 +97 @@
 
 
-const char * ll_proto_n2a(unsigned short id, char *buf, int len)
+const char* FAST_FUNC ll_proto_n2a(unsigned short id, char *buf, int len)
 {
-    int i;
-
+    unsigned i;
     id = ntohs(id);
-
-    for (i=0; i < ARRAY_SIZE(llproto_names); i++) {
+    for (i = 0; i < ARRAY_SIZE(llproto_names); i++) {
          if (llproto_names[i].id == id)
             return llproto_names[i].name;
@@ -105 +109 @@
 }
 
-int ll_proto_a2n(unsigned short *id, char *buf)
+int FAST_FUNC ll_proto_a2n(unsigned short *id, char *buf)
 {
-    int i;
-    for (i=0; i < ARRAY_SIZE(llproto_names); i++) {
+    unsigned i;
+    for (i = 0; i < ARRAY_SIZE(llproto_names); i++) {
          if (strcasecmp(llproto_names[i].name, buf) == 0) {
-             *id = htons(llproto_names[i].id);
-             return 0;
+             i = llproto_names[i].id;
+             goto good;
          }
     }
-    if (get_u16(id, buf, 0))
+    i = bb_strtou(buf, NULL, 0);
+    if (errno || i > 0xffff)
         return -1;
-    *id = htons(*id);
+ good:
+    *id = htons(i);
     return 0;
 }

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * ll_types.c
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 #include <arpa/inet.h>
@@ -16 +14 @@
 #include "rt_names.h"
 
-const char* ll_type_n2a(int type, char *buf, int len)
+const char* FAST_FUNC ll_type_n2a(int type, char *buf)
 {
-#define __PF(f,n) { ARPHRD_##f, #n },
-static const struct {
-    int type;
-    const char *name;
-} arphrd_names[] = {
-{ 0, "generic" },
-__PF(ETHER,ether)
-__PF(EETHER,eether)
-__PF(AX25,ax25)
-__PF(PRONET,pronet)
-__PF(CHAOS,chaos)
+    static const char arphrd_name[] =
+    /* 0,                  */ "generic" "\0"
+    /* ARPHRD_LOOPBACK,    */ "loopback" "\0"
+    /* ARPHRD_ETHER,       */ "ether" "\0"
+#ifdef ARPHRD_INFINIBAND
+    /* ARPHRD_INFINIBAND,  */ "infiniband" "\0"
+#endif
 #ifdef ARPHRD_IEEE802_TR
-__PF(IEEE802,ieee802)
+    /* ARPHRD_IEEE802,     */ "ieee802" "\0"
+    /* ARPHRD_IEEE802_TR,  */ "tr" "\0"
 #else
-__PF(IEEE802,tr)
-#endif
-__PF(ARCNET,arcnet)
-__PF(APPLETLK,atalk)
-__PF(DLCI,dlci)
+    /* ARPHRD_IEEE802,     */ "tr" "\0"
+#endif
+#ifdef ARPHRD_IEEE80211
+    /* ARPHRD_IEEE80211,   */ "ieee802.11" "\0"
+#endif
+#ifdef ARPHRD_IEEE1394
+    /* ARPHRD_IEEE1394,    */ "ieee1394" "\0"
+#endif
+    /* ARPHRD_IRDA,        */ "irda" "\0"
+    /* ARPHRD_SLIP,        */ "slip" "\0"
+    /* ARPHRD_CSLIP,       */ "cslip" "\0"
+    /* ARPHRD_SLIP6,       */ "slip6" "\0"
+    /* ARPHRD_CSLIP6,      */ "cslip6" "\0"
+    /* ARPHRD_PPP,         */ "ppp" "\0"
+    /* ARPHRD_TUNNEL,      */ "ipip" "\0"
+    /* ARPHRD_TUNNEL6,     */ "tunnel6" "\0"
+    /* ARPHRD_SIT,         */ "sit" "\0"
+    /* ARPHRD_IPGRE,       */ "gre" "\0"
+#ifdef ARPHRD_VOID
+    /* ARPHRD_VOID,        */ "void" "\0"
+#endif
+
+#if ENABLE_FEATURE_IP_RARE_PROTOCOLS
+    /* ARPHRD_EETHER,      */ "eether" "\0"
+    /* ARPHRD_AX25,        */ "ax25" "\0"
+    /* ARPHRD_PRONET,      */ "pronet" "\0"
+    /* ARPHRD_CHAOS,       */ "chaos" "\0"
+    /* ARPHRD_ARCNET,      */ "arcnet" "\0"
+    /* ARPHRD_APPLETLK,    */ "atalk" "\0"
+    /* ARPHRD_DLCI,        */ "dlci" "\0"
 #ifdef ARPHRD_ATM
-__PF(ATM,atm)
-#endif
-__PF(METRICOM,metricom)
+    /* ARPHRD_ATM,         */ "atm" "\0"
+#endif
+    /* ARPHRD_METRICOM,    */ "metricom" "\0"
+    /* ARPHRD_RSRVD,       */ "rsrvd" "\0"
+    /* ARPHRD_ADAPT,       */ "adapt" "\0"
+    /* ARPHRD_ROSE,        */ "rose" "\0"
+    /* ARPHRD_X25,         */ "x25" "\0"
+#ifdef ARPHRD_HWX25
+    /* ARPHRD_HWX25,       */ "hwx25" "\0"
+#endif
+    /* ARPHRD_HDLC,        */ "hdlc" "\0"
+    /* ARPHRD_LAPB,        */ "lapb" "\0"
+#ifdef ARPHRD_DDCMP
+    /* ARPHRD_DDCMP,       */ "ddcmp" "\0"
+    /* ARPHRD_RAWHDLC,     */ "rawhdlc" "\0"
+#endif
+    /* ARPHRD_FRAD,        */ "frad" "\0"
+    /* ARPHRD_SKIP,        */ "skip" "\0"
+    /* ARPHRD_LOCALTLK,    */ "ltalk" "\0"
+    /* ARPHRD_FDDI,        */ "fddi" "\0"
+    /* ARPHRD_BIF,         */ "bif" "\0"
+    /* ARPHRD_IPDDP,       */ "ip/ddp" "\0"
+    /* ARPHRD_PIMREG,      */ "pimreg" "\0"
+    /* ARPHRD_HIPPI,       */ "hippi" "\0"
+    /* ARPHRD_ASH,         */ "ash" "\0"
+    /* ARPHRD_ECONET,      */ "econet" "\0"
+    /* ARPHRD_FCPP,        */ "fcpp" "\0"
+    /* ARPHRD_FCAL,        */ "fcal" "\0"
+    /* ARPHRD_FCPL,        */ "fcpl" "\0"
+    /* ARPHRD_FCFABRIC,    */ "fcfb0" "\0"
+    /* ARPHRD_FCFABRIC+1,  */ "fcfb1" "\0"
+    /* ARPHRD_FCFABRIC+2,  */ "fcfb2" "\0"
+    /* ARPHRD_FCFABRIC+3,  */ "fcfb3" "\0"
+    /* ARPHRD_FCFABRIC+4,  */ "fcfb4" "\0"
+    /* ARPHRD_FCFABRIC+5,  */ "fcfb5" "\0"
+    /* ARPHRD_FCFABRIC+6,  */ "fcfb6" "\0"
+    /* ARPHRD_FCFABRIC+7,  */ "fcfb7" "\0"
+    /* ARPHRD_FCFABRIC+8,  */ "fcfb8" "\0"
+    /* ARPHRD_FCFABRIC+9,  */ "fcfb9" "\0"
+    /* ARPHRD_FCFABRIC+10, */ "fcfb10" "\0"
+    /* ARPHRD_FCFABRIC+11, */ "fcfb11" "\0"
+    /* ARPHRD_FCFABRIC+12, */ "fcfb12" "\0"
+#endif /* FEATURE_IP_RARE_PROTOCOLS */
+    ;
+
+    /* Keep these arrays in sync! */
+
+    static const uint16_t arphrd_type[] = {
+    0,                  /* "generic" "\0" */
+    ARPHRD_LOOPBACK,    /* "loopback" "\0" */
+    ARPHRD_ETHER,       /* "ether" "\0" */
+#ifdef ARPHRD_INFINIBAND
+    ARPHRD_INFINIBAND,  /* "infiniband" "\0" */
+#endif
+#ifdef ARPHRD_IEEE802_TR
+    ARPHRD_IEEE802,     /* "ieee802" "\0" */
+    ARPHRD_IEEE802_TR,  /* "tr" "\0" */
+#else
+    ARPHRD_IEEE802,     /* "tr" "\0" */
+#endif
+#ifdef ARPHRD_IEEE80211
+    ARPHRD_IEEE80211,   /* "ieee802.11" "\0" */
+#endif
 #ifdef ARPHRD_IEEE1394
-__PF(IEEE1394,ieee1394)
-#endif
-
-__PF(SLIP,slip)
-__PF(CSLIP,cslip)
-__PF(SLIP6,slip6)
-__PF(CSLIP6,cslip6)
-__PF(RSRVD,rsrvd)
-__PF(ADAPT,adapt)
-__PF(ROSE,rose)
-__PF(X25,x25)
+    ARPHRD_IEEE1394,    /* "ieee1394" "\0" */
+#endif
+    ARPHRD_IRDA,        /* "irda" "\0" */
+    ARPHRD_SLIP,        /* "slip" "\0" */
+    ARPHRD_CSLIP,       /* "cslip" "\0" */
+    ARPHRD_SLIP6,       /* "slip6" "\0" */
+    ARPHRD_CSLIP6,      /* "cslip6" "\0" */
+    ARPHRD_PPP,         /* "ppp" "\0" */
+    ARPHRD_TUNNEL,      /* "ipip" "\0" */
+    ARPHRD_TUNNEL6,     /* "tunnel6" "\0" */
+    ARPHRD_SIT,         /* "sit" "\0" */
+    ARPHRD_IPGRE,       /* "gre" "\0" */
+#ifdef ARPHRD_VOID
+    ARPHRD_VOID,        /* "void" "\0" */
+#endif
+
+#if ENABLE_FEATURE_IP_RARE_PROTOCOLS
+    ARPHRD_EETHER,      /* "eether" "\0" */
+    ARPHRD_AX25,        /* "ax25" "\0" */
+    ARPHRD_PRONET,      /* "pronet" "\0" */
+    ARPHRD_CHAOS,       /* "chaos" "\0" */
+    ARPHRD_ARCNET,      /* "arcnet" "\0" */
+    ARPHRD_APPLETLK,    /* "atalk" "\0" */
+    ARPHRD_DLCI,        /* "dlci" "\0" */
+#ifdef ARPHRD_ATM
+    ARPHRD_ATM,         /* "atm" "\0" */
+#endif
+    ARPHRD_METRICOM,    /* "metricom" "\0" */
+    ARPHRD_RSRVD,       /* "rsrvd" "\0" */
+    ARPHRD_ADAPT,       /* "adapt" "\0" */
+    ARPHRD_ROSE,        /* "rose" "\0" */
+    ARPHRD_X25,         /* "x25" "\0" */
 #ifdef ARPHRD_HWX25
-__PF(HWX25,hwx25)
-#endif
-__PF(PPP,ppp)
-__PF(HDLC,hdlc)
-__PF(LAPB,lapb)
+    ARPHRD_HWX25,       /* "hwx25" "\0" */
+#endif
+    ARPHRD_HDLC,        /* "hdlc" "\0" */
+    ARPHRD_LAPB,        /* "lapb" "\0" */
 #ifdef ARPHRD_DDCMP
-__PF(DDCMP,ddcmp)
-__PF(RAWHDLC,rawhdlc)
-#endif
-
-__PF(TUNNEL,ipip)
-__PF(TUNNEL6,tunnel6)
-__PF(FRAD,frad)
-__PF(SKIP,skip)
-__PF(LOOPBACK,loopback)
-__PF(LOCALTLK,ltalk)
-__PF(FDDI,fddi)
-__PF(BIF,bif)
-__PF(SIT,sit)
-__PF(IPDDP,ip/ddp)
-__PF(IPGRE,gre)
-__PF(PIMREG,pimreg)
-__PF(HIPPI,hippi)
-__PF(ASH,ash)
-__PF(ECONET,econet)
-__PF(IRDA,irda)
-__PF(FCPP,fcpp)
-__PF(FCAL,fcal)
-__PF(FCPL,fcpl)
-__PF(FCFABRIC,fcfb0)
-__PF(FCFABRIC+1,fcfb1)
-__PF(FCFABRIC+2,fcfb2)
-__PF(FCFABRIC+3,fcfb3)
-__PF(FCFABRIC+4,fcfb4)
-__PF(FCFABRIC+5,fcfb5)
-__PF(FCFABRIC+6,fcfb6)
-__PF(FCFABRIC+7,fcfb7)
-__PF(FCFABRIC+8,fcfb8)
-__PF(FCFABRIC+9,fcfb9)
-__PF(FCFABRIC+10,fcfb10)
-__PF(FCFABRIC+11,fcfb11)
-__PF(FCFABRIC+12,fcfb12)
-#ifdef ARPHRD_IEEE802_TR
-__PF(IEEE802_TR,tr)
-#endif
-#ifdef ARPHRD_IEEE80211
-__PF(IEEE80211,ieee802.11)
-#endif
-#ifdef ARPHRD_VOID
-__PF(VOID,void)
-#endif
-};
-#undef __PF
-
-    int i;
-    for (i = 0; i < ARRAY_SIZE(arphrd_names); i++) {
-         if (arphrd_names[i].type == type)
-            return arphrd_names[i].name;
+    ARPHRD_DDCMP,       /* "ddcmp" "\0" */
+    ARPHRD_RAWHDLC,     /* "rawhdlc" "\0" */
+#endif
+    ARPHRD_FRAD,        /* "frad" "\0" */
+    ARPHRD_SKIP,        /* "skip" "\0" */
+    ARPHRD_LOCALTLK,    /* "ltalk" "\0" */
+    ARPHRD_FDDI,        /* "fddi" "\0" */
+    ARPHRD_BIF,         /* "bif" "\0" */
+    ARPHRD_IPDDP,       /* "ip/ddp" "\0" */
+    ARPHRD_PIMREG,      /* "pimreg" "\0" */
+    ARPHRD_HIPPI,       /* "hippi" "\0" */
+    ARPHRD_ASH,         /* "ash" "\0" */
+    ARPHRD_ECONET,      /* "econet" "\0" */
+    ARPHRD_FCPP,        /* "fcpp" "\0" */
+    ARPHRD_FCAL,        /* "fcal" "\0" */
+    ARPHRD_FCPL,        /* "fcpl" "\0" */
+    ARPHRD_FCFABRIC,    /* "fcfb0" "\0" */
+    ARPHRD_FCFABRIC+1,  /* "fcfb1" "\0" */
+    ARPHRD_FCFABRIC+2,  /* "fcfb2" "\0" */
+    ARPHRD_FCFABRIC+3,  /* "fcfb3" "\0" */
+    ARPHRD_FCFABRIC+4,  /* "fcfb4" "\0" */
+    ARPHRD_FCFABRIC+5,  /* "fcfb5" "\0" */
+    ARPHRD_FCFABRIC+6,  /* "fcfb6" "\0" */
+    ARPHRD_FCFABRIC+7,  /* "fcfb7" "\0" */
+    ARPHRD_FCFABRIC+8,  /* "fcfb8" "\0" */
+    ARPHRD_FCFABRIC+9,  /* "fcfb9" "\0" */
+    ARPHRD_FCFABRIC+10, /* "fcfb10" "\0" */
+    ARPHRD_FCFABRIC+11, /* "fcfb11" "\0" */
+    ARPHRD_FCFABRIC+12, /* "fcfb12" "\0" */
+#endif /* FEATURE_IP_RARE_PROTOCOLS */
+    };
+
+    unsigned i;
+    const char *aname = arphrd_name;
+    for (i = 0; i < ARRAY_SIZE(arphrd_type); i++) {
+        if (arphrd_type[i] == type)
+            return aname;
+        aname += strlen(aname) + 1;
     }
-    snprintf(buf, len, "[%d]", type);
+    sprintf(buf, "[%d]", type);
     return buf;
 }

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * rt_names.c       rtnetlink names DB.
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
-
 #include "libbb.h"
 #include "rt_names.h"
 
-static void rtnl_tab_initialize(const char *file, const char **tab, int size)
-{
-    char buf[512];
-    FILE *fp;
-
-    fp = fopen(file, "r");
-    if (!fp)
-        return;
-    while (fgets(buf, sizeof(buf), fp)) {
-        char *p = buf;
-        int id;
-        char namebuf[512];
-
-        while (*p == ' ' || *p == '\t')
-            p++;
-        if (*p == '#' || *p == '\n' || *p == 0)
-            continue;
-        if (sscanf(p, "0x%x %s\n", &id, namebuf) != 2
-         && sscanf(p, "0x%x %s #", &id, namebuf) != 2
-         && sscanf(p, "%d %s\n", &id, namebuf) != 2
-         && sscanf(p, "%d %s #", &id, namebuf) != 2
+typedef struct rtnl_tab_t {
+    const char *cached_str;
+    unsigned cached_result;
+    const char *tab[256];
+} rtnl_tab_t;
+
+static void rtnl_tab_initialize(const char *file, const char **tab)
+{
+    char *token[2];
+    parser_t *parser = config_open2(file, fopen_for_read);
+
+    while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) {
+        unsigned id = bb_strtou(token[0], NULL, 0);
+        if (id > 256) {
+            bb_error_msg("database %s is corrupted at line %d",
+                file, parser->lineno);
+            break;
+        }
+        tab[id] = xstrdup(token[1]);
+    }
+    config_close(parser);
+}
+
+static int rtnl_a2n(rtnl_tab_t *tab, uint32_t *id, const char *arg, int base)
+{
+    unsigned i;
+
+    if (tab->cached_str && strcmp(tab->cached_str, arg) == 0) {
+        *id = tab->cached_result;
+        return 0;
+    }
+
+    for (i = 0; i < 256; i++) {
+        if (tab->tab[i]
+         && strcmp(tab->tab[i], arg) == 0
         ) {
-            bb_error_msg("database %s is corrupted at %s",
-                file, p);
-            return;
+            tab->cached_str = tab->tab[i];
+            tab->cached_result = i;
+            *id = i;
+            return 0;
         }
-
-        if (id < 0 || id > size)
-            continue;
-
-        tab[id] = xstrdup(namebuf);
-    }
-    fclose(fp);
-}
-
-
-static const char **rtnl_rtprot_tab; /* [256] */
+    }
+
+    i = bb_strtou(arg, NULL, base);
+    if (i > 255)
+        return -1;
+    *id = i;
+    return 0;
+}
+
+
+static rtnl_tab_t *rtnl_rtprot_tab;
 
 static void rtnl_rtprot_initialize(void)
@@ -69 +81 @@
         "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);
+
+    if (rtnl_rtprot_tab)
+        return;
+    rtnl_rtprot_tab = xzalloc(sizeof(*rtnl_rtprot_tab));
+    memcpy(rtnl_rtprot_tab->tab, init_tab, sizeof(init_tab));
+    rtnl_tab_initialize("/etc/iproute2/rt_protos", rtnl_rtprot_tab->tab);
+}
+
+const char* FAST_FUNC rtnl_rtprot_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -86 +98 @@
     rtnl_rtprot_initialize();
 
-    if (rtnl_rtprot_tab[id])
-        return rtnl_rtprot_tab[id];
-    snprintf(buf, len, "%d", id);
-    return buf;
-}
-
-int rtnl_rtprot_a2n(uint32_t *id, char *arg)
-{
-    static const char *cache = NULL;
-    static unsigned long res;
-    int i;
-
-    if (cache && strcmp(cache, arg) == 0) {
-        *id = res;
-        return 0;
-    }
-
+    if (rtnl_rtprot_tab->tab[id])
+        return rtnl_rtprot_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+}
+
+int FAST_FUNC rtnl_rtprot_a2n(uint32_t *id, char *arg)
+{
     rtnl_rtprot_initialize();
-
-    for (i = 0; i < 256; i++) {
-        if (rtnl_rtprot_tab[i] &&
-            strcmp(rtnl_rtprot_tab[i], arg) == 0) {
-            cache = rtnl_rtprot_tab[i];
-            res = i;
-            *id = res;
-            return 0;
-        }
-    }
-
-    res = bb_strtoul(arg, NULL, 0);
-    if (errno || res > 255)
-        return -1;
-    *id = res;
-    return 0;
-}
-
-
-static const char **rtnl_rtscope_tab; /* [256] */
+    return rtnl_a2n(rtnl_rtprot_tab, id, arg, 0);
+}
+
+
+static rtnl_tab_t *rtnl_rtscope_tab;
 
 static void rtnl_rtscope_initialize(void)
 {
-    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";
-    rtnl_rtscope_tab[253] = "link";
-    rtnl_rtscope_tab[200] = "site";
-    rtnl_tab_initialize("/etc/iproute2/rt_scopes",
-                rtnl_rtscope_tab, 256);
-}
-
-
-const char* rtnl_rtscope_n2a(int id, char *buf, int len)
-{
-    if (id < 0 || id >= 256) {
-        snprintf(buf, len, "%d", id);
+    if (rtnl_rtscope_tab)
+        return;
+    rtnl_rtscope_tab = xzalloc(sizeof(*rtnl_rtscope_tab));
+    rtnl_rtscope_tab->tab[0] = "global";
+    rtnl_rtscope_tab->tab[255] = "nowhere";
+    rtnl_rtscope_tab->tab[254] = "host";
+    rtnl_rtscope_tab->tab[253] = "link";
+    rtnl_rtscope_tab->tab[200] = "site";
+    rtnl_tab_initialize("/etc/iproute2/rt_scopes", rtnl_rtscope_tab->tab);
+}
+
+const char* FAST_FUNC rtnl_rtscope_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -148 +136 @@
     rtnl_rtscope_initialize();
 
-    if (rtnl_rtscope_tab[id])
-        return rtnl_rtscope_tab[id];
-    snprintf(buf, len, "%d", id);
-    return buf;
-}
-
-int rtnl_rtscope_a2n(uint32_t *id, char *arg)
-{
-    static const char *cache = NULL;
-    static unsigned long res;
-    int i;
-
-    if (cache && strcmp(cache, arg) == 0) {
-        *id = res;
-        return 0;
-    }
-
+    if (rtnl_rtscope_tab->tab[id])
+        return rtnl_rtscope_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+}
+
+int FAST_FUNC rtnl_rtscope_a2n(uint32_t *id, char *arg)
+{
     rtnl_rtscope_initialize();
-
-    for (i = 0; i < 256; i++) {
-        if (rtnl_rtscope_tab[i] &&
-            strcmp(rtnl_rtscope_tab[i], arg) == 0) {
-            cache = rtnl_rtscope_tab[i];
-            res = i;
-            *id = res;
-            return 0;
-        }
-    }
-
-    res = bb_strtoul(arg, NULL, 0);
-    if (errno || res > 255)
-        return -1;
-    *id = res;
-    return 0;
-}
-
-
-static const char **rtnl_rtrealm_tab; /* [256] */
+    return rtnl_a2n(rtnl_rtscope_tab, id, arg, 0);
+}
+
+
+static rtnl_tab_t *rtnl_rtrealm_tab;
 
 static void rtnl_rtrealm_initialize(void)
 {
     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 const char *cache = NULL;
-    static unsigned long res;
-    int i;
-
-    if (cache && strcmp(cache, arg) == 0) {
-        *id = res;
-        return 0;
-    }
-
+    rtnl_rtrealm_tab = xzalloc(sizeof(*rtnl_rtrealm_tab));
+    rtnl_rtrealm_tab->tab[0] = "unknown";
+    rtnl_tab_initialize("/etc/iproute2/rt_realms", rtnl_rtrealm_tab->tab);
+}
+
+int FAST_FUNC rtnl_rtrealm_a2n(uint32_t *id, char *arg)
+{
     rtnl_rtrealm_initialize();
-
-    for (i = 0; i < 256; i++) {
-        if (rtnl_rtrealm_tab[i] &&
-            strcmp(rtnl_rtrealm_tab[i], arg) == 0) {
-            cache = rtnl_rtrealm_tab[i];
-            res = i;
-            *id = res;
-            return 0;
-        }
-    }
-
-    res = bb_strtoul(arg, NULL, 0);
-    if (errno || res > 255)
-        return -1;
-    *id = res;
-    return 0;
+    return rtnl_a2n(rtnl_rtrealm_tab, id, arg, 0);
 }
 
 #if ENABLE_FEATURE_IP_RULE
-const char* rtnl_rtrealm_n2a(int id, char *buf, int len)
-{
-    if (id < 0 || id >= 256) {
-        snprintf(buf, len, "%d", id);
+const char* FAST_FUNC rtnl_rtrealm_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -237 +176 @@
     rtnl_rtrealm_initialize();
 
-    if (rtnl_rtrealm_tab[id])
-        return rtnl_rtrealm_tab[id];
-    snprintf(buf, len, "%d", id);
+    if (rtnl_rtrealm_tab->tab[id])
+        return rtnl_rtrealm_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
     return buf;
 }
@@ -245 +185 @@
 
 
-static const char **rtnl_rtdsfield_tab; /* [256] */
+static rtnl_tab_t *rtnl_rtdsfield_tab;
 
 static void rtnl_rtdsfield_initialize(void)
 {
     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);
+    rtnl_rtdsfield_tab = xzalloc(sizeof(*rtnl_rtdsfield_tab));
+    rtnl_rtdsfield_tab->tab[0] = "0";
+    rtnl_tab_initialize("/etc/iproute2/rt_dsfield", rtnl_rtdsfield_tab->tab);
+}
+
+const char* FAST_FUNC rtnl_dsfield_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -266 +204 @@
     rtnl_rtdsfield_initialize();
 
-    if (rtnl_rtdsfield_tab[id])
-        return rtnl_rtdsfield_tab[id];
-    snprintf(buf, len, "0x%02x", id);
-    return buf;
-}
-
-
-int rtnl_dsfield_a2n(uint32_t *id, char *arg)
-{
-    static const char *cache = NULL;
-    static unsigned long res;
-    int i;
-
-    if (cache && strcmp(cache, arg) == 0) {
-        *id = res;
-        return 0;
-    }
-
+    if (rtnl_rtdsfield_tab->tab[id])
+        return rtnl_rtdsfield_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "0x%02x", id);
+    return buf;
+}
+
+int FAST_FUNC rtnl_dsfield_a2n(uint32_t *id, char *arg)
+{
     rtnl_rtdsfield_initialize();
-
-    for (i = 0; i < 256; i++) {
-        if (rtnl_rtdsfield_tab[i] &&
-            strcmp(rtnl_rtdsfield_tab[i], arg) == 0) {
-            cache = rtnl_rtdsfield_tab[i];
-            res = i;
-            *id = res;
-            return 0;
-        }
-    }
-
-    res = bb_strtoul(arg, NULL, 16);
-    if (errno || res > 255)
-        return -1;
-    *id = res;
-    return 0;
+    return rtnl_a2n(rtnl_rtdsfield_tab, id, arg, 16);
 }
 
 
 #if ENABLE_FEATURE_IP_RULE
-static const char **rtnl_rttable_tab; /* [256] */
+static rtnl_tab_t *rtnl_rttable_tab;
 
 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);
+    rtnl_rttable_tab = xzalloc(sizeof(*rtnl_rttable_tab));
+    rtnl_rttable_tab->tab[0] = "unspec";
+    rtnl_rttable_tab->tab[255] = "local";
+    rtnl_rttable_tab->tab[254] = "main";
+    rtnl_rttable_tab->tab[253] = "default";
+    rtnl_tab_initialize("/etc/iproute2/rt_tables", rtnl_rttable_tab->tab);
+}
+
+const char* FAST_FUNC rtnl_rttable_n2a(int id, char *buf)
+{
+    if (id < 0 || id >= 256) {
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -328 +241 @@
     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;
-    }
-
+    if (rtnl_rttable_tab->tab[id])
+        return rtnl_rttable_tab->tab[id];
+    /* buf is SPRINT_BSIZE big */
+    sprintf(buf, "%d", id);
+    return buf;
+}
+
+int FAST_FUNC rtnl_rttable_a2n(uint32_t *id, char *arg)
+{
     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;
+    return rtnl_a2n(rtnl_rttable_tab, id, arg, 0);
 }
 

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef RT_NAMES_H_
-#define RT_NAMES_H_ 1
+#ifndef RT_NAMES_H
+#define RT_NAMES_H 1
 
-#include <stdint.h>
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
-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);
+/* buf is SPRINT_BSIZE big */
+extern const char* rtnl_rtprot_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rtscope_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rtrealm_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_dsfield_n2a(int id, char *buf) FAST_FUNC;
+extern const char* rtnl_rttable_n2a(int id, char *buf) FAST_FUNC;
+extern int rtnl_rtprot_a2n(uint32_t *id, char *arg) FAST_FUNC;
+extern int rtnl_rtscope_a2n(uint32_t *id, char *arg) FAST_FUNC;
+extern int rtnl_rtrealm_a2n(uint32_t *id, char *arg) FAST_FUNC;
+extern int rtnl_dsfield_a2n(uint32_t *id, char *arg) FAST_FUNC;
+extern int rtnl_rttable_a2n(uint32_t *id, char *arg) FAST_FUNC;
 
-
-extern const char* ll_type_n2a(int type, char *buf, int len);
+extern const char* ll_type_n2a(int type, char *buf) FAST_FUNC;
 
 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);
+                char *buf, int blen) FAST_FUNC;
+extern int ll_addr_a2n(unsigned char *lladdr, int len, char *arg) FAST_FUNC;
 
-extern const char* ll_proto_n2a(unsigned short id, char *buf, int len);
-extern int ll_proto_a2n(unsigned short *id, char *buf);
+extern const char* ll_proto_n2a(unsigned short id, char *buf, int len) FAST_FUNC;
+extern int ll_proto_a2n(unsigned short *id, char *buf) FAST_FUNC;
+
+POP_SAVED_FUNCTION_VISIBILITY
 
 #endif

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * rtm_map.c
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
  *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
- *
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  */
 
@@ -16 +13 @@
 #include "utils.h"
 
-const char *rtnl_rtntype_n2a(int id, char *buf, int len)
+const char* FAST_FUNC rtnl_rtntype_n2a(int id, char *buf)
 {
     switch (id) {
@@ -44 +41 @@
         return "xresolve";
     default:
-        snprintf(buf, len, "%d", id);
+        /* buf is SPRINT_BSIZE big */
+        sprintf(buf, "%d", id);
         return buf;
     }
@@ -50 +48 @@
 
 
-int rtnl_rtntype_a2n(int *id, char *arg)
+int FAST_FUNC rtnl_rtntype_a2n(int *id, char *arg)
 {
     static const char keywords[] ALIGN1 =
@@ -89 +87 @@
     else {
         res = strtoul(arg, &end, 0);
-        if (!end || end == arg || *end || res > 255)
+        if (end == arg || *end || res > 255)
             return -1;
     }
@@ -96 +94 @@
 }
 
-int get_rt_realms(uint32_t *realms, char *arg)
+int FAST_FUNC get_rt_realms(uint32_t *realms, char *arg)
 {
     uint32_t realm = 0;

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef __RTM_MAP_H__
-#define __RTM_MAP_H__ 1
+#ifndef RTM_MAP_H
+#define RTM_MAP_H 1
 
-const char *rtnl_rtntype_n2a(int id, char *buf, int len);
-int rtnl_rtntype_a2n(int *id, char *arg);
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
-int get_rt_realms(uint32_t *realms, char *arg);
+const char *rtnl_rtntype_n2a(int id, char *buf) FAST_FUNC;
+int rtnl_rtntype_a2n(int *id, char *arg) FAST_FUNC;
 
+int get_rt_realms(uint32_t *realms, char *arg) FAST_FUNC;
 
-#endif /* __RTM_MAP_H__ */
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * utils.c
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
- *
- * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  * Changes:
  *
- * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
+ * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  */
 
@@ -16 +14 @@
 #include "inet_common.h"
 
-int get_integer(int *val, char *arg, int base)
-{
-    long res;
-    char *ptr;
-
-    if (!arg || !*arg)
-        return -1;
-    res = strtol(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > INT_MAX || res < INT_MIN)
-        return -1;
-    *val = res;
-    return 0;
-}
-//XXX: FIXME: use some libbb function instead
-int get_unsigned(unsigned *val, char *arg, int base)
+unsigned get_unsigned(char *arg, const char *errmsg)
 {
     unsigned long res;
     char *ptr;
 
-    if (!arg || !*arg)
-        return -1;
-    res = strtoul(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > UINT_MAX)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_u32(uint32_t * val, char *arg, int base)
+    if (*arg) {
+        res = strtoul(arg, &ptr, 0);
+//FIXME: "" will be accepted too, is it correct?!
+        if (!*ptr && res <= UINT_MAX) {
+            return res;
+        }
+    }
+    invarg(arg, errmsg); /* does not return */
+}
+
+uint32_t get_u32(char *arg, const char *errmsg)
 {
     unsigned long res;
     char *ptr;
 
-    if (!arg || !*arg)
-        return -1;
-    res = strtoul(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > 0xFFFFFFFFUL)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_u16(uint16_t * val, char *arg, int base)
+    if (*arg) {
+        res = strtoul(arg, &ptr, 0);
+//FIXME: "" will be accepted too, is it correct?!
+        if (!*ptr && res <= 0xFFFFFFFFUL) {
+            return res;
+        }
+    }
+    invarg(arg, errmsg); /* does not return */
+}
+
+uint16_t get_u16(char *arg, const char *errmsg)
 {
     unsigned long res;
     char *ptr;
 
-    if (!arg || !*arg)
-        return -1;
-    res = strtoul(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > 0xFFFF)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_u8(uint8_t * val, char *arg, int base)
-{
-    unsigned long res;
-    char *ptr;
-
-    if (!arg || !*arg)
-        return -1;
-    res = strtoul(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > 0xFF)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_s16(int16_t * val, char *arg, int base)
-{
-    long res;
-    char *ptr;
-
-    if (!arg || !*arg)
-        return -1;
-    res = strtol(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > 0x7FFF || res < -0x8000)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_s8(int8_t * val, char *arg, int base)
-{
-    long res;
-    char *ptr;
-
-    if (!arg || !*arg)
-        return -1;
-    res = strtol(arg, &ptr, base);
-    if (!ptr || ptr == arg || *ptr || res > 0x7F || res < -0x80)
-        return -1;
-    *val = res;
-    return 0;
-}
-
-int get_addr_1(inet_prefix * addr, char *name, int family)
-{
-    char *cp;
-    unsigned char *ap = (unsigned char *) addr->data;
-    int i;
-
+    if (*arg) {
+        res = strtoul(arg, &ptr, 0);
+//FIXME: "" will be accepted too, is it correct?!
+        if (!*ptr && res <= 0xFFFF) {
+            return res;
+        }
+    }
+    invarg(arg, errmsg); /* does not return */
+}
+
+int get_addr_1(inet_prefix *addr, char *name, int family)
+{
     memset(addr, 0, sizeof(*addr));
 
-    if (strcmp(name, bb_str_default) == 0 ||
-        strcmp(name, "all") == 0 || strcmp(name, "any") == 0) {
+    if (strcmp(name, "default") == 0
+     || strcmp(name, "all") == 0
+     || strcmp(name, "any") == 0
+    ) {
         addr->family = family;
         addr->bytelen = (family == AF_INET6 ? 16 : 4);
@@ -144 +87 @@
     if (family != AF_UNSPEC && family != AF_INET)
         return -1;
+    if (inet_pton(AF_INET, name, addr->data) <= 0)
+        return -1;
     addr->bytelen = 4;
     addr->bitlen = -1;
-    for (cp = name, i = 0; *cp; cp++) {
-        if (*cp <= '9' && *cp >= '0') {
-            ap[i] = 10 * ap[i] + (*cp - '0');
-            continue;
-        }
-        if (*cp == '.' && ++i <= 3)
-            continue;
-        return -1;
-    }
-    return 0;
-}
-
-int get_prefix_1(inet_prefix * dst, char *arg, int family)
+    return 0;
+}
+
+static int get_prefix_1(inet_prefix *dst, char *arg, int family)
 {
     int err;
-    int plen;
+    unsigned plen;
     char *slash;
 
     memset(dst, 0, sizeof(*dst));
 
-    if (strcmp(arg, bb_str_default) == 0 || strcmp(arg, "any") == 0) {
+    if (strcmp(arg, "default") == 0
+     || strcmp(arg, "all") == 0
+     || strcmp(arg, "any") == 0
+    ) {
         dst->family = family;
-        dst->bytelen = 0;
-        dst->bitlen = 0;
+        /*dst->bytelen = 0; - done by memset */
+        /*dst->bitlen = 0;*/
         return 0;
     }
@@ -178 +117 @@
     err = get_addr_1(dst, arg, family);
     if (err == 0) {
-        switch (dst->family) {
-        case AF_INET6:
-            dst->bitlen = 128;
-            break;
-        default:
-        case AF_INET:
-            dst->bitlen = 32;
-        }
+        dst->bitlen = (dst->family == AF_INET6) ? 128 : 32;
         if (slash) {
-            if (get_integer(&plen, slash + 1, 0) || plen > dst->bitlen) {
+            inet_prefix netmask_pfx;
+
+            netmask_pfx.family = AF_UNSPEC;
+            plen = bb_strtou(slash + 1, NULL, 0);
+            if ((errno || plen > dst->bitlen)
+             && (get_addr_1(&netmask_pfx, slash + 1, family)))
                 err = -1;
-                goto done;
+            else if (netmask_pfx.family == AF_INET) {
+                /* fill in prefix length of dotted quad */
+                uint32_t mask = ntohl(netmask_pfx.data[0]);
+                uint32_t host = ~mask;
+
+                /* a valid netmask must be 2^n - 1 */
+                if (!(host & (host + 1))) {
+                    for (plen = 0; mask; mask <<= 1)
+                        ++plen;
+                    if (plen <= dst->bitlen) {
+                        dst->bitlen = plen;
+                        /* dst->flags |= PREFIXLEN_SPECIFIED; */
+                    } else
+                        err = -1;
+                } else
+                    err = -1;
+            } else {
+                /* plain prefix */
+                dst->bitlen = plen;
             }
-            dst->bitlen = plen;
-        }
-    }
- done:
+        }
+    }
     if (slash)
         *slash = '/';
@@ -200 +153 @@
 }
 
-int get_addr(inet_prefix * dst, char *arg, int family)
+int get_addr(inet_prefix *dst, char *arg, int family)
 {
     if (family == AF_PACKET) {
-        bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
+        bb_error_msg_and_die("\"%s\" may be inet %s, but it is not allowed in this context", arg, "address");
     }
     if (get_addr_1(dst, arg, family)) {
-        bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
-    }
-    return 0;
-}
-
-int get_prefix(inet_prefix * dst, char *arg, int family)
+        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "inet", "address", arg);
+    }
+    return 0;
+}
+
+int get_prefix(inet_prefix *dst, char *arg, int family)
 {
     if (family == AF_PACKET) {
-        bb_error_msg_and_die("\"%s\" may be inet address, but it is not allowed in this context", arg);
+        bb_error_msg_and_die("\"%s\" may be inet %s, but it is not allowed in this context", arg, "prefix");
     }
     if (get_prefix_1(dst, arg, family)) {
-        bb_error_msg_and_die("an inet address is expected rather than \"%s\"", arg);
+        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "inet", "prefix", arg);
     }
     return 0;
@@ -227 +180 @@
 
     if (get_addr_1(&addr, name, AF_INET)) {
-        bb_error_msg_and_die("an IP address is expected rather than \"%s\"", name);
+        bb_error_msg_and_die("an %s %s is expected rather than \"%s\"", "IP", "address", name);
     }
     return addr.data[0];
@@ -252 +205 @@
 }
 
-int inet_addr_match(inet_prefix * a, inet_prefix * b, int bits)
+int inet_addr_match(inet_prefix *a, inet_prefix *b, int bits)
 {
     uint32_t *a1 = a->data;
     uint32_t *a2 = b->data;
-    int words = bits >> 0x05;
+    int words = bits >> 5;
 
     bits &= 0x1f;
@@ -280 +233 @@
 }
 
-const char *rt_addr_n2a(int af, int ATTRIBUTE_UNUSED len,
+const char *rt_addr_n2a(int af,
         void *addr, char *buf, int buflen)
 {
@@ -292 +245 @@
 }
 
-
+#ifdef RESOLVE_HOSTNAMES
 const char *format_host(int af, int len, void *addr, char *buf, int buflen)
 {
-#ifdef RESOLVE_HOSTNAMES
     if (resolve_hosts) {
         struct hostent *h_ent;
@@ -318 +270 @@
         }
     }
+    return rt_addr_n2a(af, addr, buf, buflen);
+}
 #endif
-    return rt_addr_n2a(af, len, addr, buf, buflen);
-}

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-#ifndef __UTILS_H__
-#define __UTILS_H__ 1
+#ifndef UTILS_H
+#define UTILS_H 1
 
 #include "libnetlink.h"
@@ -7 +7 @@
 #include "rtm_map.h"
 
-extern int preferred_family;
+PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
+
+extern family_t preferred_family;
 extern smallint show_stats;    /* UNUSED */
 extern smallint show_details;  /* UNUSED */
@@ -16 +18 @@
 
 #ifndef IPPROTO_ESP
-#define IPPROTO_ESP 50
+#define IPPROTO_ESP  50
 #endif
 #ifndef IPPROTO_AH
-#define IPPROTO_AH  51
+#define IPPROTO_AH  51
 #endif
 
 #define SPRINT_BSIZE 64
-#define SPRINT_BUF(x)   char x[SPRINT_BSIZE]
+#define SPRINT_BUF(x)  char x[SPRINT_BSIZE]
 
-extern void incomplete_command(void) ATTRIBUTE_NORETURN;
+extern void incomplete_command(void) NORETURN;
 
-#define NEXT_ARG() do { argv++; if (--argc <= 0) incomplete_command(); } while (0)
+#define NEXT_ARG() do { if (!*++argv) incomplete_command(); } while (0)
 
-typedef struct
-{
+typedef struct {
     uint8_t family;
     uint8_t bytelen;
@@ -36 +37 @@
     uint32_t data[4];
 } inet_prefix;
+
+#define PREFIXLEN_SPECIFIED 1
 
 #define DN_MAXADDL 20
@@ -43 +46 @@
 
 struct dn_naddr {
-    unsigned short          a_len;
-    unsigned char a_addr[DN_MAXADDL];
+    unsigned short a_len;
+    unsigned char  a_addr[DN_MAXADDL];
 };
 
@@ -56 +59 @@
 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);
+/*extern int get_prefix_1(inet_prefix *dst, char *arg, int family);*/
 extern int get_addr(inet_prefix *dst, char *arg, int family);
 extern int get_prefix(inet_prefix *dst, char *arg, int family);
 
-extern int get_integer(int *val, char *arg, int base);
-extern int get_unsigned(unsigned *val, char *arg, int base);
-#define get_byte get_u8
-#define get_ushort get_u16
-#define get_short get_s16
-extern int get_u32(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 unsigned get_unsigned(char *arg, const char *errmsg);
+extern uint32_t get_u32(char *arg, const char *errmsg);
+extern uint16_t get_u16(char *arg, const char *errmsg);
 
+extern const char *rt_addr_n2a(int af, void *addr, char *buf, int buflen);
+#ifdef RESOLVE_HOSTNAMES
 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);
+#else
+#define format_host(af, len, addr, buf, buflen) \
+    rt_addr_n2a(af, addr, buf, buflen)
+#endif
 
-void invarg(const char *, const char *) ATTRIBUTE_NORETURN;
-void duparg(const char *, const char *) ATTRIBUTE_NORETURN;
-void duparg2(const char *, const char *) ATTRIBUTE_NORETURN;
+void invarg(const char *, const char *) NORETURN;
+void duparg(const char *, const char *) NORETURN;
+void duparg2(const char *, const char *) NORETURN;
 int inet_addr_match(inet_prefix *a, inet_prefix *b, int bits);
 
@@ -85 +86 @@
 int ipx_pton(int af, const char *src, void *addr);
 
-#endif /* __UTILS_H__ */
+POP_SAVED_FUNCTION_VISIBILITY
+
+#endif