1 files changed, 210 insertions, 26 deletions

diff --git a/networking/libiproute/iproute.c b/networking/libiproute/iproute.c
index 0f2b89682..cc3443a92 100644
--- a/networking/libiproute/iproute.c
+++ b/networking/libiproute/iproute.c
@@ -322,16 +322,31 @@ static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
         return 0;
 }
 
+static int str_is_lock(const char *str)
+{
+        return strcmp(str, "lock") == 0;
+}
+
 /* Return value becomes exitcode. It's okay to not return at all */
 static int iproute_modify(int cmd, unsigned flags, char **argv)
 {
+        /* If you add stuff here, update iproute_full_usage */
         static const char keywords[] ALIGN1 =
-                "src\0""via\0""mtu\0""lock\0""scope\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
+                "src\0""via\0"
+                "mtu\0""advmss\0"
+                "scope\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
                 "dev\0""oif\0""to\0""metric\0""onlink\0";
+#define keyword_via    (keywords       + sizeof("src"))
+#define keyword_mtu    (keyword_via    + sizeof("via"))
+#define keyword_advmss (keyword_mtu    + sizeof("mtu"))
+#define keyword_scope  (keyword_advmss + sizeof("advmss"))
+#define keyword_proto  (keyword_scope  + sizeof("scope"))
+#define keyword_table  (keyword_proto  + sizeof("protocol"))
         enum {
                 ARG_src,
                 ARG_via,
-                ARG_mtu, PARM_lock,
+                ARG_mtu,
+                ARG_advmss,
                 ARG_scope,
                 ARG_protocol,
 IF_FEATURE_IP_RULE(ARG_table,)
@@ -404,24 +419,33 @@ IF_FEATURE_IP_RULE(ARG_table,)
                 } else if (arg == ARG_mtu) {
                         unsigned mtu;
                         NEXT_ARG();
-                        if (index_in_strings(keywords, *argv) == PARM_lock) {
+                        if (str_is_lock(*argv)) {
                                 mxlock |= (1 << RTAX_MTU);
                                 NEXT_ARG();
                         }
-                        mtu = get_unsigned(*argv, "mtu");
+                        mtu = get_unsigned(*argv, keyword_mtu);
                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
+                } else if (arg == ARG_advmss) {
+                        unsigned mss;
+                        NEXT_ARG();
+                        if (str_is_lock(*argv)) {
+                                mxlock |= (1 << RTAX_ADVMSS);
+                                NEXT_ARG();
+                        }
+                        mss = get_unsigned(*argv, keyword_advmss);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_ADVMSS, mss);
                 } else if (arg == ARG_scope) {
                         uint32_t scope;
                         NEXT_ARG();
                         if (rtnl_rtscope_a2n(&scope, *argv))
-                                invarg_1_to_2(*argv, "scope");
+                                invarg_1_to_2(*argv, keyword_scope);
                         req.r.rtm_scope = scope;
                         scope_ok = 1;
                 } else if (arg == ARG_protocol) {
                         uint32_t prot;
                         NEXT_ARG();
                         if (rtnl_rtprot_a2n(&prot, *argv))
-                                invarg_1_to_2(*argv, "protocol");
+                                invarg_1_to_2(*argv, keyword_proto);
                         req.r.rtm_protocol = prot;
                         ok |= proto_ok;
 #if ENABLE_FEATURE_IP_RULE
@@ -429,7 +453,7 @@ IF_FEATURE_IP_RULE(ARG_table,)
                         uint32_t tid;
                         NEXT_ARG();
                         if (rtnl_rttable_a2n(&tid, *argv))
-                                invarg_1_to_2(*argv, "table");
+                                invarg_1_to_2(*argv, keyword_table);
                         if (tid < 256)
                                 req.r.rtm_table = tid;
                         else {
@@ -441,6 +465,7 @@ IF_FEATURE_IP_RULE(ARG_table,)
                         NEXT_ARG();
                         d = *argv;
                 } else if (arg == ARG_metric) {
+//TODO: "metric", "priority" and "preference" are synonyms
                         uint32_t metric;
                         NEXT_ARG();
                         metric = get_u32(*argv, "metric");
@@ -475,6 +500,158 @@ IF_FEATURE_IP_RULE(ARG_table,)
                                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
                         }
                 }
+/* Other keywords recognized by iproute2-3.19.0: */
+#if 0
+                } else if (strcmp(*argv, "from") == 0) {
+                        inet_prefix addr;
+                        NEXT_ARG();
+                        get_prefix(&addr, *argv, req.r.rtm_family);
+                        if (req.r.rtm_family == AF_UNSPEC)
+                                req.r.rtm_family = addr.family;
+                        if (addr.bytelen)
+                                addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
+                        req.r.rtm_src_len = addr.bitlen;
+                } else if (strcmp(*argv, "tos") == 0 ||
+                           matches(*argv, "dsfield") == 0) {
+                        __u32 tos;
+                        NEXT_ARG();
+                        if (rtnl_dsfield_a2n(&tos, *argv))
+                                invarg("\"tos\" value is invalid\n", *argv);
+                        req.r.rtm_tos = tos;
+                } else if (strcmp(*argv, "hoplimit") == 0) {
+                        unsigned hoplimit;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_HOPLIMIT);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&hoplimit, *argv, 0))
+                                invarg("\"hoplimit\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_HOPLIMIT, hoplimit);
+                } else if (matches(*argv, "reordering") == 0) {
+                        unsigned reord;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_REORDERING);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&reord, *argv, 0))
+                                invarg("\"reordering\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_REORDERING, reord);
+                } else if (strcmp(*argv, "rtt") == 0) {
+                        unsigned rtt;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_RTT);
+                                NEXT_ARG();
+                        }
+                        if (get_time_rtt(&rtt, *argv, &raw))
+                                invarg("\"rtt\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTT,
+                                (raw) ? rtt : rtt * 8);
+                } else if (strcmp(*argv, "rto_min") == 0) {
+                        unsigned rto_min;
+                        NEXT_ARG();
+                        mxlock |= (1<<RTAX_RTO_MIN);
+                        if (get_time_rtt(&rto_min, *argv, &raw))
+                                invarg("\"rto_min\" value is invalid\n",
+                                       *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTO_MIN,
+                                      rto_min);
+                } else if (matches(*argv, "window") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_WINDOW);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&win, *argv, 0))
+                                invarg("\"window\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_WINDOW, win);
+                } else if (matches(*argv, "cwnd") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_CWND);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&win, *argv, 0))
+                                invarg("\"cwnd\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_CWND, win);
+                } else if (matches(*argv, "initcwnd") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_INITCWND);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&win, *argv, 0))
+                                invarg("\"initcwnd\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITCWND, win);
+                } else if (matches(*argv, "initrwnd") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_INITRWND);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&win, *argv, 0))
+                                invarg("\"initrwnd\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITRWND, win);
+                } else if (matches(*argv, "features") == 0) {
+                        unsigned int features = 0;
+
+                        while (argc > 0) {
+                                NEXT_ARG();
+
+                                if (strcmp(*argv, "ecn") == 0)
+                                        features |= RTAX_FEATURE_ECN;
+                                else
+                                        invarg("\"features\" value not valid\n", *argv);
+                                break;
+                        }
+
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_FEATURES, features);
+                } else if (matches(*argv, "quickack") == 0) {
+                        unsigned quickack;
+                        NEXT_ARG();
+                        if (get_unsigned(&quickack, *argv, 0))
+                                invarg("\"quickack\" value is invalid\n", *argv);
+                        if (quickack != 1 && quickack != 0)
+                                invarg("\"quickack\" value should be 0 or 1\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_QUICKACK, quickack);
+                } else if (matches(*argv, "rttvar") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_RTTVAR);
+                                NEXT_ARG();
+                        }
+                        if (get_time_rtt(&win, *argv, &raw))
+                                invarg("\"rttvar\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_RTTVAR,
+                                (raw) ? win : win * 4);
+                } else if (matches(*argv, "ssthresh") == 0) {
+                        unsigned win;
+                        NEXT_ARG();
+                        if (strcmp(*argv, "lock") == 0) {
+                                mxlock |= (1<<RTAX_SSTHRESH);
+                                NEXT_ARG();
+                        }
+                        if (get_unsigned(&win, *argv, 0))
+                                invarg("\"ssthresh\" value is invalid\n", *argv);
+                        rta_addattr32(mxrta, sizeof(mxbuf), RTAX_SSTHRESH, win);
+                } else if (matches(*argv, "realms") == 0) {
+                        __u32 realm;
+                        NEXT_ARG();
+                        if (get_rt_realms(&realm, *argv))
+                                invarg("\"realm\" value is invalid\n", *argv);
+                        addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
+                } else if (strcmp(*argv, "nexthop") == 0) {
+                        nhs_ok = 1;
+                        break;
+                }
+#endif
                 argv++;
         }
 
