1 /*
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright 2023 Baptiste Daroussin <bapt@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted providing that the following conditions~
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
24 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/param.h>
29 #include <sys/module.h>
30 #include <sys/socket.h>
31
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <err.h>
36 #include <stdio.h>
37 #include <poll.h>
38
39 #include <netlink/netlink.h>
40 #include <netlink/netlink_generic.h>
41 #include <netlink/netlink_snl.h>
42 #include <netlink/netlink_snl_generic.h>
43 #include <netlink/netlink_sysevent.h>
44
45 static int monitor_mcast(int argc, char **argv);
46 static int list_families(int argc, char **argv);
47 static void parser_nlctrl_notify(struct snl_state *ss, struct nlmsghdr *hdr);
48 static void parser_nlsysevent(struct snl_state *ss, struct nlmsghdr *hdr);
49 static void parser_fallback(struct snl_state *ss, struct nlmsghdr *hdr);
50
51 static struct commands {
52 const char *name;
53 const char *usage;
54 int (*cmd)(int argc, char **argv);
55 } cmds[] = {
56 { "monitor", "monitor <family> [multicast group]", monitor_mcast },
57 { "list", "list", list_families },
58 };
59
60 static struct mcast_parsers {
61 const char *family;
62 void (*parser)(struct snl_state *ss, struct nlmsghdr *hdr);
63 } mcast_parsers [] = {
64 { "nlctrl", parser_nlctrl_notify },
65 { "nlsysevent", parser_nlsysevent },
66 };
67
68 struct nlevent {
69 const char *name;
70 const char *subsystem;
71 const char *type;
72 const char *data;
73 };
74 #define _OUT(_field) offsetof(struct nlevent, _field)
75 static struct snl_attr_parser ap_nlevent_get[] = {
76 { .type = NLSE_ATTR_SYSTEM, .off = _OUT(name), .cb = snl_attr_get_string },
77 { .type = NLSE_ATTR_SUBSYSTEM, .off = _OUT(subsystem), .cb = snl_attr_get_string },
78 { .type = NLSE_ATTR_TYPE, .off = _OUT(type), .cb = snl_attr_get_string },
79 { .type = NLSE_ATTR_DATA, .off = _OUT(data), .cb = snl_attr_get_string },
80 };
81 #undef _OUT
82 SNL_DECLARE_GENL_PARSER(nlevent_get_parser, ap_nlevent_get);
83
84 struct genl_ctrl_op {
85 uint32_t id;
86 uint32_t flags;
87 };
88
89 struct genl_ctrl_ops {
90 uint32_t num_ops;
91 struct genl_ctrl_op **ops;
92 };
93
94 #define _OUT(_field) offsetof(struct genl_ctrl_op, _field)
95 static struct snl_attr_parser _nla_p_getops[] = {
96 { .type = CTRL_ATTR_OP_ID, .off = _OUT(id), .cb = snl_attr_get_uint32},
97 { .type = CTRL_ATTR_OP_FLAGS, .off = _OUT(flags), .cb = snl_attr_get_uint32 },
98 };
99 #undef _OUT
100 SNL_DECLARE_ATTR_PARSER_EXT(genl_ctrl_op_parser,
101 sizeof(struct genl_ctrl_op),
102 _nla_p_getops, NULL);
103
104 struct genl_family {
105 uint16_t id;
106 char *name;
107 uint32_t version;
108 uint32_t hdrsize;
109 uint32_t max_attr;
110 struct snl_genl_ctrl_mcast_groups mcast_groups;
111 struct genl_ctrl_ops ops;
112 };
113
114 #define _OUT(_field) offsetof(struct genl_family, _field)
115 static struct snl_attr_parser _nla_p_getfamily[] = {
116 { .type = CTRL_ATTR_FAMILY_ID , .off = _OUT(id), .cb = snl_attr_get_uint16 },
117 { .type = CTRL_ATTR_FAMILY_NAME, .off = _OUT(name), .cb = snl_attr_get_string },
118 { .type = CTRL_ATTR_VERSION, .off = _OUT(version), .cb = snl_attr_get_uint32 },
119 { .type = CTRL_ATTR_VERSION, .off = _OUT(hdrsize), .cb = snl_attr_get_uint32 },
120 { .type = CTRL_ATTR_MAXATTR, .off = _OUT(max_attr), .cb = snl_attr_get_uint32 },
121 {
122 .type = CTRL_ATTR_OPS,
123 .off = _OUT(ops),
124 .cb = snl_attr_get_parray,
125 .arg = &genl_ctrl_op_parser,
126 },
127 {
128 .type = CTRL_ATTR_MCAST_GROUPS,
129 .off = _OUT(mcast_groups),
130 .cb = snl_attr_get_parray,
131 .arg = &_genl_ctrl_mc_parser,
132 },
133 };
134 #undef _OUT
135 SNL_DECLARE_GENL_PARSER(genl_family_parser, _nla_p_getfamily);
136
137 static struct op_capability {
138 uint32_t flag;
139 const char *str;
140 } op_caps[] = {
141 { GENL_ADMIN_PERM, "requires admin permission" },
142 { GENL_CMD_CAP_DO, "can modify" },
143 { GENL_CMD_CAP_DUMP, "can get/dump" },
144 { GENL_CMD_CAP_HASPOL, "has policy" },
145 };
146
147 static void
dump_operations(struct genl_ctrl_ops * ops)148 dump_operations(struct genl_ctrl_ops *ops)
149 {
150 if (ops->num_ops == 0)
151 return;
152 printf("\tsupported operations: \n");
153 for (uint32_t i = 0; i < ops->num_ops; i++) {
154 printf("\t - ID: %#02x, Capabilities: %#02x (",
155 ops->ops[i]->id,
156 ops->ops[i]->flags);
157 for (size_t j = 0; j < nitems(op_caps); j++)
158 if ((ops->ops[i]->flags & op_caps[j].flag) == op_caps[j].flag)
159 printf("%s; ", op_caps[j].str);
160 printf("\b\b)\n");
161 }
162 }
163
164 static void
dump_mcast_groups(struct snl_genl_ctrl_mcast_groups * mcast_groups)165 dump_mcast_groups( struct snl_genl_ctrl_mcast_groups *mcast_groups)
166 {
167 if (mcast_groups->num_groups == 0)
168 return;
169 printf("\tmulticast groups: \n");
170 for (uint32_t i = 0; i < mcast_groups->num_groups; i++)
171 printf("\t - ID: %#02x, Name: %s\n",
172 mcast_groups->groups[i]->mcast_grp_id,
173 mcast_groups->groups[i]->mcast_grp_name);
174 }
175
176 static void
usage(void)177 usage(void)
178 {
179 fprintf(stderr, "Usage: %s\n", getprogname());
180 for (size_t i = 0; i < nitems(cmds); i++)
181 fprintf(stderr, " %s %s\n", getprogname(), cmds[i].usage);
182 }
183
184 static void
dump_family(struct genl_family * family)185 dump_family(struct genl_family *family)
186 {
187 printf("Name: %s\n\tID: %#02hx, Version: %#02x, "
188 "header size: %d, max attributes: %d\n",
189 family->name, family->id, family->version,
190 family->hdrsize, family->max_attr);
191 dump_operations(&family->ops);
192 dump_mcast_groups(&family->mcast_groups);
193 }
194
195 void
parser_nlctrl_notify(struct snl_state * ss,struct nlmsghdr * hdr)196 parser_nlctrl_notify(struct snl_state *ss, struct nlmsghdr *hdr)
197 {
198 struct genl_family family = {};
199
200 if (snl_parse_nlmsg(ss, hdr, &genl_family_parser,
201 &family))
202 dump_family(&family);
203 }
204
205 void
parser_nlsysevent(struct snl_state * ss,struct nlmsghdr * hdr)206 parser_nlsysevent(struct snl_state *ss, struct nlmsghdr *hdr)
207 {
208 struct nlevent ne = {};
209 if (snl_parse_nlmsg(ss, hdr, &nlevent_get_parser, &ne)) {
210 printf("system=%s subsystem=%s type=%s", ne.name, ne.subsystem, ne.type);
211 if (ne.data) {
212 printf(" %s", ne.data);
213 if (ne.data[strlen(ne.data) -1] != '\n')
214 printf("\n");
215 }
216 }
217 }
218
219 void
parser_fallback(struct snl_state * ss __unused,struct nlmsghdr * hdr __unused)220 parser_fallback(struct snl_state *ss __unused, struct nlmsghdr *hdr __unused)
221 {
222 printf("New unknown message\n");
223 }
224
225 int
monitor_mcast(int argc __unused,char ** argv)226 monitor_mcast(int argc __unused, char **argv)
227 {
228 struct snl_state ss;
229 struct nlmsghdr *hdr;
230 struct _getfamily_attrs attrs;
231 struct pollfd pfd;
232 bool found = false;
233 bool all = false;
234 void (*parser)(struct snl_state *ss, struct nlmsghdr *hdr);
235
236 parser = parser_fallback;
237
238 if (!snl_init(&ss, NETLINK_GENERIC))
239 err(EXIT_FAILURE, "snl_init()");
240
241 if (argc < 1 || argc > 2) {
242 usage();
243 return (EXIT_FAILURE);
244 }
245
246 if (!snl_get_genl_family_info(&ss, argv[0], &attrs))
247 errx(EXIT_FAILURE, "Unknown family '%s'", argv[0]);
248 if (argc == 1)
249 all = true;
250 for (unsigned int i = 0; i < attrs.mcast_groups.num_groups; i++) {
251 if (all || strcmp(attrs.mcast_groups.groups[i]->mcast_grp_name,
252 argv[1]) == 0) {
253 found = true;
254 if (setsockopt(ss.fd, SOL_NETLINK,
255 NETLINK_ADD_MEMBERSHIP,
256 &attrs.mcast_groups.groups[i]->mcast_grp_id,
257 sizeof(attrs.mcast_groups.groups[i]->mcast_grp_id))
258 == -1)
259 err(EXIT_FAILURE, "Cannot subscribe to command "
260 "notify");
261 if (!all)
262 break;
263 }
264 }
265 if (!found)
266 errx(EXIT_FAILURE, "No such multicast group '%s'"
267 " in family '%s'", argv[1], argv[0]);
268 for (size_t i= 0; i < nitems(mcast_parsers); i++) {
269 if (strcmp(mcast_parsers[i].family, argv[0]) == 0) {
270 parser = mcast_parsers[i].parser;
271 break;
272 }
273 }
274 memset(&pfd, 0, sizeof(pfd));
275 pfd.fd = ss.fd;
276 pfd.events = POLLIN | POLLERR;
277 while (true) {
278 pfd.revents = 0;
279 if (poll(&pfd, 1, -1) == -1) {
280 if (errno == EINTR)
281 continue;
282 err(EXIT_FAILURE, "poll()");
283 }
284 hdr = snl_read_message(&ss);
285 if (hdr != NULL && hdr->nlmsg_type != NLMSG_ERROR)
286 parser(&ss, hdr);
287
288 }
289
290 return (EXIT_SUCCESS);
291 }
292
293 int
list_families(int argc,char ** argv __unused)294 list_families(int argc, char **argv __unused)
295 {
296 struct snl_state ss;
297 struct snl_writer nw;
298 struct nlmsghdr *hdr;
299 struct snl_errmsg_data e = {};
300 uint32_t seq_id;
301
302 if (argc != 0) {
303 usage();
304 return (EXIT_FAILURE);
305 }
306 if (!snl_init(&ss, NETLINK_GENERIC))
307 err(EXIT_FAILURE, "snl_init()");
308
309 snl_init_writer(&ss, &nw);
310 hdr = snl_create_genl_msg_request(&nw, GENL_ID_CTRL,
311 CTRL_CMD_GETFAMILY);
312 if ((hdr = snl_finalize_msg(&nw)) == NULL)
313 err(EXIT_FAILURE, "snl_finalize_msg");
314 seq_id = hdr->nlmsg_seq;
315 if (!snl_send_message(&ss, hdr))
316 err(EXIT_FAILURE, "snl_send_message");
317
318 while ((hdr = snl_read_reply_multi(&ss, seq_id, &e)) != NULL) {
319 if (e.error != 0) {
320 err(EXIT_FAILURE, "Error reading generic netlink");
321 }
322 struct genl_family family = {};
323 if (snl_parse_nlmsg(&ss, hdr, &genl_family_parser, &family))
324 dump_family(&family);
325 }
326
327 return (EXIT_SUCCESS);
328 }
329
330 int
main(int argc,char ** argv)331 main(int argc, char **argv)
332 {
333 if (modfind("netlink") == -1)
334 err(EXIT_FAILURE, "require netlink module to be loaded");
335
336 if (argc == 1)
337 return (list_families(0, NULL));
338
339 for (size_t i = 0; i < nitems(cmds); i++) {
340 if (strcmp(argv[1], cmds[i].name) == 0)
341 return (cmds[i].cmd(argc - 2, argv + 2));
342 }
343 usage();
344
345 return (EXIT_FAILURE);
346 }
347