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
require_netlink(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);
ATF_TC_HEAD(snl_verify_core_parsers,tc)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
ATF_TC_BODY(snl_verify_core_parsers,tc)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);
ATF_TC_HEAD(snl_verify_route_parsers,tc)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
ATF_TC_BODY(snl_verify_route_parsers,tc)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);
ATF_TC_HEAD(snl_parse_errmsg_capped,tc)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
ATF_TC_BODY(snl_parse_errmsg_capped,tc)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);
ATF_TC_HEAD(snl_parse_errmsg_capped_extack,tc)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
ATF_TC_BODY(snl_parse_errmsg_capped_extack,tc)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);
ATF_TC_HEAD(snl_parse_errmsg_uncapped_extack,tc)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
ATF_TC_BODY(snl_parse_errmsg_uncapped_extack,tc)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);
ATF_TC_HEAD(snl_list_ifaces,tc)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
ATF_TC_BODY(snl_list_ifaces,tc)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
ATF_TP_ADD_TCS(tp)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