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