sysctlgetmibinfo.c revision 1.15 1 /* $NetBSD: sysctlgetmibinfo.c,v 1.15 2022/04/19 20:32:15 rillig Exp $ */
2
3 /*-
4 * Copyright (c) 2003,2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Brown.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 #if defined(LIBC_SCCS) && !defined(lint)
34 __RCSID("$NetBSD: sysctlgetmibinfo.c,v 1.15 2022/04/19 20:32:15 rillig Exp $");
35 #endif /* LIBC_SCCS and not lint */
36
37 #ifndef RUMP_ACTION
38 #include "namespace.h"
39 #ifdef _REENTRANT
40 #include "reentrant.h"
41 #endif /* _REENTRANT */
42 #endif /* RUMP_ACTION */
43 #include <sys/param.h>
44 #include <sys/sysctl.h>
45
46 #include <assert.h>
47 #include <errno.h>
48 #include <inttypes.h>
49 #include <stdlib.h>
50 #include <string.h>
51
52 #ifdef RUMP_ACTION
53 #include <rump/rump_syscalls.h>
54 #define sysctl(a,b,c,d,e,f) rump_sys___sysctl(a,b,c,d,e,f)
55 #else
56 #ifdef __weak_alias
57 __weak_alias(__learn_tree,___learn_tree)
58 __weak_alias(sysctlgetmibinfo,_sysctlgetmibinfo)
59 #endif
60 #endif
61
62 /*
63 * the place where we attach stuff we learn on the fly, not
64 * necessarily used.
65 */
66 static struct sysctlnode sysctl_mibroot = {
67 #if defined(lint)
68 /*
69 * lint doesn't like my initializers
70 */
71 0
72 #else /* !lint */
73 .sysctl_flags = SYSCTL_VERSION|CTLFLAG_ROOT|CTLTYPE_NODE,
74 .sysctl_size = sizeof(struct sysctlnode),
75 .sysctl_name = "(root)",
76 #endif /* !lint */
77 };
78
79 /*
80 * routines to handle learning and cleanup
81 */
82 static int compar(const void *, const void *);
83 static void free_children(struct sysctlnode *);
84 static void relearnhead(void);
85
86 /*
87 * specifically not static since sysctl(8) "borrows" it.
88 */
89 int __learn_tree(int *, u_int, struct sysctlnode *);
90
91 /*
92 * for ordering nodes -- a query may or may not be given them in
93 * numeric order
94 */
95 static int
96 compar(const void *a, const void *b)
97 {
98
99 return (((const struct sysctlnode *)a)->sysctl_num -
100 ((const struct sysctlnode *)b)->sysctl_num);
101 }
102
103 /*
104 * recursively nukes a branch or an entire tree from the given node
105 */
106 static void
107 free_children(struct sysctlnode *rnode)
108 {
109 struct sysctlnode *node;
110
111 if (rnode == NULL ||
112 SYSCTL_TYPE(rnode->sysctl_flags) != CTLTYPE_NODE ||
113 rnode->sysctl_child == NULL)
114 return;
115
116 for (node = rnode->sysctl_child;
117 node < &rnode->sysctl_child[rnode->sysctl_clen];
118 node++) {
119 free_children(node);
120 }
121 free(rnode->sysctl_child);
122 rnode->sysctl_child = NULL;
123 }
124
125 /*
126 * verifies that the head of the tree in the kernel is the same as the
127 * head of the tree we already got, integrating new stuff and removing
128 * old stuff, if it's not.
129 */
130 static void
131 relearnhead(void)
132 {
133 struct sysctlnode *h, *i, *o, qnode;
134 size_t si, so;
135 int rc, name;
136 size_t nlen, olen, ni, oi;
137 uint32_t t;
138
139 /*
140 * if there's nothing there, there's no need to expend any
141 * effort
142 */
143 if (sysctl_mibroot.sysctl_child == NULL)
144 return;
145
146 /*
147 * attempt to pull out the head of the tree, starting with the
148 * size we have now, and looping if we need more (or less)
149 * space
150 */
151 si = 0;
152 so = sysctl_mibroot.sysctl_clen * sizeof(struct sysctlnode);
153 name = CTL_QUERY;
154 memset(&qnode, 0, sizeof(qnode));
155 qnode.sysctl_flags = SYSCTL_VERSION;
156 do {
157 si = so;
158 h = malloc(si);
159 rc = sysctl(&name, 1, h, &so, &qnode, sizeof(qnode));
160 if (rc == -1 && errno != ENOMEM)
161 return;
162 if (si < so)
163 free(h);
164 } while (si < so);
165
166 /*
167 * order the new copy of the head
168 */
169 nlen = so / sizeof(struct sysctlnode);
170 qsort(h, nlen, sizeof(struct sysctlnode), compar);
171
172 /*
173 * verify that everything is the same. if it is, we don't
174 * need to do any more work here.
175 */
176 olen = sysctl_mibroot.sysctl_clen;
177 rc = (nlen == olen) ? 0 : 1;
178 o = sysctl_mibroot.sysctl_child;
179 for (ni = 0; rc == 0 && ni < nlen; ni++) {
180 if (h[ni].sysctl_num != o[ni].sysctl_num ||
181 h[ni].sysctl_ver != o[ni].sysctl_ver)
182 rc = 1;
183 }
184 if (rc == 0) {
185 free(h);
186 return;
187 }
188
189 /*
190 * something changed. h will become the new head, and we need
191 * pull over any subtrees we already have if they're the same
192 * version.
193 */
194 i = h;
195 ni = oi = 0;
196 while (ni < nlen && oi < olen) {
197 /*
198 * something was inserted or deleted
199 */
200 if (SYSCTL_TYPE(i[ni].sysctl_flags) == CTLTYPE_NODE)
201 i[ni].sysctl_child = NULL;
202 if (i[ni].sysctl_num != o[oi].sysctl_num) {
203 if (i[ni].sysctl_num < o[oi].sysctl_num) {
204 ni++;
205 }
206 else {
207 free_children(&o[oi]);
208 oi++;
209 }
210 continue;
211 }
212
213 /*
214 * same number, but different version, so throw away
215 * any accumulated children
216 */
217 if (i[ni].sysctl_ver != o[oi].sysctl_ver)
218 free_children(&o[oi]);
219
220 /*
221 * this node is the same, but we only need to
222 * move subtrees.
223 */
224 else if (SYSCTL_TYPE(i[ni].sysctl_flags) == CTLTYPE_NODE) {
225 /*
226 * move subtree to new parent
227 */
228 i[ni].sysctl_clen = o[oi].sysctl_clen;
229 i[ni].sysctl_csize = o[oi].sysctl_csize;
230 i[ni].sysctl_child = o[oi].sysctl_child;
231 /*
232 * reparent inherited subtree
233 */
234 for (t = 0;
235 i[ni].sysctl_child != NULL &&
236 t < i[ni].sysctl_clen;
237 t++)
238 i[ni].sysctl_child[t].sysctl_parent = &i[ni];
239 }
240 ni++;
241 oi++;
242 }
243
244 /*
245 * left over new nodes need to have empty subtrees cleared
246 */
247 while (ni < nlen) {
248 if (SYSCTL_TYPE(i[ni].sysctl_flags) == CTLTYPE_NODE)
249 i[ni].sysctl_child = NULL;
250 ni++;
251 }
252
253 /*
254 * left over old nodes need to be cleaned out
255 */
256 while (oi < olen) {
257 free_children(&o[oi]);
258 oi++;
259 }
260
261 /*
262 * pop new head in
263 */
264 _DIAGASSERT(__type_fit(uint32_t, nlen));
265 sysctl_mibroot.sysctl_csize =
266 sysctl_mibroot.sysctl_clen = (uint32_t)nlen;
267 sysctl_mibroot.sysctl_child = h;
268 free(o);
269 }
270
271 /*
272 * sucks in the children at a given level and attaches it to the tree.
273 */
274 int
275 __learn_tree(int *name, u_int namelen, struct sysctlnode *pnode)
276 {
277 struct sysctlnode qnode;
278 uint32_t rc;
279 size_t sz;
280 int serrno;
281
282 if (pnode == NULL)
283 pnode = &sysctl_mibroot;
284 if (SYSCTL_TYPE(pnode->sysctl_flags) != CTLTYPE_NODE) {
285 errno = EINVAL;
286 return (-1);
287 }
288 if (pnode->sysctl_child != NULL)
289 return (0);
290
291 if (pnode->sysctl_clen == 0)
292 sz = SYSCTL_DEFSIZE * sizeof(struct sysctlnode);
293 else
294 sz = pnode->sysctl_clen * sizeof(struct sysctlnode);
295 pnode->sysctl_child = malloc(sz);
296 if (pnode->sysctl_child == NULL)
297 return (-1);
298
299 name[namelen] = CTL_QUERY;
300 pnode->sysctl_clen = 0;
301 pnode->sysctl_csize = 0;
302 memset(&qnode, 0, sizeof(qnode));
303 qnode.sysctl_flags = SYSCTL_VERSION;
304 rc = sysctl(name, namelen + 1, pnode->sysctl_child, &sz,
305 &qnode, sizeof(qnode));
306 if (sz == 0) {
307 serrno = errno;
308 free(pnode->sysctl_child);
309 errno = serrno;
310 pnode->sysctl_child = NULL;
311 return (rc);
312 }
313 if (rc) {
314 free(pnode->sysctl_child);
315 pnode->sysctl_child = NULL;
316 if ((sz % sizeof(struct sysctlnode)) != 0)
317 errno = EINVAL;
318 if (errno != ENOMEM)
319 return (rc);
320 }
321
322 if (pnode->sysctl_child == NULL) {
323 pnode->sysctl_child = malloc(sz);
324 if (pnode->sysctl_child == NULL)
325 return (-1);
326
327 rc = sysctl(name, namelen + 1, pnode->sysctl_child, &sz,
328 &qnode, sizeof(qnode));
329 if (rc) {
330 serrno = errno;
331 free(pnode->sysctl_child);
332 errno = serrno;
333 pnode->sysctl_child = NULL;
334 return (rc);
335 }
336 }
337
338 /*
339 * how many did we get?
340 */
341 sz /= sizeof(struct sysctlnode);
342 pnode->sysctl_csize = pnode->sysctl_clen = (uint32_t)sz;
343 if (pnode->sysctl_clen != sz) {
344 free(pnode->sysctl_child);
345 pnode->sysctl_child = NULL;
346 errno = EINVAL;
347 return (-1);
348 }
349
350 /*
351 * you know, the kernel doesn't really keep them in any
352 * particular order...just like entries in a directory
353 */
354 qsort(pnode->sysctl_child, pnode->sysctl_clen,
355 sizeof(struct sysctlnode), compar);
356
357 /*
358 * rearrange parent<->child linkage
359 */
360 for (rc = 0; rc < pnode->sysctl_clen; rc++) {
361 pnode->sysctl_child[rc].sysctl_parent = pnode;
362 if (SYSCTL_TYPE(pnode->sysctl_child[rc].sysctl_flags) ==
363 CTLTYPE_NODE) {
364 /*
365 * these nodes may have children, but we
366 * haven't discovered that yet.
367 */
368 pnode->sysctl_child[rc].sysctl_child = NULL;
369 }
370 pnode->sysctl_child[rc].sysctl_desc = NULL;
371 }
372
373 return (0);
374 }
375
376 /*
377 * that's "given name" as a string, the integer form of the name fit
378 * to be passed to sysctl(), "canonicalized name" (optional), and a
379 * pointer to the length of the integer form. oh, and then a pointer
380 * to the node, in case you (the caller) care. you can leave them all
381 * NULL except for gname, though that might be rather pointless,
382 * unless all you wanna do is verify that a given name is acceptable.
383 *
384 * returns either 0 (everything was fine) or -1 and sets errno
385 * accordingly. if errno is set to EAGAIN, we detected a change to
386 * the mib while parsing, and you should try again. in the case of an
387 * invalid node name, cname will be set to contain the offending name.
388 */
389 #if defined(_REENTRANT) && !defined(RUMP_ACTION)
390 static mutex_t sysctl_mutex = MUTEX_INITIALIZER;
391 static int sysctlgetmibinfo_unlocked(const char *, int *, u_int *, char *,
392 size_t *, struct sysctlnode **, int);
393 #endif /* __REENTRANT && !RUMP_ACTION */
394
395 int
396 sysctlgetmibinfo(const char *gname, int *iname, u_int *namelenp,
397 char *cname, size_t *csz, struct sysctlnode **rnode, int v)
398 #if defined(_REENTRANT) && !defined(RUMP_ACTION)
399 {
400 int rc;
401
402 mutex_lock(&sysctl_mutex);
403 rc = sysctlgetmibinfo_unlocked(gname, iname, namelenp, cname, csz,
404 rnode, v);
405 mutex_unlock(&sysctl_mutex);
406
407 return (rc);
408 }
409
410 static int
411 sysctlgetmibinfo_unlocked(const char *gname, int *iname, u_int *namelenp,
412 char *cname, size_t *csz, struct sysctlnode **rnode,
413 int v)
414 #endif /* _REENTRANT && !RUMP_ACTION */
415 {
416 struct sysctlnode *pnode, *node;
417 int name[CTL_MAXNAME], n, haven;
418 u_int ni, nl;
419 intmax_t q;
420 char sep[2], token[SYSCTL_NAMELEN],
421 pname[SYSCTL_NAMELEN * CTL_MAXNAME + CTL_MAXNAME];
422 const char *piece, *dot;
423 char *t;
424 size_t l;
425
426 if (rnode != NULL) {
427 if (*rnode == NULL) {
428 /* XXX later deal with dealing back a sub version */
429 if (v != SYSCTL_VERSION) {
430 errno = EINVAL;
431 return -1;
432 }
433
434 pnode = &sysctl_mibroot;
435 }
436 else {
437 /* this is just someone being silly */
438 if (SYSCTL_VERS((*rnode)->sysctl_flags)
439 != (uint32_t)v) {
440 errno = EINVAL;
441 return -1;
442 }
443
444 /* XXX later deal with other people's trees */
445 if (SYSCTL_VERS((*rnode)->sysctl_flags) !=
446 SYSCTL_VERSION) {
447 errno = EINVAL;
448 return -1;
449 }
450
451 pnode = *rnode;
452 }
453 }
454 else
455 pnode = &sysctl_mibroot;
456
457 if (pnode == &sysctl_mibroot)
458 relearnhead();
459
460 nl = ni = 0;
461 token[0] = '\0';
462 pname[0] = '\0';
463 node = NULL;
464
465 /*
466 * default to using '.' as the separator, but allow '/' as
467 * well, and then allow a leading separator
468 */
469 if ((dot = strpbrk(gname, "./")) == NULL)
470 sep[0] = '.';
471 else
472 sep[0] = dot[0];
473 sep[1] = '\0';
474 if (gname[0] == sep[0]) {
475 strlcat(pname, sep, sizeof(pname));
476 gname++;
477 }
478
479 #define COPY_OUT_DATA(t, c, cs, nlp, l) do { \
480 if ((c) != NULL && (cs) != NULL) \
481 *(cs) = strlcpy((c), (t), *(cs)); \
482 else if ((cs) != NULL) \
483 *(cs) = strlen(t) + 1; \
484 if ((nlp) != NULL) \
485 *(nlp) = (l); \
486 } while (0)
487
488 piece = gname;
489 while (piece != NULL && *piece != '\0') {
490 /*
491 * what was i looking for?
492 */
493 dot = strchr(piece, sep[0]);
494 if (dot == NULL) {
495 l = strlcpy(token, piece, sizeof(token));
496 if (l > sizeof(token)) {
497 COPY_OUT_DATA(piece, cname, csz, namelenp, nl);
498 errno = ENAMETOOLONG;
499 return (-1);
500 }
501 }
502 else if (dot - piece > (intptr_t)(sizeof(token) - 1)) {
503 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
504 errno = ENAMETOOLONG;
505 return (-1);
506 }
507 else {
508 strncpy(token, piece, (size_t)(dot - piece));
509 token[dot - piece] = '\0';
510 }
511
512 /*
513 * i wonder if this "token" is an integer?
514 */
515 errno = 0;
516 q = strtoimax(token, &t, 0);
517 n = (int)q;
518 if (errno != 0 || *t != '\0')
519 haven = 0;
520 else if (q < INT_MIN || q > UINT_MAX)
521 haven = 0;
522 else
523 haven = 1;
524
525 /*
526 * make sure i have something to look at
527 */
528 if (SYSCTL_TYPE(pnode->sysctl_flags) != CTLTYPE_NODE) {
529 if (haven && nl > 0) {
530 strlcat(pname, sep, sizeof(pname));
531 goto just_numbers;
532 }
533 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
534 errno = ENOTDIR;
535 return (-1);
536 }
537 if (pnode->sysctl_child == NULL) {
538 if (__learn_tree(name, nl, pnode) == -1) {
539 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
540 return (-1);
541 }
542 }
543 node = pnode->sysctl_child;
544 if (node == NULL) {
545 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
546 errno = ENOENT;
547 return (-1);
548 }
549
550 /*
551 * now...is it there?
552 */
553 for (ni = 0; ni < pnode->sysctl_clen; ni++)
554 if ((haven && ((n == node[ni].sysctl_num) ||
555 (node[ni].sysctl_flags & CTLFLAG_ANYNUMBER))) ||
556 strcmp(token, node[ni].sysctl_name) == 0)
557 break;
558 if (ni >= pnode->sysctl_clen) {
559 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
560 errno = ENOENT;
561 return (-1);
562 }
563
564 /*
565 * ah...it is.
566 */
567 pnode = &node[ni];
568 if (nl > 0)
569 strlcat(pname, sep, sizeof(pname));
570 if (haven && n != pnode->sysctl_num) {
571 just_numbers:
572 strlcat(pname, token, sizeof(pname));
573 name[nl] = n;
574 }
575 else {
576 strlcat(pname, pnode->sysctl_name, sizeof(pname));
577 name[nl] = pnode->sysctl_num;
578 }
579 piece = (dot != NULL) ? dot + 1 : NULL;
580 nl++;
581 if (nl == CTL_MAXNAME) {
582 COPY_OUT_DATA(token, cname, csz, namelenp, nl);
583 errno = ERANGE;
584 return (-1);
585 }
586 }
587
588 if (nl == 0) {
589 if (namelenp != NULL)
590 *namelenp = 0;
591 errno = EINVAL;
592 return (-1);
593 }
594
595 COPY_OUT_DATA(pname, cname, csz, namelenp, nl);
596 if (iname != NULL && namelenp != NULL)
597 memcpy(iname, &name[0], MIN(nl, *namelenp) * sizeof(int));
598 if (namelenp != NULL)
599 *namelenp = nl;
600 if (rnode != NULL) {
601 if (*rnode != NULL)
602 /*
603 * they gave us a private tree to work in, so
604 * we give back a pointer into that private
605 * tree
606 */
607 *rnode = pnode;
608 else {
609 /*
610 * they gave us a place to put the node data,
611 * so give them a copy
612 */
613 *rnode = malloc(sizeof(struct sysctlnode));
614 if (*rnode != NULL) {
615 **rnode = *pnode;
616 (*rnode)->sysctl_child = NULL;
617 (*rnode)->sysctl_parent = NULL;
618 }
619 }
620 }
621
622 return (0);
623 }
624