@@ -912,9 +1089,15 @@ static int iproute_get(char **argv)
 int FAST_FUNC do_iproute(char **argv)
 {
         static const char ip_route_commands[] ALIGN1 =
-        /*0-3*/ "add\0""append\0""change\0""chg\0"
-        /*4-7*/ "delete\0""get\0""list\0""show\0"
-        /*8..*/ "prepend\0""replace\0""test\0""flush\0";
+                "a\0""add\0""append\0""change\0""chg\0"
+                "delete\0""get\0""list\0""show\0"
+                "prepend\0""replace\0""test\0""flush\0"
+        ;
+        enum {
+                CMD_a = 0, CMD_add, CMD_append, CMD_change, CMD_chg,
+                CMD_delete, CMD_get, CMD_list, CMD_show,
+                CMD_prepend, CMD_replace, CMD_test, CMD_flush,
+        };
         int command_num;
         unsigned flags = 0;
         int cmd = RTM_NEWROUTE;
@@ -929,38 +1112,39 @@ int FAST_FUNC do_iproute(char **argv)
         command_num = index_in_substrings(ip_route_commands, *argv);
 
         switch (command_num) {
-                case 0: /* add */
+                case CMD_a:
+                case CMD_add:
                         flags = NLM_F_CREATE|NLM_F_EXCL;
                         break;
-                case 1: /* append */
+                case CMD_append:
                         flags = NLM_F_CREATE|NLM_F_APPEND;
                         break;
-                case 2: /* change */
-                case 3: /* chg */
+                case CMD_change:
+                case CMD_chg:
                         flags = NLM_F_REPLACE;
                         break;
-                case 4: /* delete */
+                case CMD_delete:
                         cmd = RTM_DELROUTE;
                         break;
-                case 5: /* get */
-                        return iproute_get(argv+1);
-                case 6: /* list */
-                case 7: /* show */
-                        return iproute_list_or_flush(argv+1, 0);
-                case 8: /* prepend */
+                case CMD_get:
+                        return iproute_get(argv + 1);
+                case CMD_list:
+                case CMD_show:
+                        return iproute_list_or_flush(argv + 1, 0);
+                case CMD_prepend:
                         flags = NLM_F_CREATE;
                         break;
-                case 9: /* replace */
+                case CMD_replace:
                         flags = NLM_F_CREATE|NLM_F_REPLACE;
                         break;
-                case 10: /* test */
+                case CMD_test:
                         flags = NLM_F_EXCL;
                         break;
-                case 11: /* flush */
-                        return iproute_list_or_flush(argv+1, 1);
+                case CMD_flush:
+                        return iproute_list_or_flush(argv + 1, 1);
                 default:
                         invarg_1_to_2(*argv, applet_name);
         }
 
-        return iproute_modify(cmd, flags, argv+1);
+        return iproute_modify(cmd, flags, argv + 1);
 }