osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 1 | /* |
| 2 | * iprule.c "ip rule". |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or |
| 5 | * modify it under the terms of the GNU General Public License |
| 6 | * as published by the Free Software Foundation; either version |
| 7 | * 2 of the License, or (at your option) any later version. |
| 8 | * |
| 9 | * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> |
| 10 | * |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 11 | */ |
| 12 | |
| 13 | #include <stdio.h> |
| 14 | #include <stdlib.h> |
| 15 | #include <unistd.h> |
| 16 | #include <syslog.h> |
| 17 | #include <fcntl.h> |
| 18 | #include <sys/socket.h> |
| 19 | #include <netinet/in.h> |
| 20 | #include <netinet/ip.h> |
| 21 | #include <arpa/inet.h> |
| 22 | #include <string.h> |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 23 | #include <linux/if.h> |
Thomas Graf | 3123a0c | 2006-11-09 12:38:02 +0100 | [diff] [blame] | 24 | #include <linux/fib_rules.h> |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 25 | #include <errno.h> |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 26 | |
| 27 | #include "rt_names.h" |
| 28 | #include "utils.h" |
Patrick McHardy | 34e9564 | 2006-08-11 00:14:51 +0200 | [diff] [blame] | 29 | #include "ip_common.h" |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 30 | |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 31 | enum list_action { |
| 32 | IPRULE_LIST, |
| 33 | IPRULE_FLUSH, |
| 34 | IPRULE_SAVE, |
| 35 | }; |
| 36 | |
shemminger | 351efcd | 2005-09-01 19:21:50 +0000 | [diff] [blame] | 37 | extern struct rtnl_handle rth; |
| 38 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 39 | static void usage(void) __attribute__((noreturn)); |
| 40 | |
| 41 | static void usage(void) |
| 42 | { |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 43 | fprintf(stderr, |
| 44 | "Usage: ip rule { add | del } SELECTOR ACTION\n" |
| 45 | " ip rule { flush | save | restore }\n" |
| 46 | " ip rule [ list [ SELECTOR ]]\n" |
| 47 | "SELECTOR := [ not ] [ from PREFIX ] [ to PREFIX ] [ tos TOS ] [ fwmark FWMARK[/MASK] ]\n" |
| 48 | " [ iif STRING ] [ oif STRING ] [ pref NUMBER ] [ l3mdev ]\n" |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 49 | " [ uidrange NUMBER-NUMBER ]\n" |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 50 | "ACTION := [ table TABLE_ID ]\n" |
| 51 | " [ nat ADDRESS ]\n" |
| 52 | " [ realms [SRCREALM/]DSTREALM ]\n" |
| 53 | " [ goto NUMBER ]\n" |
| 54 | " SUPPRESSOR\n" |
| 55 | "SUPPRESSOR := [ suppress_prefixlength NUMBER ]\n" |
| 56 | " [ suppress_ifgroup DEVGROUP ]\n" |
| 57 | "TABLE_ID := [ local | main | default | NUMBER ]\n"); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 58 | exit(-1); |
| 59 | } |
| 60 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 61 | static struct |
| 62 | { |
| 63 | int not; |
| 64 | int l3mdev; |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 65 | int iifmask, oifmask, uidrange; |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 66 | unsigned int tb; |
| 67 | unsigned int tos, tosmask; |
| 68 | unsigned int pref, prefmask; |
| 69 | unsigned int fwmark, fwmask; |
| 70 | char iif[IFNAMSIZ]; |
| 71 | char oif[IFNAMSIZ]; |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 72 | struct fib_rule_uid_range range; |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 73 | inet_prefix src; |
| 74 | inet_prefix dst; |
| 75 | } filter; |
| 76 | |
| 77 | static bool filter_nlmsg(struct nlmsghdr *n, struct rtattr **tb, int host_len) |
| 78 | { |
| 79 | struct rtmsg *r = NLMSG_DATA(n); |
| 80 | inet_prefix src = { .family = r->rtm_family }; |
| 81 | inet_prefix dst = { .family = r->rtm_family }; |
| 82 | __u32 table; |
| 83 | |
| 84 | if (preferred_family != AF_UNSPEC && r->rtm_family != preferred_family) |
| 85 | return false; |
| 86 | |
| 87 | if (filter.prefmask && |
| 88 | filter.pref ^ (tb[FRA_PRIORITY] ? rta_getattr_u32(tb[FRA_PRIORITY]) : 0)) |
| 89 | return false; |
| 90 | if (filter.not && !(r->rtm_flags & FIB_RULE_INVERT)) |
| 91 | return false; |
| 92 | |
| 93 | if (filter.src.family) { |
| 94 | if (tb[FRA_SRC]) { |
| 95 | memcpy(&src.data, RTA_DATA(tb[FRA_SRC]), |
| 96 | (r->rtm_src_len + 7) / 8); |
| 97 | } |
| 98 | if (filter.src.family != r->rtm_family || |
| 99 | filter.src.bitlen > r->rtm_src_len || |
| 100 | inet_addr_match(&src, &filter.src, filter.src.bitlen)) |
| 101 | return false; |
| 102 | } |
| 103 | |
| 104 | if (filter.dst.family) { |
| 105 | if (tb[FRA_DST]) { |
| 106 | memcpy(&dst.data, RTA_DATA(tb[FRA_DST]), |
| 107 | (r->rtm_dst_len + 7) / 8); |
| 108 | } |
| 109 | if (filter.dst.family != r->rtm_family || |
| 110 | filter.dst.bitlen > r->rtm_dst_len || |
| 111 | inet_addr_match(&dst, &filter.dst, filter.dst.bitlen)) |
| 112 | return false; |
| 113 | } |
| 114 | |
| 115 | if (filter.tosmask && filter.tos ^ r->rtm_tos) |
| 116 | return false; |
| 117 | |
| 118 | if (filter.fwmark) { |
| 119 | __u32 mark = 0; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 120 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 121 | if (tb[FRA_FWMARK]) |
| 122 | mark = rta_getattr_u32(tb[FRA_FWMARK]); |
| 123 | if (filter.fwmark ^ mark) |
| 124 | return false; |
| 125 | } |
| 126 | if (filter.fwmask) { |
| 127 | __u32 mask = 0; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 128 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 129 | if (tb[FRA_FWMASK]) |
| 130 | mask = rta_getattr_u32(tb[FRA_FWMASK]); |
| 131 | if (filter.fwmask ^ mask) |
| 132 | return false; |
| 133 | } |
| 134 | |
| 135 | if (filter.iifmask) { |
| 136 | if (tb[FRA_IFNAME]) { |
| 137 | if (strcmp(filter.iif, rta_getattr_str(tb[FRA_IFNAME])) != 0) |
| 138 | return false; |
| 139 | } else { |
| 140 | return false; |
| 141 | } |
| 142 | } |
| 143 | |
| 144 | if (filter.oifmask) { |
| 145 | if (tb[FRA_OIFNAME]) { |
| 146 | if (strcmp(filter.oif, rta_getattr_str(tb[FRA_OIFNAME])) != 0) |
| 147 | return false; |
| 148 | } else { |
| 149 | return false; |
| 150 | } |
| 151 | } |
| 152 | |
| 153 | if (filter.l3mdev && !(tb[FRA_L3MDEV] && rta_getattr_u8(tb[FRA_L3MDEV]))) |
| 154 | return false; |
| 155 | |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 156 | if (filter.uidrange) { |
| 157 | struct fib_rule_uid_range *r = RTA_DATA(tb[FRA_UID_RANGE]); |
| 158 | |
| 159 | if (!tb[FRA_UID_RANGE] || |
| 160 | r->start != filter.range.start || |
| 161 | r->end != filter.range.end) |
| 162 | return false; |
| 163 | } |
| 164 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 165 | table = rtm_get_table(r, tb); |
| 166 | if (filter.tb > 0 && filter.tb ^ table) |
| 167 | return false; |
| 168 | |
| 169 | return true; |
| 170 | } |
| 171 | |
Thomas Graf | 98bde98 | 2006-11-10 12:27:10 +0100 | [diff] [blame] | 172 | int print_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 173 | { |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 174 | FILE *fp = (FILE *)arg; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 175 | struct rtmsg *r = NLMSG_DATA(n); |
| 176 | int len = n->nlmsg_len; |
| 177 | int host_len = -1; |
Patrick McHardy | 34e9564 | 2006-08-11 00:14:51 +0200 | [diff] [blame] | 178 | __u32 table; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 179 | struct rtattr *tb[FRA_MAX+1]; |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 180 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 181 | SPRINT_BUF(b1); |
| 182 | |
Thomas Graf | 98bde98 | 2006-11-10 12:27:10 +0100 | [diff] [blame] | 183 | if (n->nlmsg_type != RTM_NEWRULE && n->nlmsg_type != RTM_DELRULE) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 184 | return 0; |
| 185 | |
| 186 | len -= NLMSG_LENGTH(sizeof(*r)); |
| 187 | if (len < 0) |
| 188 | return -1; |
| 189 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 190 | parse_rtattr(tb, FRA_MAX, RTM_RTA(r), len); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 191 | |
Vadim Kochan | f3a2ddc | 2015-02-28 02:50:24 +0200 | [diff] [blame] | 192 | host_len = af_bit_len(r->rtm_family); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 193 | |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 194 | if (!filter_nlmsg(n, tb, host_len)) |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 195 | return 0; |
| 196 | |
Thomas Graf | 98bde98 | 2006-11-10 12:27:10 +0100 | [diff] [blame] | 197 | if (n->nlmsg_type == RTM_DELRULE) |
| 198 | fprintf(fp, "Deleted "); |
| 199 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 200 | if (tb[FRA_PRIORITY]) |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 201 | fprintf(fp, "%u:\t", |
| 202 | rta_getattr_u32(tb[FRA_PRIORITY])); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 203 | else |
| 204 | fprintf(fp, "0:\t"); |
| 205 | |
Thomas Graf | 3123a0c | 2006-11-09 12:38:02 +0100 | [diff] [blame] | 206 | if (r->rtm_flags & FIB_RULE_INVERT) |
| 207 | fprintf(fp, "not "); |
| 208 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 209 | if (tb[FRA_SRC]) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 210 | if (r->rtm_src_len != host_len) { |
Phil Sutter | 7faf158 | 2016-03-22 19:35:18 +0100 | [diff] [blame] | 211 | fprintf(fp, "from %s/%u ", |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 212 | rt_addr_n2a_rta(r->rtm_family, tb[FRA_SRC]), |
| 213 | r->rtm_src_len); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 214 | } else { |
Phil Sutter | d49f934 | 2016-03-22 19:35:17 +0100 | [diff] [blame] | 215 | fprintf(fp, "from %s ", |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 216 | format_host_rta(r->rtm_family, tb[FRA_SRC])); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 217 | } |
| 218 | } else if (r->rtm_src_len) { |
| 219 | fprintf(fp, "from 0/%d ", r->rtm_src_len); |
| 220 | } else { |
| 221 | fprintf(fp, "from all "); |
| 222 | } |
| 223 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 224 | if (tb[FRA_DST]) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 225 | if (r->rtm_dst_len != host_len) { |
Phil Sutter | 7faf158 | 2016-03-22 19:35:18 +0100 | [diff] [blame] | 226 | fprintf(fp, "to %s/%u ", |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 227 | rt_addr_n2a_rta(r->rtm_family, tb[FRA_DST]), |
| 228 | r->rtm_dst_len); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 229 | } else { |
Phil Sutter | d49f934 | 2016-03-22 19:35:17 +0100 | [diff] [blame] | 230 | fprintf(fp, "to %s ", |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 231 | format_host_rta(r->rtm_family, tb[FRA_DST])); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 232 | } |
| 233 | } else if (r->rtm_dst_len) { |
| 234 | fprintf(fp, "to 0/%d ", r->rtm_dst_len); |
| 235 | } |
| 236 | |
| 237 | if (r->rtm_tos) { |
| 238 | SPRINT_BUF(b1); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 239 | fprintf(fp, "tos %s ", |
| 240 | rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1))); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 241 | } |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 242 | |
Stephen Hemminger | 4806867 | 2014-02-17 10:56:31 -0800 | [diff] [blame] | 243 | if (tb[FRA_FWMARK] || tb[FRA_FWMASK]) { |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 244 | __u32 mark = 0, mask = 0; |
| 245 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 246 | if (tb[FRA_FWMARK]) |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 247 | mark = rta_getattr_u32(tb[FRA_FWMARK]); |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 248 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 249 | if (tb[FRA_FWMASK] && |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 250 | (mask = rta_getattr_u32(tb[FRA_FWMASK])) != 0xFFFFFFFF) |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 251 | fprintf(fp, "fwmark 0x%x/0x%x ", mark, mask); |
Stephen Hemminger | 81c6179 | 2006-12-13 17:05:50 -0800 | [diff] [blame] | 252 | else |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 253 | fprintf(fp, "fwmark 0x%x ", mark); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 254 | } |
| 255 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 256 | if (tb[FRA_IFNAME]) { |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 257 | fprintf(fp, "iif %s ", rta_getattr_str(tb[FRA_IFNAME])); |
Patrick McHardy | 85eae22 | 2009-12-03 20:07:14 +0000 | [diff] [blame] | 258 | if (r->rtm_flags & FIB_RULE_IIF_DETACHED) |
| 259 | fprintf(fp, "[detached] "); |
| 260 | } |
| 261 | |
| 262 | if (tb[FRA_OIFNAME]) { |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 263 | fprintf(fp, "oif %s ", rta_getattr_str(tb[FRA_OIFNAME])); |
Patrick McHardy | 85eae22 | 2009-12-03 20:07:14 +0000 | [diff] [blame] | 264 | if (r->rtm_flags & FIB_RULE_OIF_DETACHED) |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 265 | fprintf(fp, "[detached] "); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 266 | } |
| 267 | |
David Ahern | 8c92e12 | 2016-06-10 10:47:17 -0700 | [diff] [blame] | 268 | if (tb[FRA_L3MDEV]) { |
| 269 | if (rta_getattr_u8(tb[FRA_L3MDEV])) |
| 270 | fprintf(fp, "lookup [l3mdev-table] "); |
| 271 | } |
| 272 | |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 273 | if (tb[FRA_UID_RANGE]) { |
| 274 | struct fib_rule_uid_range *r = RTA_DATA(tb[FRA_UID_RANGE]); |
| 275 | |
| 276 | fprintf(fp, "uidrange %u-%u ", r->start, r->end); |
| 277 | } |
| 278 | |
Patrick McHardy | 34e9564 | 2006-08-11 00:14:51 +0200 | [diff] [blame] | 279 | table = rtm_get_table(r, tb); |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 280 | if (table) { |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 281 | fprintf(fp, "lookup %s ", |
| 282 | rtnl_rttable_n2a(table, b1, sizeof(b1))); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 283 | |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 284 | if (tb[FRA_SUPPRESS_PREFIXLEN]) { |
| 285 | int pl = rta_getattr_u32(tb[FRA_SUPPRESS_PREFIXLEN]); |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 286 | |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 287 | if (pl != -1) |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 288 | fprintf(fp, "suppress_prefixlength %d ", pl); |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 289 | } |
| 290 | if (tb[FRA_SUPPRESS_IFGROUP]) { |
| 291 | int group = rta_getattr_u32(tb[FRA_SUPPRESS_IFGROUP]); |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 292 | |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 293 | if (group != -1) { |
| 294 | SPRINT_BUF(b1); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 295 | fprintf(fp, "suppress_ifgroup %s ", |
| 296 | rtnl_group_n2a(group, b1, sizeof(b1))); |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 297 | } |
| 298 | } |
| 299 | } |
| 300 | |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 301 | if (tb[FRA_FLOW]) { |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 302 | __u32 to = rta_getattr_u32(tb[FRA_FLOW]); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 303 | __u32 from = to>>16; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 304 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 305 | to &= 0xFFFF; |
| 306 | if (from) { |
| 307 | fprintf(fp, "realms %s/", |
| 308 | rtnl_rtrealm_n2a(from, b1, sizeof(b1))); |
| 309 | } |
| 310 | fprintf(fp, "%s ", |
| 311 | rtnl_rtrealm_n2a(to, b1, sizeof(b1))); |
| 312 | } |
| 313 | |
| 314 | if (r->rtm_type == RTN_NAT) { |
| 315 | if (tb[RTA_GATEWAY]) { |
Stephen Hemminger | ae665a5 | 2006-12-05 10:10:22 -0800 | [diff] [blame] | 316 | fprintf(fp, "map-to %s ", |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 317 | format_host_rta(r->rtm_family, |
| 318 | tb[RTA_GATEWAY])); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 319 | } else |
| 320 | fprintf(fp, "masquerade"); |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 321 | } else if (r->rtm_type == FR_ACT_GOTO) { |
| 322 | fprintf(fp, "goto "); |
| 323 | if (tb[FRA_GOTO]) |
Stephen Hemminger | ff24746 | 2012-04-10 08:47:55 -0700 | [diff] [blame] | 324 | fprintf(fp, "%u", rta_getattr_u32(tb[FRA_GOTO])); |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 325 | else |
| 326 | fprintf(fp, "none"); |
| 327 | if (r->rtm_flags & FIB_RULE_UNRESOLVED) |
| 328 | fprintf(fp, " [unresolved]"); |
| 329 | } else if (r->rtm_type == FR_ACT_NOP) |
| 330 | fprintf(fp, "nop"); |
| 331 | else if (r->rtm_type != RTN_UNICAST) |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 332 | fprintf(fp, "%s", |
| 333 | rtnl_rtntype_n2a(r->rtm_type, |
| 334 | b1, sizeof(b1))); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 335 | |
| 336 | fprintf(fp, "\n"); |
| 337 | fflush(fp); |
| 338 | return 0; |
| 339 | } |
| 340 | |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 341 | static __u32 rule_dump_magic = 0x71706986; |
| 342 | |
| 343 | static int save_rule_prep(void) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 344 | { |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 345 | int ret; |
| 346 | |
| 347 | if (isatty(STDOUT_FILENO)) { |
| 348 | fprintf(stderr, "Not sending a binary stream to stdout\n"); |
| 349 | return -1; |
| 350 | } |
| 351 | |
| 352 | ret = write(STDOUT_FILENO, &rule_dump_magic, sizeof(rule_dump_magic)); |
| 353 | if (ret != sizeof(rule_dump_magic)) { |
| 354 | fprintf(stderr, "Can't write magic to dump file\n"); |
| 355 | return -1; |
| 356 | } |
| 357 | |
| 358 | return 0; |
| 359 | } |
| 360 | |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 361 | static int save_rule(const struct sockaddr_nl *who, |
| 362 | struct nlmsghdr *n, void *arg) |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 363 | { |
| 364 | int ret; |
| 365 | |
| 366 | ret = write(STDOUT_FILENO, n, n->nlmsg_len); |
| 367 | if ((ret > 0) && (ret != n->nlmsg_len)) { |
| 368 | fprintf(stderr, "Short write while saving nlmsg\n"); |
| 369 | ret = -EIO; |
| 370 | } |
| 371 | |
| 372 | return ret == n->nlmsg_len ? 0 : ret; |
| 373 | } |
| 374 | |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 375 | static int flush_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, |
| 376 | void *arg) |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 377 | { |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 378 | struct rtnl_handle rth2; |
| 379 | struct rtmsg *r = NLMSG_DATA(n); |
| 380 | int len = n->nlmsg_len; |
| 381 | struct rtattr *tb[FRA_MAX+1]; |
| 382 | |
| 383 | len -= NLMSG_LENGTH(sizeof(*r)); |
| 384 | if (len < 0) |
| 385 | return -1; |
| 386 | |
| 387 | parse_rtattr(tb, FRA_MAX, RTM_RTA(r), len); |
| 388 | |
| 389 | if (tb[FRA_PRIORITY]) { |
| 390 | n->nlmsg_type = RTM_DELRULE; |
| 391 | n->nlmsg_flags = NLM_F_REQUEST; |
| 392 | |
| 393 | if (rtnl_open(&rth2, 0) < 0) |
| 394 | return -1; |
| 395 | |
| 396 | if (rtnl_talk(&rth2, n, NULL, 0) < 0) |
| 397 | return -2; |
| 398 | |
| 399 | rtnl_close(&rth2); |
| 400 | } |
| 401 | |
| 402 | return 0; |
| 403 | } |
| 404 | |
| 405 | static int iprule_list_flush_or_save(int argc, char **argv, int action) |
| 406 | { |
| 407 | rtnl_filter_t filter_fn; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 408 | int af = preferred_family; |
| 409 | |
| 410 | if (af == AF_UNSPEC) |
| 411 | af = AF_INET; |
| 412 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 413 | if (action != IPRULE_LIST && argc > 0) { |
| 414 | fprintf(stderr, "\"ip rule %s\" does not take any arguments.\n", |
| 415 | action == IPRULE_SAVE ? "save" : "flush"); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 416 | return -1; |
| 417 | } |
| 418 | |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 419 | switch (action) { |
| 420 | case IPRULE_SAVE: |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 421 | if (save_rule_prep()) |
| 422 | return -1; |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 423 | filter_fn = save_rule; |
| 424 | break; |
| 425 | case IPRULE_FLUSH: |
| 426 | filter_fn = flush_rule; |
| 427 | break; |
| 428 | default: |
| 429 | filter_fn = print_rule; |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 430 | } |
| 431 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 432 | memset(&filter, 0, sizeof(filter)); |
| 433 | |
| 434 | while (argc > 0) { |
| 435 | if (matches(*argv, "preference") == 0 || |
| 436 | matches(*argv, "order") == 0 || |
| 437 | matches(*argv, "priority") == 0) { |
| 438 | __u32 pref; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 439 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 440 | NEXT_ARG(); |
| 441 | if (get_u32(&pref, *argv, 0)) |
| 442 | invarg("preference value is invalid\n", *argv); |
| 443 | filter.pref = pref; |
| 444 | filter.prefmask = 1; |
| 445 | } else if (strcmp(*argv, "not") == 0) { |
| 446 | filter.not = 1; |
| 447 | } else if (strcmp(*argv, "tos") == 0) { |
| 448 | __u32 tos; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 449 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 450 | NEXT_ARG(); |
| 451 | if (rtnl_dsfield_a2n(&tos, *argv)) |
| 452 | invarg("TOS value is invalid\n", *argv); |
| 453 | filter.tos = tos; |
| 454 | filter.tosmask = 1; |
| 455 | } else if (strcmp(*argv, "fwmark") == 0) { |
| 456 | char *slash; |
| 457 | __u32 fwmark, fwmask; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 458 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 459 | NEXT_ARG(); |
| 460 | slash = strchr(*argv, '/'); |
| 461 | if (slash != NULL) |
| 462 | *slash = '\0'; |
| 463 | if (get_u32(&fwmark, *argv, 0)) |
| 464 | invarg("fwmark value is invalid\n", *argv); |
| 465 | filter.fwmark = fwmark; |
| 466 | if (slash) { |
| 467 | if (get_u32(&fwmask, slash+1, 0)) |
| 468 | invarg("fwmask value is invalid\n", |
| 469 | slash+1); |
| 470 | filter.fwmask = fwmask; |
| 471 | } |
| 472 | } else if (strcmp(*argv, "dev") == 0 || |
| 473 | strcmp(*argv, "iif") == 0) { |
| 474 | NEXT_ARG(); |
| 475 | strncpy(filter.iif, *argv, IFNAMSIZ); |
| 476 | filter.iifmask = 1; |
| 477 | } else if (strcmp(*argv, "oif") == 0) { |
| 478 | NEXT_ARG(); |
| 479 | strncpy(filter.oif, *argv, IFNAMSIZ); |
| 480 | filter.oifmask = 1; |
| 481 | } else if (strcmp(*argv, "l3mdev") == 0) { |
| 482 | filter.l3mdev = 1; |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 483 | } else if (strcmp(*argv, "uidrange") == 0) { |
| 484 | NEXT_ARG(); |
| 485 | filter.uidrange = 1; |
| 486 | if (sscanf(*argv, "%u-%u", |
| 487 | &filter.range.start, |
| 488 | &filter.range.end) != 2) |
| 489 | invarg("invalid UID range\n", *argv); |
| 490 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 491 | } else if (matches(*argv, "lookup") == 0 || |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 492 | matches(*argv, "table") == 0) { |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 493 | __u32 tid; |
Stephen Hemminger | e147161 | 2016-10-09 19:29:24 -0700 | [diff] [blame] | 494 | |
Hangbin Liu | ca89c52 | 2016-09-23 11:25:55 +0800 | [diff] [blame] | 495 | NEXT_ARG(); |
| 496 | if (rtnl_rttable_a2n(&tid, *argv)) |
| 497 | invarg("table id value is invalid\n", *argv); |
| 498 | filter.tb = tid; |
| 499 | } else if (matches(*argv, "from") == 0 || |
| 500 | matches(*argv, "src") == 0) { |
| 501 | NEXT_ARG(); |
| 502 | get_prefix(&filter.src, *argv, af); |
| 503 | } else { |
| 504 | if (matches(*argv, "dst") == 0 || |
| 505 | matches(*argv, "to") == 0) { |
| 506 | NEXT_ARG(); |
| 507 | } |
| 508 | get_prefix(&filter.dst, *argv, af); |
| 509 | } |
| 510 | argc--; argv++; |
| 511 | } |
| 512 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 513 | if (rtnl_wilddump_request(&rth, af, RTM_GETRULE) < 0) { |
| 514 | perror("Cannot send dump request"); |
| 515 | return 1; |
| 516 | } |
| 517 | |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 518 | if (rtnl_dump_filter(&rth, filter_fn, stdout) < 0) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 519 | fprintf(stderr, "Dump terminated\n"); |
| 520 | return 1; |
| 521 | } |
| 522 | |
| 523 | return 0; |
| 524 | } |
| 525 | |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 526 | static int rule_dump_check_magic(void) |
| 527 | { |
| 528 | int ret; |
| 529 | __u32 magic = 0; |
| 530 | |
| 531 | if (isatty(STDIN_FILENO)) { |
| 532 | fprintf(stderr, "Can't restore rule dump from a terminal\n"); |
| 533 | return -1; |
| 534 | } |
| 535 | |
| 536 | ret = fread(&magic, sizeof(magic), 1, stdin); |
| 537 | if (magic != rule_dump_magic) { |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 538 | fprintf(stderr, "Magic mismatch (%d elems, %x magic)\n", |
| 539 | ret, magic); |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 540 | return -1; |
| 541 | } |
| 542 | |
| 543 | return 0; |
| 544 | } |
| 545 | |
| 546 | static int restore_handler(const struct sockaddr_nl *nl, |
| 547 | struct rtnl_ctrl_data *ctrl, |
| 548 | struct nlmsghdr *n, void *arg) |
| 549 | { |
| 550 | int ret; |
| 551 | |
| 552 | n->nlmsg_flags |= NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK; |
| 553 | |
| 554 | ll_init_map(&rth); |
| 555 | |
| 556 | ret = rtnl_talk(&rth, n, n, sizeof(*n)); |
| 557 | if ((ret < 0) && (errno == EEXIST)) |
| 558 | ret = 0; |
| 559 | |
| 560 | return ret; |
| 561 | } |
| 562 | |
| 563 | |
| 564 | static int iprule_restore(void) |
| 565 | { |
| 566 | if (rule_dump_check_magic()) |
| 567 | exit(-1); |
| 568 | |
| 569 | exit(rtnl_from_file(stdin, &restore_handler, NULL)); |
| 570 | } |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 571 | |
osdl.net!shemminger | 50772dc | 2004-12-07 21:48:29 +0000 | [diff] [blame] | 572 | static int iprule_modify(int cmd, int argc, char **argv) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 573 | { |
David Ahern | 8c92e12 | 2016-06-10 10:47:17 -0700 | [diff] [blame] | 574 | int l3mdev_rule = 0; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 575 | int table_ok = 0; |
David Ahern | 8c92e12 | 2016-06-10 10:47:17 -0700 | [diff] [blame] | 576 | __u32 tid = 0; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 577 | struct { |
Stephen Hemminger | 4806867 | 2014-02-17 10:56:31 -0800 | [diff] [blame] | 578 | struct nlmsghdr n; |
| 579 | struct rtmsg r; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 580 | char buf[1024]; |
Phil Sutter | d17b136 | 2016-07-18 16:48:42 +0200 | [diff] [blame] | 581 | } req = { |
| 582 | .n.nlmsg_type = cmd, |
| 583 | .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)), |
| 584 | .n.nlmsg_flags = NLM_F_REQUEST, |
| 585 | .r.rtm_family = preferred_family, |
| 586 | .r.rtm_protocol = RTPROT_BOOT, |
| 587 | .r.rtm_scope = RT_SCOPE_UNIVERSE, |
| 588 | .r.rtm_type = RTN_UNSPEC, |
| 589 | }; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 590 | |
| 591 | if (cmd == RTM_NEWRULE) { |
| 592 | req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL; |
| 593 | req.r.rtm_type = RTN_UNICAST; |
| 594 | } |
| 595 | |
Andrey Jr. Melnikov | 67a990b | 2016-08-24 23:43:00 +0300 | [diff] [blame] | 596 | if (cmd == RTM_DELRULE && argc == 0) { |
| 597 | fprintf(stderr, "\"ip rule del\" requires arguments.\n"); |
| 598 | return -1; |
| 599 | } |
| 600 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 601 | while (argc > 0) { |
Thomas Graf | 3123a0c | 2006-11-09 12:38:02 +0100 | [diff] [blame] | 602 | if (strcmp(*argv, "not") == 0) { |
| 603 | req.r.rtm_flags |= FIB_RULE_INVERT; |
| 604 | } else if (strcmp(*argv, "from") == 0) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 605 | inet_prefix dst; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 606 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 607 | NEXT_ARG(); |
| 608 | get_prefix(&dst, *argv, req.r.rtm_family); |
| 609 | req.r.rtm_src_len = dst.bitlen; |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 610 | addattr_l(&req.n, sizeof(req), FRA_SRC, |
| 611 | &dst.data, dst.bytelen); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 612 | } else if (strcmp(*argv, "to") == 0) { |
| 613 | inet_prefix dst; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 614 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 615 | NEXT_ARG(); |
| 616 | get_prefix(&dst, *argv, req.r.rtm_family); |
| 617 | req.r.rtm_dst_len = dst.bitlen; |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 618 | addattr_l(&req.n, sizeof(req), FRA_DST, |
| 619 | &dst.data, dst.bytelen); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 620 | } else if (matches(*argv, "preference") == 0 || |
| 621 | matches(*argv, "order") == 0 || |
| 622 | matches(*argv, "priority") == 0) { |
| 623 | __u32 pref; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 624 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 625 | NEXT_ARG(); |
| 626 | if (get_u32(&pref, *argv, 0)) |
| 627 | invarg("preference value is invalid\n", *argv); |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 628 | addattr32(&req.n, sizeof(req), FRA_PRIORITY, pref); |
Arnd Hannemann | dec0160 | 2010-05-21 04:10:09 +0000 | [diff] [blame] | 629 | } else if (strcmp(*argv, "tos") == 0 || |
| 630 | matches(*argv, "dsfield") == 0) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 631 | __u32 tos; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 632 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 633 | NEXT_ARG(); |
| 634 | if (rtnl_dsfield_a2n(&tos, *argv)) |
| 635 | invarg("TOS value is invalid\n", *argv); |
| 636 | req.r.rtm_tos = tos; |
| 637 | } else if (strcmp(*argv, "fwmark") == 0) { |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 638 | char *slash; |
| 639 | __u32 fwmark, fwmask; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 640 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 641 | NEXT_ARG(); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 642 | |
| 643 | slash = strchr(*argv, '/'); |
| 644 | if (slash != NULL) |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 645 | *slash = '\0'; |
org[shemminger]!shemminger | 4fb466f | 2004-06-07 22:02:48 +0000 | [diff] [blame] | 646 | if (get_u32(&fwmark, *argv, 0)) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 647 | invarg("fwmark value is invalid\n", *argv); |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 648 | addattr32(&req.n, sizeof(req), FRA_FWMARK, fwmark); |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 649 | if (slash) { |
| 650 | if (get_u32(&fwmask, slash+1, 0)) |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 651 | invarg("fwmask value is invalid\n", |
| 652 | slash+1); |
| 653 | addattr32(&req.n, sizeof(req), |
| 654 | FRA_FWMASK, fwmask); |
Patrick McHardy | be7f286 | 2006-12-13 16:58:32 -0800 | [diff] [blame] | 655 | } |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 656 | } else if (matches(*argv, "realms") == 0) { |
| 657 | __u32 realm; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 658 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 659 | NEXT_ARG(); |
Daniel Borkmann | d583e88 | 2015-10-08 12:22:39 +0200 | [diff] [blame] | 660 | if (get_rt_realms_or_raw(&realm, *argv)) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 661 | invarg("invalid realms\n", *argv); |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 662 | addattr32(&req.n, sizeof(req), FRA_FLOW, realm); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 663 | } else if (matches(*argv, "table") == 0 || |
| 664 | strcmp(*argv, "lookup") == 0) { |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 665 | NEXT_ARG(); |
| 666 | if (rtnl_rttable_a2n(&tid, *argv)) |
| 667 | invarg("invalid table ID\n", *argv); |
Patrick McHardy | 34e9564 | 2006-08-11 00:14:51 +0200 | [diff] [blame] | 668 | if (tid < 256) |
| 669 | req.r.rtm_table = tid; |
| 670 | else { |
| 671 | req.r.rtm_table = RT_TABLE_UNSPEC; |
Patrick McHardy | ad1a12d | 2007-08-22 10:26:12 -0700 | [diff] [blame] | 672 | addattr32(&req.n, sizeof(req), FRA_TABLE, tid); |
Patrick McHardy | 34e9564 | 2006-08-11 00:14:51 +0200 | [diff] [blame] | 673 | } |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 674 | table_ok = 1; |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 675 | } else if (matches(*argv, "suppress_prefixlength") == 0 || |
| 676 | strcmp(*argv, "sup_pl") == 0) { |
| 677 | int pl; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 678 | |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 679 | NEXT_ARG(); |
| 680 | if (get_s32(&pl, *argv, 0) || pl < 0) |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 681 | invarg("suppress_prefixlength value is invalid\n", |
| 682 | *argv); |
| 683 | addattr32(&req.n, sizeof(req), |
| 684 | FRA_SUPPRESS_PREFIXLEN, pl); |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 685 | } else if (matches(*argv, "suppress_ifgroup") == 0 || |
| 686 | strcmp(*argv, "sup_group") == 0) { |
| 687 | NEXT_ARG(); |
| 688 | int group; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 689 | |
Stefan Tomanek | b1d0525 | 2013-08-03 14:23:16 +0200 | [diff] [blame] | 690 | if (rtnl_group_a2n(&group, *argv)) |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 691 | invarg("Invalid \"suppress_ifgroup\" value\n", |
| 692 | *argv); |
| 693 | addattr32(&req.n, sizeof(req), |
| 694 | FRA_SUPPRESS_IFGROUP, group); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 695 | } else if (strcmp(*argv, "dev") == 0 || |
| 696 | strcmp(*argv, "iif") == 0) { |
| 697 | NEXT_ARG(); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 698 | addattr_l(&req.n, sizeof(req), FRA_IFNAME, |
| 699 | *argv, strlen(*argv)+1); |
Patrick McHardy | 85eae22 | 2009-12-03 20:07:14 +0000 | [diff] [blame] | 700 | } else if (strcmp(*argv, "oif") == 0) { |
| 701 | NEXT_ARG(); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 702 | addattr_l(&req.n, sizeof(req), FRA_OIFNAME, |
| 703 | *argv, strlen(*argv)+1); |
David Ahern | 8c92e12 | 2016-06-10 10:47:17 -0700 | [diff] [blame] | 704 | } else if (strcmp(*argv, "l3mdev") == 0) { |
| 705 | addattr8(&req.n, sizeof(req), FRA_L3MDEV, 1); |
| 706 | table_ok = 1; |
| 707 | l3mdev_rule = 1; |
Lorenzo Colitti | 82252cd | 2016-11-07 01:26:51 +0900 | [diff] [blame] | 708 | } else if (strcmp(*argv, "uidrange") == 0) { |
| 709 | struct fib_rule_uid_range r; |
| 710 | |
| 711 | NEXT_ARG(); |
| 712 | if (sscanf(*argv, "%u-%u", &r.start, &r.end) != 2) |
| 713 | invarg("invalid UID range\n", *argv); |
| 714 | addattr_l(&req.n, sizeof(req), FRA_UID_RANGE, &r, |
| 715 | sizeof(r)); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 716 | } else if (strcmp(*argv, "nat") == 0 || |
| 717 | matches(*argv, "map-to") == 0) { |
| 718 | NEXT_ARG(); |
net[shemminger]!shemminger | 526afe4 | 2005-01-17 23:27:23 +0000 | [diff] [blame] | 719 | fprintf(stderr, "Warning: route NAT is deprecated\n"); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 720 | addattr32(&req.n, sizeof(req), RTA_GATEWAY, |
| 721 | get_addr32(*argv)); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 722 | req.r.rtm_type = RTN_NAT; |
| 723 | } else { |
| 724 | int type; |
| 725 | |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 726 | if (strcmp(*argv, "type") == 0) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 727 | NEXT_ARG(); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 728 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 729 | if (matches(*argv, "help") == 0) |
| 730 | usage(); |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 731 | else if (matches(*argv, "goto") == 0) { |
| 732 | __u32 target; |
Stephen Hemminger | 56f5daa | 2016-03-21 11:52:19 -0700 | [diff] [blame] | 733 | |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 734 | type = FR_ACT_GOTO; |
| 735 | NEXT_ARG(); |
| 736 | if (get_u32(&target, *argv, 0)) |
| 737 | invarg("invalid target\n", *argv); |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 738 | addattr32(&req.n, sizeof(req), |
| 739 | FRA_GOTO, target); |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 740 | } else if (matches(*argv, "nop") == 0) |
| 741 | type = FR_ACT_NOP; |
| 742 | else if (rtnl_rtntype_a2n(&type, *argv)) |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 743 | invarg("Failed to parse rule type", *argv); |
| 744 | req.r.rtm_type = type; |
Thomas Graf | 6b469ca | 2007-03-27 02:04:10 +0200 | [diff] [blame] | 745 | table_ok = 1; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 746 | } |
| 747 | argc--; |
| 748 | argv++; |
| 749 | } |
| 750 | |
David Ahern | 8c92e12 | 2016-06-10 10:47:17 -0700 | [diff] [blame] | 751 | if (l3mdev_rule && tid != 0) { |
| 752 | fprintf(stderr, |
| 753 | "table can not be specified for l3mdev rules\n"); |
| 754 | return -EINVAL; |
| 755 | } |
| 756 | |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 757 | if (req.r.rtm_family == AF_UNSPEC) |
| 758 | req.r.rtm_family = AF_INET; |
| 759 | |
| 760 | if (!table_ok && cmd == RTM_NEWRULE) |
| 761 | req.r.rtm_table = RT_TABLE_MAIN; |
| 762 | |
Stephen Hemminger | c079e12 | 2015-05-27 12:26:14 -0700 | [diff] [blame] | 763 | if (rtnl_talk(&rth, &req.n, NULL, 0) < 0) |
Stephen Hemminger | 076ae70 | 2015-05-06 09:53:41 -0700 | [diff] [blame] | 764 | return -2; |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 765 | |
| 766 | return 0; |
| 767 | } |
| 768 | |
| 769 | int do_iprule(int argc, char **argv) |
| 770 | { |
| 771 | if (argc < 1) { |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 772 | return iprule_list_flush_or_save(0, NULL, IPRULE_LIST); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 773 | } else if (matches(argv[0], "list") == 0 || |
| 774 | matches(argv[0], "lst") == 0 || |
| 775 | matches(argv[0], "show") == 0) { |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 776 | return iprule_list_flush_or_save(argc-1, argv+1, IPRULE_LIST); |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 777 | } else if (matches(argv[0], "save") == 0) { |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 778 | return iprule_list_flush_or_save(argc-1, argv+1, IPRULE_SAVE); |
Kirill Tkhai | 2f4e171 | 2015-10-20 13:41:48 +0300 | [diff] [blame] | 779 | } else if (matches(argv[0], "restore") == 0) { |
| 780 | return iprule_restore(); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 781 | } else if (matches(argv[0], "add") == 0) { |
| 782 | return iprule_modify(RTM_NEWRULE, argc-1, argv+1); |
| 783 | } else if (matches(argv[0], "delete") == 0) { |
| 784 | return iprule_modify(RTM_DELRULE, argc-1, argv+1); |
osdl.net!shemminger | 50772dc | 2004-12-07 21:48:29 +0000 | [diff] [blame] | 785 | } else if (matches(argv[0], "flush") == 0) { |
Hangbin Liu | cb294a1 | 2016-09-23 11:25:54 +0800 | [diff] [blame] | 786 | return iprule_list_flush_or_save(argc-1, argv+1, IPRULE_FLUSH); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 787 | } else if (matches(argv[0], "help") == 0) |
| 788 | usage(); |
| 789 | |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 790 | fprintf(stderr, |
| 791 | "Command \"%s\" is unknown, try \"ip rule help\".\n", *argv); |
osdl.org!shemminger | aba5acd | 2004-04-15 20:56:59 +0000 | [diff] [blame] | 792 | exit(-1); |
| 793 | } |
| 794 | |
Patrick McHardy | b6c8e80 | 2010-06-09 17:41:10 +0200 | [diff] [blame] | 795 | int do_multirule(int argc, char **argv) |
| 796 | { |
| 797 | switch (preferred_family) { |
| 798 | case AF_UNSPEC: |
| 799 | case AF_INET: |
| 800 | preferred_family = RTNL_FAMILY_IPMR; |
| 801 | break; |
| 802 | case AF_INET6: |
| 803 | preferred_family = RTNL_FAMILY_IP6MR; |
| 804 | break; |
Ben Greear | 0d1c9b5 | 2010-07-15 15:48:10 -0700 | [diff] [blame] | 805 | case RTNL_FAMILY_IPMR: |
| 806 | case RTNL_FAMILY_IP6MR: |
| 807 | break; |
Patrick McHardy | b6c8e80 | 2010-06-09 17:41:10 +0200 | [diff] [blame] | 808 | default: |
Stephen Hemminger | d831cc7 | 2016-06-14 17:20:02 -0700 | [diff] [blame] | 809 | fprintf(stderr, |
| 810 | "Multicast rules are only supported for IPv4/IPv6, was: %i\n", |
Ben Greear | 0d1c9b5 | 2010-07-15 15:48:10 -0700 | [diff] [blame] | 811 | preferred_family); |
Patrick McHardy | b6c8e80 | 2010-06-09 17:41:10 +0200 | [diff] [blame] | 812 | exit(-1); |
| 813 | } |
| 814 | |
| 815 | return do_iprule(argc, argv); |
| 816 | } |