| /* |
| * IFLA_LINKINFO netlink attribute decoding check. |
| * |
| * Copyright (c) 2018 The strace developers. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "tests.h" |
| |
| #include <inttypes.h> |
| #include <stdio.h> |
| #include <stddef.h> |
| #include <arpa/inet.h> |
| |
| #include "test_nlattr.h" |
| |
| #include <linux/if.h> |
| #include <linux/if_arp.h> |
| #ifdef HAVE_LINUX_IF_LINK_H |
| # include <linux/if_link.h> |
| #endif |
| #include <linux/rtnetlink.h> |
| |
| #define XLAT_MACROS_ONLY |
| # include <xlat/rtnl_link_attrs.h> |
| # include <xlat/rtnl_ifla_info_attrs.h> |
| #undef XLAT_MACROS_ONLY |
| |
| #define IFLA_ATTR IFLA_LINKINFO |
| #include "nlattr_ifla.h" |
| |
| #define COMMA , |
| #define TEST_UNKNOWN_TUNNELS(fd_, nlh0_, objtype_, objtype_str_, \ |
| obj_, objsz_, arrstrs_, ...) \ |
| do { \ |
| /* 64 is guestimate for maximum unknown type len */ \ |
| char buf[8 * 2 + 64 + objsz_]; \ |
| const char **arrstrs[] = arrstrs_; \ |
| const char ***arrstrs_pos = arrstrs; \ |
| const char **arrstr = *arrstrs_pos; \ |
| const char *type = NULL; \ |
| \ |
| for (type = arrstr ? arrstr[0] : NULL; type && arrstr; \ |
| type = (++arrstr)[0] ? arrstr[0] \ |
| : (++arrstrs_pos)[0] \ |
| ? (arrstr = arrstrs_pos[0])[0] \ |
| : NULL) \ |
| { \ |
| size_t type_len = strlen(type) + 1; \ |
| \ |
| if (type_len > 64) \ |
| error_msg_and_fail("Unexpectedly long " \ |
| "unknown type: \"%s\" " \ |
| "(length is %zu)", \ |
| type, type_len); \ |
| \ |
| struct nlattr obj_nla = { \ |
| .nla_len = NLA_HDRLEN + (objsz_), \ |
| .nla_type = (objtype_), \ |
| }; \ |
| \ |
| char *pos = buf; \ |
| memcpy(pos, type, type_len); \ |
| pos += NLA_ALIGN(type_len); \ |
| memcpy(pos, &obj_nla, sizeof(obj_nla)); \ |
| pos += sizeof(obj_nla); \ |
| memcpy(pos, (obj_), (objsz_)); \ |
| \ |
| TEST_NLATTR_EX_((fd_), \ |
| (nlh0_) - hdrlen - (pos - buf), \ |
| hdrlen + NLA_HDRLEN, \ |
| init_ifinfomsg, print_ifinfomsg, \ |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", \ |
| type_len, objsz_ + (pos - buf), \ |
| buf, objsz_ + (pos - buf), \ |
| printf("\"%s\"}", type); \ |
| printf(", {{nla_len=%zu" \ |
| ", nla_type=%s}, ", \ |
| (objsz_) + NLA_HDRLEN, \ |
| (objtype_str_)); \ |
| \ |
| { __VA_ARGS__; } \ |
| \ |
| printf("}")); \ |
| } \ |
| } while (0) |
| |
| #define TEST_LINKINFO_(fd_, nlh0_, nla_type_, nla_type_str_, tuntype_, \ |
| obj_, objsz_, pattern_, fallback_func_, ...) \ |
| do { \ |
| size_t tuntype_len = strlen(tuntype_) + 1; \ |
| char *buf = tail_alloc(NLA_ALIGN(tuntype_len) \ |
| + NLA_HDRLEN + (objsz_)); \ |
| char *pos = buf; \ |
| \ |
| struct nlattr obj_nla = { \ |
| .nla_len = NLA_HDRLEN + (objsz_), \ |
| .nla_type = (nla_type_), \ |
| }; \ |
| \ |
| memcpy(pos, (tuntype_), tuntype_len); \ |
| pos += NLA_ALIGN(tuntype_len); \ |
| memcpy(pos, &obj_nla, sizeof(obj_nla)); \ |
| pos += sizeof(obj_nla); \ |
| memcpy(pos, &(obj_), (objsz_)); \ |
| \ |
| if (fallback_func_ == print_quoted_hex) { \ |
| TEST_NLATTR_EX_((fd_), \ |
| (nlh0_) - NLA_HDRLEN, \ |
| hdrlen + NLA_HDRLEN, \ |
| init_ifinfomsg, print_ifinfomsg, \ |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", \ |
| tuntype_len, \ |
| objsz_ + (pos - buf) - 1, \ |
| buf, objsz_ + (pos - buf) - 1, \ |
| printf("\"%s\"}", (tuntype_)); \ |
| printf(", {{nla_len=%zu" \ |
| ", nla_type=%s}, ", \ |
| (objsz_) + NLA_HDRLEN, \ |
| (nla_type_str_)); \ |
| (fallback_func_)((obj_), \ |
| (objsz_) - 1); \ |
| printf("}")); \ |
| } \ |
| \ |
| TEST_NLATTR_EX_((fd_), (nlh0_) - NLA_HDRLEN, \ |
| hdrlen + NLA_HDRLEN, \ |
| init_ifinfomsg, print_ifinfomsg, \ |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", \ |
| tuntype_len, objsz_ + (pos - buf), \ |
| buf, objsz_ + (pos - buf) - 1, \ |
| printf("\"%s\"}", (tuntype_)); \ |
| printf(", {{nla_len=%zu, nla_type=%s}, ", \ |
| (objsz_) + NLA_HDRLEN, \ |
| (nla_type_str_)); \ |
| printf("%p}", \ |
| RTA_DATA(NLMSG_ATTR(nlh, \ |
| (hdrlen + NLA_HDRLEN + (pos - buf)))) \ |
| ) \ |
| ); \ |
| \ |
| TEST_NLATTR_EX_((fd_), (nlh0_) - NLA_HDRLEN, \ |
| hdrlen + NLA_HDRLEN, \ |
| init_ifinfomsg, print_ifinfomsg, \ |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", \ |
| tuntype_len, objsz_ + (pos - buf), \ |
| buf, objsz_ + (pos - buf), \ |
| printf("\"%s\"}", (tuntype_)); \ |
| printf(", {{nla_len=%zu, nla_type=%s}, ", \ |
| (objsz_) + NLA_HDRLEN, \ |
| (nla_type_str_)); \ |
| \ |
| { __VA_ARGS__; } \ |
| \ |
| printf("}")); \ |
| } while (0) |
| |
| #define TEST_LINKINFO(fd_, nlh0_, nla_type_, tuntype_, \ |
| obj_, pattern_, fallback_func_, ...) \ |
| TEST_LINKINFO_((fd_), (nlh0_), nla_type_, #nla_type_, (tuntype_), \ |
| (obj_), sizeof(obj_), pattern_, fallback_func_, \ |
| __VA_ARGS__) |
| |
| #define TEST_NESTED_LINKINFO(fd_, nlh0_, \ |
| nla_type_, nla_type_str_, tuntype_, \ |
| subnla_type_, subnla_type_str_, \ |
| obj_, pattern_, ...) \ |
| do { \ |
| size_t tuntype_len = strlen(tuntype_) + 1; \ |
| struct { \ |
| size_t sz; \ |
| const char *str; \ |
| } attrs[] = { __VA_ARGS__ }; \ |
| size_t tunhdrlen; \ |
| size_t buflen = NLA_ALIGN(tuntype_len) + NLA_HDRLEN; \ |
| size_t attrsz = 0; \ |
| \ |
| for (size_t i = 0; i < ARRAY_SIZE(attrs); i++) \ |
| attrsz += NLA_HDRLEN + NLA_ALIGN(attrs[i].sz); \ |
| \ |
| buflen += attrsz; \ |
| \ |
| char *buf = tail_alloc(buflen); \ |
| char *pos = buf; \ |
| \ |
| struct nlattr nla = { \ |
| .nla_len = NLA_HDRLEN + attrsz, \ |
| .nla_type = (nla_type_), \ |
| }; \ |
| \ |
| memcpy(pos, (tuntype_), tuntype_len); \ |
| pos += NLA_ALIGN(tuntype_len); \ |
| memcpy(pos, &nla, sizeof(nla)); \ |
| pos += sizeof(nla); \ |
| \ |
| tunhdrlen = pos - buf; \ |
| \ |
| nla.nla_type = subnla_type_; \ |
| \ |
| for (size_t i = 0; i < ARRAY_SIZE(attrs); i++) { \ |
| nla.nla_len = NLA_HDRLEN + attrs[i].sz; \ |
| memcpy(pos, &nla, sizeof(nla)); \ |
| pos += sizeof(nla); \ |
| \ |
| memcpy(pos, &(obj_), MIN(sizeof(obj_), attrs[i].sz)); \ |
| \ |
| if (attrs[i].sz > sizeof(obj_)) \ |
| memcpy(pos + sizeof(obj_), \ |
| &(pattern_), \ |
| attrs[i].sz - sizeof(obj_)); \ |
| \ |
| pos += NLA_ALIGN(attrs[i].sz); \ |
| } \ |
| \ |
| TEST_NLATTR_EX_((fd_), (nlh0_) - hdrlen - tunhdrlen, \ |
| hdrlen + NLA_HDRLEN, \ |
| init_ifinfomsg, print_ifinfomsg, \ |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", \ |
| tuntype_len, buflen, \ |
| buf, buflen, \ |
| printf("\"%s\"}", (tuntype_)); \ |
| printf(", {{nla_len=%zu, nla_type=%s}, [", \ |
| attrsz + NLA_HDRLEN, \ |
| (nla_type_str_)); \ |
| \ |
| for (size_t i = 0; i < ARRAY_SIZE(attrs); i++) \ |
| printf("%s%s{nla_len=%zu" \ |
| ", nla_type=%s}%s%s%s", \ |
| i ? ", " : "", \ |
| attrs[i].str ? "{": "", \ |
| attrs[i].sz + NLA_HDRLEN, \ |
| subnla_type_str_, \ |
| attrs[i].str ? ", ": "", \ |
| attrs[i].str ?: "", \ |
| attrs[i].str ? "}" : ""); \ |
| \ |
| printf("]}")); \ |
| } while (0) |
| |
| int |
| main(void) |
| { |
| static const uint8_t unknown_msg[] = { 0xab, 0xac, 0xdb, 0xcd }; |
| static const char *unsupported_tunnel_types[] = { |
| "batadv", "bond", |
| "caif", "cfhsi", |
| "dummy", |
| "erspan", |
| "geneve", "gre", "gretap", "gtp", |
| "hsr", |
| "ifb", "ip6erspan", "ip6gre", "ip6gretap", "ip6tnl", |
| "ipip", "ipoib", "ipvlan", "ipvtap", |
| "lowpan", |
| "macsec", "macvlan", "macvtap", |
| "netdevsim", "nlmon", |
| "openvswitch", |
| "ppp", |
| "rmnet", |
| "sit", |
| "team", |
| "vcan", "veth", "vlan", "vrf", "vsockmon", |
| "vti", "vti6", "vxcan", "vxlan", |
| NULL |
| }; |
| static const char *unsupported_xstats_types[] = { |
| "bridge", |
| "tun", |
| NULL |
| }; |
| static const char *unsupported_data_types[] = { |
| "can", |
| NULL |
| }; |
| |
| skip_if_unavailable("/proc/self/fd/"); |
| |
| const int fd = create_nl_socket(NETLINK_ROUTE); |
| |
| const unsigned int hdrlen = sizeof(struct ifinfomsg); |
| void *nlh0 = midtail_alloc(NLMSG_SPACE(hdrlen), 2 * NLA_HDRLEN + 256); |
| |
| static char pattern[4096]; |
| fill_memory_ex(pattern, sizeof(pattern), 'a', 'z' - 'a' + 1); |
| |
| |
| /* unknown AF_INFO_* type */ |
| TEST_NESTED_NLATTR_OBJECT(fd, nlh0, hdrlen, |
| init_ifinfomsg, print_ifinfomsg, |
| IFLA_INFO_UNSPEC, pattern, unknown_msg, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| TEST_NESTED_NLATTR_OBJECT_EX_(fd, nlh0, hdrlen, |
| init_ifinfomsg, print_ifinfomsg, |
| 6, "0x6 /* IFLA_INFO_??? */", pattern, |
| unknown_msg, print_quoted_hex, 1, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| |
| /* IFLA_INFO_KIND */ |
| TEST_NESTED_NLATTR_OBJECT_EX_(fd, nlh0, hdrlen, |
| init_ifinfomsg, print_ifinfomsg, |
| IFLA_INFO_KIND, "IFLA_INFO_KIND", pattern, |
| unknown_msg, print_quoted_stringn, 1, |
| printf("\"\\253\\254\\333\\315\"...")); |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_UNSPEC */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, IFLA_INFO_UNSPEC, "IFLA_INFO_UNSPEC", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_KIND */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, IFLA_INFO_KIND, "IFLA_INFO_KIND", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\253\\254\\333\\315\"...")); |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_DATA */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, IFLA_INFO_DATA, "IFLA_INFO_DATA", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| struct val_name { |
| unsigned int val; |
| const char *name; |
| }; |
| |
| static const uint64_t u64_val = 0xdeadc0defacefeedULL; |
| static const uint32_t u32_val = 0xbadc0dedU; |
| static const uint16_t u16_val = 0xdeed; |
| static const uint8_t u8_val = 0xa1; |
| |
| /* bridge attrs */ |
| static const struct val_name und_br_attrs[] = { |
| { 0, "IFLA_BR_UNSPEC" }, |
| { 20, "IFLA_BR_GROUP_ADDR" }, |
| { 21, "IFLA_BR_FDB_FLUSH" }, |
| { 40, "IFLA_BR_PAD" }, |
| { 45, "0x2d /* IFLA_BR_??? */" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(und_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| und_br_attrs[k].val, und_br_attrs[k].name, |
| unknown_msg, pattern, |
| { 2, "\"\\xab\\xac\"" }, |
| { 4, "\"\\xab\\xac\\xdb\\xcd\"" }, |
| { 6, |
| "\"\\xab\\xac\\xdb\\xcd\\x61\\x62\"" }, |
| { 8, "\"\\xab\\xac\\xdb\\xcd\\x61\\x62" |
| "\\x63\\x64\"" }, |
| { 10, "\"\\xab\\xac\\xdb\\xcd\\x61\\x62" |
| "\\x63\\x64\\x65\\x66\"" }); |
| } |
| |
| static const struct val_name u64_br_attrs[] = { |
| { 16, "IFLA_BR_HELLO_TIMER" }, |
| { 17, "IFLA_BR_TCN_TIMER" }, |
| { 18, "IFLA_BR_TOPOLOGY_CHANGE_TIMER" }, |
| { 19, "IFLA_BR_GC_TIMER" }, |
| { 30, "IFLA_BR_MCAST_LAST_MEMBER_INTVL" }, |
| { 31, "IFLA_BR_MCAST_MEMBERSHIP_INTVL" }, |
| { 32, "IFLA_BR_MCAST_QUERIER_INTVL" }, |
| { 33, "IFLA_BR_MCAST_QUERY_INTVL" }, |
| { 34, "IFLA_BR_MCAST_QUERY_RESPONSE_INTVL" }, |
| { 35, "IFLA_BR_MCAST_STARTUP_QUERY_INTVL" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u64_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| u64_br_attrs[k].val, u64_br_attrs[k].name, |
| u64_val, pattern, |
| { 7, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xde\\xad\\xc0\\xde\\xfa\\xce\\xfe" |
| #else |
| "\\xed\\xfe\\xce\\xfa\\xde\\xc0\\xad" |
| #endif |
| "\"" }, |
| { 8, "16045693111314087661" }, |
| { 9, "16045693111314087661" }); |
| } |
| |
| static const struct val_name u32_br_attrs[] = { |
| { 1, "IFLA_BR_FORWARD_DELAY" }, |
| { 2, "IFLA_BR_HELLO_TIME" }, |
| { 3, "IFLA_BR_MAX_AGE" }, |
| { 4, "IFLA_BR_AGEING_TIME" }, |
| { 5, "IFLA_BR_STP_STATE" }, |
| { 13, "IFLA_BR_ROOT_PATH_COST" }, |
| { 26, "IFLA_BR_MCAST_HASH_ELASTICITY" }, |
| { 27, "IFLA_BR_MCAST_HASH_MAX" }, |
| { 28, "IFLA_BR_MCAST_LAST_MEMBER_CNT" }, |
| { 29, "IFLA_BR_MCAST_STARTUP_QUERY_CNT" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u32_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| u32_br_attrs[k].val, u32_br_attrs[k].name, |
| u32_val, pattern, |
| { 3, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xba\\xdc\\x0d" |
| #else |
| "\\xed\\x0d\\xdc" |
| #endif |
| "\"" }, |
| { 4, "3134983661" }, |
| { 5, "3134983661" }); |
| } |
| |
| static const struct val_name u16_br_attrs[] = { |
| { 6, "IFLA_BR_PRIORITY" }, |
| { 12, "IFLA_BR_ROOT_PORT" }, |
| { 39, "IFLA_BR_VLAN_DEFAULT_PVID" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u16_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| u16_br_attrs[k].val, u16_br_attrs[k].name, |
| u16_val, pattern, |
| { 1, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xde" |
| #else |
| "\\xed" |
| #endif |
| "\"" }, |
| { 2, "57069" }, |
| { 3, "57069" }); |
| } |
| |
| |
| static const struct val_name x16_br_attrs[] = { |
| { 9, "IFLA_BR_GROUP_FWD_MASK" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(x16_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| x16_br_attrs[k].val, x16_br_attrs[k].name, |
| u16_val, pattern, |
| { 1, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xde" |
| #else |
| "\\xed" |
| #endif |
| "\"" }, |
| { 2, "0xdeed" }, |
| { 3, "0xdeed" }); |
| } |
| |
| static const struct val_name u8_br_attrs[] = { |
| { 7, "IFLA_BR_VLAN_FILTERING" }, |
| { 14, "IFLA_BR_TOPOLOGY_CHANGE" }, |
| { 15, "IFLA_BR_TOPOLOGY_CHANGE_DETECTED" }, |
| { 22, "IFLA_BR_MCAST_ROUTER" }, |
| { 23, "IFLA_BR_MCAST_SNOOPING" }, |
| { 24, "IFLA_BR_MCAST_QUERY_USE_IFADDR" }, |
| { 25, "IFLA_BR_MCAST_QUERIER" }, |
| { 36, "IFLA_BR_NF_CALL_IPTABLES" }, |
| { 37, "IFLA_BR_NF_CALL_IP6TABLES" }, |
| { 38, "IFLA_BR_NF_CALL_ARPTABLES" }, |
| { 41, "IFLA_BR_VLAN_STATS_ENABLED" }, |
| { 42, "IFLA_BR_MCAST_STATS_ENABLED" }, |
| { 43, "IFLA_BR_MCAST_IGMP_VERSION" }, |
| { 44, "IFLA_BR_MCAST_MLD_VERSION" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u8_br_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| u8_br_attrs[k].val, u8_br_attrs[k].name, |
| u8_val, pattern, |
| { 0, NULL }, |
| { 1, "161" }, |
| { 2, "161" }); |
| } |
| |
| unsigned short eth_p = htons(0x88C7); |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| 8, "IFLA_BR_VLAN_PROTOCOL", |
| eth_p, pattern, |
| { 1, "\"\\x88\"" }, |
| { 2, "htons(ETH_P_PREAUTH)" }, |
| { 2, "htons(ETH_P_PREAUTH)" }); |
| |
| static const uint8_t bridge_id[] |
| = { 0xbe, 0xef, 0xfa, 0xce, 0xde, 0xc0, 0xde, 0xad }; |
| static const struct val_name br_id_attrs[] = { |
| { 10, "IFLA_BR_ROOT_ID" }, |
| { 11, "IFLA_BR_BRIDGE_ID" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(br_id_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "bridge", |
| br_id_attrs[k].val, br_id_attrs[k].name, |
| bridge_id, pattern, |
| { 7, "\"\\xbe\\xef\\xfa\\xce" |
| "\\xde\\xc0\\xde\"" }, |
| { 8, "{prio=[190, 239]" |
| ", addr=fa:ce:de:c0:de:ad}" }, |
| { 9, "{prio=[190, 239]" |
| ", addr=fa:ce:de:c0:de:ad}" }); |
| } |
| |
| /* tun attrs */ |
| static const struct val_name u8_tun_attrs[] = { |
| { 4, "IFLA_TUN_PI" }, |
| { 5, "IFLA_TUN_VNET_HDR" }, |
| { 6, "IFLA_TUN_PERSIST" }, |
| { 7, "IFLA_TUN_MULTI_QUEUE" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u8_tun_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| u8_tun_attrs[k].val, u8_tun_attrs[k].name, |
| u8_val, pattern, |
| { 0, NULL }, |
| { 1, "161" }, |
| { 2, "161" }); |
| } |
| |
| static const struct val_name u32_tun_attrs[] = { |
| { 8, "IFLA_TUN_NUM_QUEUES" }, |
| { 9, "IFLA_TUN_NUM_DISABLED_QUEUES" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(u32_tun_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| u32_tun_attrs[k].val, |
| u32_tun_attrs[k].name, |
| u32_val, pattern, |
| { 3, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xba\\xdc\\x0d" |
| #else |
| "\\xed\\x0d\\xdc" |
| #endif |
| "\"" }, |
| { 4, "3134983661" }, |
| { 5, "3134983661" }); |
| } |
| |
| static const struct val_name und_tun_attrs[] = { |
| { 0, "IFLA_TUN_UNSPEC" }, |
| { 10, "0xa /* IFLA_TUN_??? */" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(und_tun_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| und_tun_attrs[k].val, |
| und_tun_attrs[k].name, |
| unknown_msg, pattern, |
| { 2, "\"\\xab\\xac\"" }, |
| { 4, "\"\\xab\\xac\\xdb\\xcd\"" }, |
| { 6, |
| "\"\\xab\\xac\\xdb\\xcd\\x61\\x62\"" }, |
| { 8, "\"\\xab\\xac\\xdb\\xcd\\x61\\x62" |
| "\\x63\\x64\"" }, |
| { 10, "\"\\xab\\xac\\xdb\\xcd\\x61\\x62" |
| "\\x63\\x64\\x65\\x66\"" }); |
| } |
| |
| static const uint32_t minus_one = 0xffffffffU; |
| static const struct val_name uid_tun_attrs[] = { |
| { 1, "IFLA_TUN_OWNER" }, |
| { 2, "IFLA_TUN_GROUP" }, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(uid_tun_attrs); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| uid_tun_attrs[k].val, |
| uid_tun_attrs[k].name, |
| u32_val, pattern, |
| { 3, "\"" |
| #if WORDS_BIGENDIAN |
| "\\xba\\xdc\\x0d" |
| #else |
| "\\xed\\x0d\\xdc" |
| #endif |
| "\"" }, |
| { 4, "3134983661" }, |
| { 5, "3134983661" }); |
| |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| uid_tun_attrs[k].val, |
| uid_tun_attrs[k].name, |
| minus_one, pattern, |
| { 3, "\"\\xff\\xff\\xff\"" }, |
| { 4, "-1" }, |
| { 5, "-1" }); |
| } |
| |
| static const struct { |
| uint8_t val; |
| const char *str; |
| } tun_types[] = { |
| { 0, "0 /* IFF_??? */"}, |
| { 1, "IFF_TUN"}, |
| { 2, "IFF_TAP"}, |
| { 3, "0x3 /* IFF_??? */"}, |
| { 0xda, "0xda /* IFF_??? */"}, |
| }; |
| |
| for (size_t k = 0; k < ARRAY_SIZE(tun_types); k++) { |
| TEST_NESTED_LINKINFO(fd, nlh0, 2, "IFLA_INFO_DATA", "tun", |
| 3, "IFLA_TUN_TYPE", |
| tun_types[k].val, pattern, |
| { 0, NULL }, |
| { 1, tun_types[k].str }, |
| { 2, tun_types[k].str }); |
| } |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_XSTATS */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, IFLA_INFO_XSTATS, "IFLA_INFO_XSTATS", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| /* |
| * can decoder decodes its data only if it's big |
| * enough. |
| */ |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| uint32_t can_stats_data[] = { |
| 0xbadc0de0, 0xbadc0de1, 0xbadc0de2, 0xbadc0de3, |
| 0xbadc0de4, 0xbadc0de5, |
| }; |
| |
| TEST_LINKINFO(fd, nlh0, IFLA_INFO_XSTATS, "can", |
| can_stats_data, pattern, print_quoted_hex, |
| printf("{bus_error=3134983648" |
| ", error_warning=3134983649" |
| ", error_passive=3134983650" |
| ", bus_off=3134983651" |
| ", arbitration_lost=3134983652" |
| ", restarts=3134983653}")); |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_SLVAE_KIND */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, |
| IFLA_INFO_SLAVE_KIND, "IFLA_INFO_SLAVE_KIND", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\253\\254\\333\\315\"...")); |
| |
| |
| /* IFLA_INFO_KIND + IFLA_INFO_SLAVE_DATA */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, |
| IFLA_INFO_SLAVE_DATA, "IFLA_INFO_SLAVE_DATA", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| |
| /* IFLA_INFO_KIND + unknown type */ |
| TEST_UNKNOWN_TUNNELS(fd, nlh0, 6, "0x6 /* IFLA_INFO_??? */", |
| unknown_msg, sizeof(unknown_msg), |
| {unsupported_tunnel_types COMMA |
| unsupported_xstats_types COMMA |
| unsupported_data_types COMMA |
| NULL}, |
| printf("\"\\xab\\xac\\xdb\\xcd\"")); |
| |
| |
| puts("+++ exited with 0 +++"); |
| return 0; |
| } |
