1 #include <stdio.h> 2 #include <string.h> 3 #include <stdlib.h> 4 5 #include <sys/param.h> 6 #include <sys/module.h> 7 8 #include <netlink/netlink.h> 9 #include <netlink/netlink_route.h> 10 #include "netlink/netlink_snl.h" 11 #include "netlink/netlink_snl_route.h" 12 #include "netlink/netlink_snl_route_parsers.h" 13 14 #include <atf-c.h> 15 16 static const struct snl_hdr_parser *snl_all_core_parsers[] = { 17 &snl_errmsg_parser, &snl_donemsg_parser, 18 &_nla_bit_parser, &_nla_bitset_parser, 19 }; 20 21 static const struct snl_hdr_parser *snl_all_route_parsers[] = { 22 &_metrics_mp_nh_parser, &_mpath_nh_parser, &_metrics_parser, &snl_rtm_route_parser, 23 &_link_fbsd_parser, &snl_rtm_link_parser, &snl_rtm_link_parser_simple, 24 &_neigh_fbsd_parser, &snl_rtm_neigh_parser, 25 &_addr_fbsd_parser, &snl_rtm_addr_parser, &_nh_fbsd_parser, &snl_nhmsg_parser, 26 }; 27 28 static void 29 require_netlink(void) 30 { 31 if (modfind("netlink") == -1) 32 atf_tc_skip("netlink module not loaded"); 33 } 34 35 ATF_TC(snl_verify_core_parsers); 36 ATF_TC_HEAD(snl_verify_core_parsers, tc) 37 { 38 atf_tc_set_md_var(tc, "descr", "Tests snl(3) core nlmsg parsers are correct"); 39 } 40 41 ATF_TC_BODY(snl_verify_core_parsers, tc) 42 { 43 SNL_VERIFY_PARSERS(snl_all_core_parsers); 44 45 } 46 47 ATF_TC(snl_verify_route_parsers); 48 ATF_TC_HEAD(snl_verify_route_parsers, tc) 49 { 50 atf_tc_set_md_var(tc, "descr", "Tests snl(3) route parsers are correct"); 51 } 52 53 ATF_TC_BODY(snl_verify_route_parsers, tc) 54 { 55 SNL_VERIFY_PARSERS(snl_all_route_parsers); 56 57 } 58 59 ATF_TC(snl_parse_errmsg_capped); 60 ATF_TC_HEAD(snl_parse_errmsg_capped, tc) 61 { 62 atf_tc_set_md_var(tc, "descr", "Tests snl(3) correctly parsing capped errors"); 63 } 64 65 ATF_TC_BODY(snl_parse_errmsg_capped, tc) 66 { 67 struct snl_state ss; 68 struct snl_writer nw; 69 70 require_netlink(); 71 72 if (!snl_init(&ss, NETLINK_ROUTE)) 73 atf_tc_fail("snl_init() failed"); 74 75 atf_tc_skip("does not work"); 76 77 int optval = 1; 78 ATF_CHECK(setsockopt(ss.fd, SOL_NETLINK, NETLINK_CAP_ACK, &optval, sizeof(optval)) == 0); 79 80 snl_init_writer(&ss, &nw); 81 82 struct nlmsghdr *hdr = snl_create_msg_request(&nw, 255); 83 ATF_CHECK(hdr != NULL); 84 ATF_CHECK(snl_reserve_msg_object(&nw, struct ifinfomsg) != NULL); 85 snl_add_msg_attr_string(&nw, 143, "some random string"); 86 ATF_CHECK(snl_finalize_msg(&nw) != NULL); 87 88 ATF_CHECK(snl_send_message(&ss, hdr)); 89 90 struct nlmsghdr *rx_hdr = snl_read_reply(&ss, hdr->nlmsg_seq); 91 ATF_CHECK(rx_hdr != NULL); 92 ATF_CHECK(rx_hdr->nlmsg_type == NLMSG_ERROR); 93 94 struct snl_errmsg_data e = {}; 95 ATF_CHECK(rx_hdr->nlmsg_len == sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr)); 96 ATF_CHECK(snl_parse_errmsg(&ss, rx_hdr, &e)); 97 ATF_CHECK(e.error != 0); 98 ATF_CHECK(!memcmp(hdr, e.orig_hdr, sizeof(struct nlmsghdr))); 99 } 100 101 ATF_TC(snl_parse_errmsg_capped_extack); 102 ATF_TC_HEAD(snl_parse_errmsg_capped_extack, tc) 103 { 104 atf_tc_set_md_var(tc, "descr", "Tests snl(3) correctly parsing capped errors with extack"); 105 } 106 107 ATF_TC_BODY(snl_parse_errmsg_capped_extack, tc) 108 { 109 struct snl_state ss; 110 struct snl_writer nw; 111 112 require_netlink(); 113 114 if (!snl_init(&ss, NETLINK_ROUTE)) 115 atf_tc_fail("snl_init() failed"); 116 117 int optval = 1; 118 ATF_CHECK(setsockopt(ss.fd, SOL_NETLINK, NETLINK_CAP_ACK, &optval, sizeof(optval)) == 0); 119 optval = 1; 120 ATF_CHECK(setsockopt(ss.fd, SOL_NETLINK, NETLINK_EXT_ACK, &optval, sizeof(optval)) == 0); 121 122 snl_init_writer(&ss, &nw); 123 124 struct nlmsghdr *hdr = snl_create_msg_request(&nw, 255); 125 ATF_CHECK(hdr != NULL); 126 ATF_CHECK(snl_reserve_msg_object(&nw, struct ifinfomsg) != NULL); 127 snl_add_msg_attr_string(&nw, 143, "some random string"); 128 ATF_CHECK(snl_finalize_msg(&nw) != NULL); 129 130 ATF_CHECK(snl_send_message(&ss, hdr)); 131 132 struct nlmsghdr *rx_hdr = snl_read_reply(&ss, hdr->nlmsg_seq); 133 ATF_CHECK(rx_hdr != NULL); 134 ATF_CHECK(rx_hdr->nlmsg_type == NLMSG_ERROR); 135 136 struct snl_errmsg_data e = {}; 137 ATF_CHECK(snl_parse_errmsg(&ss, rx_hdr, &e)); 138 ATF_CHECK(e.error != 0); 139 ATF_CHECK(!memcmp(hdr, e.orig_hdr, sizeof(struct nlmsghdr))); 140 141 ATF_CHECK(e.error_str != NULL); 142 } 143 144 ATF_TC(snl_parse_errmsg_uncapped_extack); 145 ATF_TC_HEAD(snl_parse_errmsg_uncapped_extack, tc) 146 { 147 atf_tc_set_md_var(tc, "descr", "Tests snl(3) correctly parsing errors with extack"); 148 } 149 150 ATF_TC_BODY(snl_parse_errmsg_uncapped_extack, tc) 151 { 152 struct snl_state ss; 153 struct snl_writer nw; 154 155 require_netlink(); 156 157 ATF_CHECK(snl_init(&ss, NETLINK_ROUTE)); 158 159 int optval = 1; 160 ATF_CHECK(setsockopt(ss.fd, SOL_NETLINK, NETLINK_EXT_ACK, &optval, sizeof(optval)) == 0); 161 162 snl_init_writer(&ss, &nw); 163 164 struct nlmsghdr *hdr = snl_create_msg_request(&nw, 255); 165 ATF_CHECK(hdr != NULL); 166 ATF_CHECK(snl_reserve_msg_object(&nw, struct ifinfomsg) != NULL); 167 snl_add_msg_attr_string(&nw, 143, "some random string"); 168 ATF_CHECK(snl_finalize_msg(&nw) != NULL); 169 170 ATF_CHECK(snl_send_message(&ss, hdr)); 171 172 struct nlmsghdr *rx_hdr = snl_read_reply(&ss, hdr->nlmsg_seq); 173 ATF_CHECK(rx_hdr != NULL); 174 ATF_CHECK(rx_hdr->nlmsg_type == NLMSG_ERROR); 175 176 struct snl_errmsg_data e = {}; 177 ATF_CHECK(snl_parse_errmsg(&ss, rx_hdr, &e)); 178 ATF_CHECK(e.error != 0); 179 ATF_CHECK(!memcmp(hdr, e.orig_hdr, hdr->nlmsg_len)); 180 181 ATF_CHECK(e.error_str != NULL); 182 } 183 184 ATF_TC(snl_list_ifaces); 185 ATF_TC_HEAD(snl_list_ifaces, tc) 186 { 187 atf_tc_set_md_var(tc, "descr", "Tests snl(3) listing interfaces"); 188 } 189 190 struct nl_parsed_link { 191 uint32_t ifi_index; 192 uint32_t ifla_mtu; 193 char *ifla_ifname; 194 }; 195 196 #define _IN(_field) offsetof(struct ifinfomsg, _field) 197 #define _OUT(_field) offsetof(struct nl_parsed_link, _field) 198 static struct snl_attr_parser ap_link[] = { 199 { .type = IFLA_IFNAME, .off = _OUT(ifla_ifname), .cb = snl_attr_get_string }, 200 { .type = IFLA_MTU, .off = _OUT(ifla_mtu), .cb = snl_attr_get_uint32 }, 201 }; 202 static struct snl_field_parser fp_link[] = { 203 {.off_in = _IN(ifi_index), .off_out = _OUT(ifi_index), .cb = snl_field_get_uint32 }, 204 }; 205 #undef _IN 206 #undef _OUT 207 SNL_DECLARE_PARSER(link_parser, struct ifinfomsg, fp_link, ap_link); 208 209 210 ATF_TC_BODY(snl_list_ifaces, tc) 211 { 212 struct snl_state ss; 213 struct snl_writer nw; 214 215 require_netlink(); 216 217 if (!snl_init(&ss, NETLINK_ROUTE)) 218 atf_tc_fail("snl_init() failed"); 219 220 snl_init_writer(&ss, &nw); 221 222 struct nlmsghdr *hdr = snl_create_msg_request(&nw, RTM_GETLINK); 223 ATF_CHECK(hdr != NULL); 224 ATF_CHECK(snl_reserve_msg_object(&nw, struct ifinfomsg) != NULL); 225 ATF_CHECK(snl_finalize_msg(&nw) != NULL); 226 uint32_t seq_id = hdr->nlmsg_seq; 227 228 ATF_CHECK(snl_send_message(&ss, hdr)); 229 230 struct snl_errmsg_data e = {}; 231 int count = 0; 232 233 while ((hdr = snl_read_reply_multi(&ss, seq_id, &e)) != NULL) { 234 count++; 235 } 236 ATF_REQUIRE(e.error == 0); 237 238 ATF_REQUIRE_MSG(count > 0, "Empty interface list"); 239 } 240 241 ATF_TP_ADD_TCS(tp) 242 { 243 ATF_TP_ADD_TC(tp, snl_verify_core_parsers); 244 ATF_TP_ADD_TC(tp, snl_verify_route_parsers); 245 ATF_TP_ADD_TC(tp, snl_parse_errmsg_capped); 246 ATF_TP_ADD_TC(tp, snl_parse_errmsg_capped_extack); 247 ATF_TP_ADD_TC(tp, snl_parse_errmsg_uncapped_extack); 248 ATF_TP_ADD_TC(tp, snl_list_ifaces); 249 250 return (atf_no_error()); 251 } 252