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