1 /* $NetBSD: sysctlfs.c,v 1.21 2023/04/02 18:23:02 ryo Exp $ */
2
3 /*-
4 * Copyright (c) 2006, 2007 Antti Kantee. All Rights Reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided 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
16 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 /*
29 * sysctlfs: mount sysctls as a file system tree. Supports query and
30 * modify of nodes in the sysctl namespace in addition to namespace
31 * traversal.
32 */
33
34 #include <sys/cdefs.h>
35 #ifndef lint
36 __RCSID("$NetBSD: sysctlfs.c,v 1.21 2023/04/02 18:23:02 ryo Exp $");
37 #endif /* !lint */
38
39 #include <sys/types.h>
40 #include <sys/sysctl.h>
41
42 #include <stdio.h>
43 #include <assert.h>
44 #include <err.h>
45 #include <errno.h>
46 #include <mntopts.h>
47 #include <paths.h>
48 #include <puffs.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <unistd.h>
52 #include <util.h>
53
54 #ifdef RUMP_ACTION
55 #include <rump/rump.h>
56 #include <rump/rump_syscalls.h>
57
58 #define sysctl(a,b,c,d,e,f) rump_sys___sysctl(a,b,c,d,e,f)
59 #endif
60
61 PUFFSOP_PROTOS(sysctlfs)
62
63 struct sfsnode {
64 int sysctl_flags;
65 ino_t myid;
66 };
67
68 #define SFSPATH_DOTDOT 0
69 #define SFSPATH_NORMAL 1
70
71 #define N_HIERARCHY 10
72 typedef int SfsName[N_HIERARCHY];
73
74 struct sfsfid {
75 int len;
76 SfsName path;
77 };
78
79 static struct sfsnode rn;
80 static SfsName sname_root;
81 static struct timespec fstime;
82
83 static ino_t nextid = 3;
84 static mode_t fileperms;
85 static uid_t fileuid;
86 static gid_t filegid;
87
88 static int rflag;
89
90 #define ISADIR(a) ((SYSCTL_TYPE(a->sysctl_flags) == CTLTYPE_NODE))
91 #define SFS_MAXFILE 32768
92 #define SFS_NODEPERDIR 128
93
94 static int sysctlfs_domount(struct puffs_usermount *);
95
96 /*
97 * build paths. doesn't support rename (but neither does the fs)
98 */
99 static int
sysctlfs_pathbuild(struct puffs_usermount * pu,const struct puffs_pathobj * parent,const struct puffs_pathobj * comp,size_t offset,struct puffs_pathobj * res)100 sysctlfs_pathbuild(struct puffs_usermount *pu,
101 const struct puffs_pathobj *parent, const struct puffs_pathobj *comp,
102 size_t offset, struct puffs_pathobj *res)
103 {
104 SfsName *sname;
105 size_t clen;
106
107 assert(parent->po_len < N_HIERARCHY); /* code uses +1 */
108
109 sname = malloc(sizeof(SfsName));
110 assert(sname != NULL);
111
112 clen = parent->po_len;
113 if (comp->po_len == SFSPATH_DOTDOT) {
114 assert(clen != 0);
115 clen--;
116 }
117
118 memcpy(sname, parent->po_path, clen * sizeof(int));
119
120 res->po_path = sname;
121 res->po_len = clen;
122
123 return 0;
124 }
125
126 static int
sysctlfs_pathtransform(struct puffs_usermount * pu,const struct puffs_pathobj * p,const struct puffs_cn * pcn,struct puffs_pathobj * res)127 sysctlfs_pathtransform(struct puffs_usermount *pu,
128 const struct puffs_pathobj *p, const struct puffs_cn *pcn,
129 struct puffs_pathobj *res)
130 {
131
132 res->po_path = NULL;
133 /*
134 * XXX: overload. prevents us from doing rename, but the fs
135 * (and sysctl(3)) doesn't support it, so no biggie
136 */
137 if (PCNISDOTDOT(pcn)) {
138 res->po_len = SFSPATH_DOTDOT;
139 }else {
140 res->po_len = SFSPATH_NORMAL;
141 }
142
143 return 0;
144 }
145
146 static int
sysctlfs_pathcmp(struct puffs_usermount * pu,struct puffs_pathobj * po1,struct puffs_pathobj * po2,size_t clen,int checkprefix)147 sysctlfs_pathcmp(struct puffs_usermount *pu, struct puffs_pathobj *po1,
148 struct puffs_pathobj *po2, size_t clen, int checkprefix)
149 {
150
151 if (memcmp(po1->po_path, po2->po_path, clen * sizeof(int)) == 0)
152 return 0;
153 return 1;
154 }
155
156 static void
sysctlfs_pathfree(struct puffs_usermount * pu,struct puffs_pathobj * po)157 sysctlfs_pathfree(struct puffs_usermount *pu, struct puffs_pathobj *po)
158 {
159
160 free(po->po_path);
161 }
162
163 static struct puffs_node *
getnode(struct puffs_usermount * pu,struct puffs_pathobj * po,int nodetype)164 getnode(struct puffs_usermount *pu, struct puffs_pathobj *po, int nodetype)
165 {
166 struct sysctlnode sn[SFS_NODEPERDIR];
167 struct sysctlnode qnode;
168 struct puffs_node *pn;
169 struct sfsnode *sfs;
170 SfsName myname, *sname;
171 size_t sl, i;
172
173 /*
174 * Check if we need to create a new in-memory node or if we
175 * already have one for this path. Shortcut for the rootnode.
176 * Also, memcmp against zero-length would be quite true always.
177 */
178 if (po->po_len == 0)
179 pn = puffs_getroot(pu);
180 else
181 pn = puffs_pn_nodewalk(pu, puffs_path_walkcmp, po);
182
183 if (pn != NULL)
184 return pn;
185 /*
186 * don't know nodetype? query...
187 *
188 * XXX1: nothing really guarantees 0 is an invalid nodetype
189 * XXX2: is there really no easier way of doing this? we
190 * know the whole mib path
191 */
192 if (!nodetype) {
193 sname = po->po_path;
194 memcpy(myname, po->po_path, po->po_len * sizeof(myname[0]));
195
196 memset(&qnode, 0, sizeof(qnode));
197 qnode.sysctl_flags = SYSCTL_VERSION;
198 myname[po->po_len-1] = CTL_QUERY;
199
200 sl = sizeof(sn);
201 if (sysctl(myname, po->po_len, sn, &sl,
202 &qnode, sizeof(qnode)) == -1)
203 abort();
204
205 for (i = 0; i < sl / sizeof(struct sysctlnode); i++) {
206 if (sn[i].sysctl_num == (*sname)[po->po_len-1]) {
207 nodetype = sn[i].sysctl_flags;
208 break;
209 }
210 }
211 if (!nodetype)
212 return NULL;
213 }
214
215 sfs = emalloc(sizeof(*sfs));
216 sfs->sysctl_flags = nodetype;
217 sfs->myid = nextid++;
218
219 pn = puffs_pn_new(pu, sfs);
220 assert(pn);
221
222 return pn;
223 }
224
225 static void __dead
usage(void)226 usage(void)
227 {
228
229 fprintf(stderr, "Usage: %s [-o <mntopts>] sysctlfs mountpath\n",
230 getprogname());
231 exit(1);
232 }
233
234 int
main(int argc,char * argv[])235 main(int argc, char *argv[])
236 {
237 struct puffs_usermount *pu;
238 struct puffs_ops *pops;
239 mntoptparse_t mp;
240 int mntflags, pflags;
241 int detach;
242 int ch;
243
244 setprogname(argv[0]);
245
246 if (argc < 2)
247 usage();
248
249 mntflags = pflags = 0;
250 detach = 1;
251 while ((ch = getopt(argc, argv, "o:rs")) != -1) {
252 switch (ch) {
253 case 'o':
254 mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
255 if (mp == NULL)
256 err(EXIT_FAILURE, "getmntopts");
257 freemntopts(mp);
258 break;
259 case 'r':
260 rflag = 1;
261 break;
262 case 's':
263 detach = 0;
264 break;
265 }
266 }
267 argv += optind;
268 argc -= optind;
269 pflags |= PUFFS_FLAG_BUILDPATH | PUFFS_KFLAG_NOCACHE;
270
271 if (pflags & PUFFS_FLAG_OPDUMP)
272 detach = 0;
273
274 if (argc != 2)
275 usage();
276
277 PUFFSOP_INIT(pops);
278
279 PUFFSOP_SETFSNOP(pops, unmount);
280 PUFFSOP_SETFSNOP(pops, sync);
281 PUFFSOP_SETFSNOP(pops, statvfs);
282 PUFFSOP_SET(pops, sysctlfs, fs, nodetofh);
283 PUFFSOP_SET(pops, sysctlfs, fs, fhtonode);
284
285 PUFFSOP_SET(pops, sysctlfs, node, lookup);
286 PUFFSOP_SET(pops, sysctlfs, node, getattr);
287 PUFFSOP_SET(pops, sysctlfs, node, setattr);
288 PUFFSOP_SET(pops, sysctlfs, node, readdir);
289 PUFFSOP_SET(pops, sysctlfs, node, read);
290 PUFFSOP_SET(pops, sysctlfs, node, write);
291 PUFFSOP_SET(pops, puffs_genfs, node, reclaim);
292
293 pu = puffs_init(pops, _PATH_PUFFS, "sysctlfs", NULL, pflags);
294 if (pu == NULL)
295 err(EXIT_FAILURE, "puffs_init");
296
297 puffs_set_pathbuild(pu, sysctlfs_pathbuild);
298 puffs_set_pathtransform(pu, sysctlfs_pathtransform);
299 puffs_set_pathcmp(pu, sysctlfs_pathcmp);
300 puffs_set_pathfree(pu, sysctlfs_pathfree);
301
302 puffs_setfhsize(pu, sizeof(struct sfsfid), PUFFS_FHFLAG_NFSV3);
303
304 if (sysctlfs_domount(pu) != 0)
305 errx(EXIT_FAILURE, "domount");
306
307 if (detach)
308 if (puffs_daemon(pu, 1, 1) == -1)
309 err(EXIT_FAILURE, "puffs_daemon");
310
311 #ifdef RUMP_ACTION
312 {
313 extern int puffs_fakecc;
314 puffs_fakecc = 1;
315 rump_init();
316 }
317 #endif
318
319 if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
320 err(EXIT_FAILURE, "puffs_mount");
321 if (puffs_mainloop(pu) == -1)
322 err(EXIT_FAILURE, "mainloop");
323
324 return 0;
325 }
326
327 static int
sysctlfs_domount(struct puffs_usermount * pu)328 sysctlfs_domount(struct puffs_usermount *pu)
329 {
330 struct puffs_pathobj *po_root;
331 struct puffs_node *pn_root;
332 struct timeval tv_now;
333
334 rn.myid = 2;
335 rn.sysctl_flags = CTLTYPE_NODE;
336
337 gettimeofday(&tv_now, NULL);
338 TIMEVAL_TO_TIMESPEC(&tv_now, &fstime);
339
340 pn_root = puffs_pn_new(pu, &rn);
341 assert(pn_root != NULL);
342 puffs_setroot(pu, pn_root);
343
344 po_root = puffs_getrootpathobj(pu);
345 po_root->po_path = &sname_root;
346 po_root->po_len = 0;
347
348 fileuid = geteuid();
349 filegid = getegid();
350
351 if (fileuid == 0)
352 fileperms = 0644;
353 else
354 fileperms = 0444;
355
356 return 0;
357 }
358
359 int
sysctlfs_fs_fhtonode(struct puffs_usermount * pu,void * fid,size_t fidsize,struct puffs_newinfo * pni)360 sysctlfs_fs_fhtonode(struct puffs_usermount *pu, void *fid, size_t fidsize,
361 struct puffs_newinfo *pni)
362 {
363 struct puffs_pathobj po;
364 struct puffs_node *pn;
365 struct sfsnode *sfs;
366 struct sfsfid *sfid;
367
368 sfid = fid;
369
370 po.po_len = sfid->len;
371 po.po_path = &sfid->path;
372
373 pn = getnode(pu, &po, 0);
374 if (pn == NULL)
375 return EINVAL;
376 sfs = pn->pn_data;
377
378 puffs_newinfo_setcookie(pni, pn);
379 if (ISADIR(sfs))
380 puffs_newinfo_setvtype(pni, VDIR);
381 else
382 puffs_newinfo_setvtype(pni, VREG);
383
384 return 0;
385 }
386
387 int
sysctlfs_fs_nodetofh(struct puffs_usermount * pu,void * cookie,void * fid,size_t * fidsize)388 sysctlfs_fs_nodetofh(struct puffs_usermount *pu, void *cookie,
389 void *fid, size_t *fidsize)
390 {
391 struct puffs_node *pn = cookie;
392 struct sfsfid *sfid;
393
394 sfid = fid;
395 sfid->len = PNPLEN(pn);
396 memcpy(&sfid->path, PNPATH(pn), sfid->len * sizeof(int));
397
398 return 0;
399 }
400
401 static void
getnodedata(struct sfsnode * sfs,struct puffs_pathobj * po,char * buf,size_t * bufsize)402 getnodedata(struct sfsnode *sfs, struct puffs_pathobj *po,
403 char *buf, size_t *bufsize)
404 {
405 size_t sz;
406 int error = 0;
407
408 assert(!ISADIR(sfs));
409
410 memset(buf, 0, *bufsize);
411 switch (SYSCTL_TYPE(sfs->sysctl_flags)) {
412 case CTLTYPE_BOOL: {
413 bool b;
414 sz = sizeof(bool);
415 assert(sz <= *bufsize);
416 if (sysctl(po->po_path, po->po_len, &b, &sz, NULL, 0) == -1) {
417 error = errno;
418 break;
419 }
420 if (rflag)
421 memcpy(buf, &b, sz);
422 else
423 snprintf(buf, *bufsize, "%s", b ? "true" : "false");
424 break;
425 }
426 case CTLTYPE_INT: {
427 int i;
428 sz = sizeof(int);
429 assert(sz <= *bufsize);
430 if (sysctl(po->po_path, po->po_len, &i, &sz, NULL, 0) == -1) {
431 error = errno;
432 break;
433 }
434 if (rflag)
435 memcpy(buf, &i, sz);
436 else
437 snprintf(buf, *bufsize, "%d", i);
438 break;
439 }
440 case CTLTYPE_QUAD: {
441 quad_t q;
442 sz = sizeof(q);
443 assert(sz <= *bufsize);
444 if (sysctl(po->po_path, po->po_len, &q, &sz, NULL, 0) == -1) {
445 error = errno;
446 break;
447 }
448 if (rflag)
449 memcpy(buf, &q, sz);
450 else
451 snprintf(buf, *bufsize, "%" PRId64, q);
452 break;
453 }
454 case CTLTYPE_STRUCT: {
455 uint8_t snode[SFS_MAXFILE/2-1];
456 unsigned i;
457
458 sz = sizeof(snode);
459 assert(sz <= *bufsize);
460 if (sysctl(po->po_path, po->po_len, snode, &sz, NULL, 0) == -1){
461 error = errno;
462 break;
463 }
464 if (rflag) {
465 memcpy(buf, &snode, sz);
466 } else {
467 for (i = 0; i < sz && 2*i < *bufsize; i++) {
468 sprintf(&buf[2*i], "%02x", snode[i]);
469 }
470 buf[2*i] = '\0';
471 }
472 break;
473 }
474 case CTLTYPE_STRING: {
475 sz = *bufsize;
476 assert(sz <= *bufsize);
477 if (sysctl(po->po_path, po->po_len, buf, &sz, NULL, 0) == -1) {
478 error = errno;
479 break;
480 }
481 break;
482 }
483 default:
484 snprintf(buf, *bufsize, "invalid sysctl CTLTYPE %d",
485 SYSCTL_TYPE(sfs->sysctl_flags));
486 break;
487 }
488
489 if (error) {
490 *bufsize = 0;
491 return;
492 }
493
494 if (rflag)
495 *bufsize = sz;
496 else
497 *bufsize = strlen(buf);
498 }
499
500 static int
getlinks(struct sfsnode * sfs,struct puffs_pathobj * po)501 getlinks(struct sfsnode *sfs, struct puffs_pathobj *po)
502 {
503 struct sysctlnode sn[SFS_NODEPERDIR];
504 struct sysctlnode qnode;
505 SfsName *sname;
506 size_t sl;
507
508 if (!ISADIR(sfs))
509 return 1;
510
511 memset(&qnode, 0, sizeof(qnode));
512 sl = sizeof(sn);
513 qnode.sysctl_flags = SYSCTL_VERSION;
514 sname = po->po_path;
515 (*sname)[po->po_len] = CTL_QUERY;
516
517 if (sysctl(*sname, po->po_len + 1, sn, &sl,
518 &qnode, sizeof(qnode)) == -1)
519 return 0;
520
521 return (sl / sizeof(sn[0])) + 2;
522 }
523
524 static int
getsize(struct sfsnode * sfs,struct puffs_pathobj * po)525 getsize(struct sfsnode *sfs, struct puffs_pathobj *po)
526 {
527 char buf[SFS_MAXFILE];
528 size_t sz = sizeof(buf);
529
530 if (ISADIR(sfs))
531 return getlinks(sfs, po) * 16; /* totally arbitrary */
532
533 getnodedata(sfs, po, buf, &sz);
534 if (rflag)
535 return sz;
536 else
537 return sz + 1; /* for \n, not \0 */
538 }
539
540 int
sysctlfs_node_lookup(struct puffs_usermount * pu,void * opc,struct puffs_newinfo * pni,const struct puffs_cn * pcn)541 sysctlfs_node_lookup(struct puffs_usermount *pu, void *opc,
542 struct puffs_newinfo *pni, const struct puffs_cn *pcn)
543 {
544 struct puffs_cn *p2cn = __UNCONST(pcn); /* XXX: fix the interface */
545 struct sysctlnode sn[SFS_NODEPERDIR];
546 struct sysctlnode qnode;
547 struct puffs_node *pn_dir = opc;
548 struct puffs_node *pn_new;
549 struct sfsnode *sfs_dir = pn_dir->pn_data, *sfs_new;
550 SfsName *sname = PCNPATH(pcn);
551 size_t sl, i;
552 int nodetype;
553
554 assert(ISADIR(sfs_dir));
555
556 /*
557 * If we're looking for dotdot, we already have the entire pathname
558 * in sname, courtesy of pathbuild, so we can skip this step.
559 */
560 if (!PCNISDOTDOT(pcn)) {
561 memset(&qnode, 0, sizeof(qnode));
562 sl = SFS_NODEPERDIR * sizeof(struct sysctlnode);
563 qnode.sysctl_flags = SYSCTL_VERSION;
564 (*sname)[PCNPLEN(pcn)] = CTL_QUERY;
565
566 if (sysctl(*sname, PCNPLEN(pcn) + 1, sn, &sl,
567 &qnode, sizeof(qnode)) == -1)
568 return ENOENT;
569
570 for (i = 0; i < sl / sizeof(struct sysctlnode); i++)
571 if (strcmp(sn[i].sysctl_name, pcn->pcn_name) == 0)
572 break;
573 if (i == sl / sizeof(struct sysctlnode))
574 return ENOENT;
575
576 (*sname)[PCNPLEN(pcn)] = sn[i].sysctl_num;
577 p2cn->pcn_po_full.po_len++;
578 nodetype = sn[i].sysctl_flags;
579 } else
580 nodetype = CTLTYPE_NODE;
581
582 pn_new = getnode(pu, &p2cn->pcn_po_full, nodetype);
583 if (pn_new == NULL)
584 return ENOENT;
585 sfs_new = pn_new->pn_data;
586
587 puffs_newinfo_setcookie(pni, pn_new);
588 if (ISADIR(sfs_new))
589 puffs_newinfo_setvtype(pni, VDIR);
590 else
591 puffs_newinfo_setvtype(pni, VREG);
592
593 return 0;
594 }
595
596 int
sysctlfs_node_getattr(struct puffs_usermount * pu,void * opc,struct vattr * va,const struct puffs_cred * pcr)597 sysctlfs_node_getattr(struct puffs_usermount *pu, void *opc, struct vattr *va,
598 const struct puffs_cred *pcr)
599 {
600 struct puffs_node *pn = opc;
601 struct sfsnode *sfs = pn->pn_data;
602
603 memset(va, 0, sizeof(struct vattr));
604
605 if (ISADIR(sfs)) {
606 va->va_type = VDIR;
607 va->va_mode = 0555;
608 } else {
609 va->va_type = VREG;
610 va->va_mode = fileperms;
611 }
612 va->va_uid = fileuid;
613 va->va_gid = filegid;
614 va->va_nlink = getlinks(sfs, &pn->pn_po);
615 va->va_fileid = sfs->myid;
616 va->va_size = getsize(sfs, &pn->pn_po);
617 va->va_gen = 1;
618 va->va_rdev = PUFFS_VNOVAL;
619 va->va_blocksize = 512;
620 va->va_filerev = 1;
621
622 va->va_atime = va->va_mtime = va->va_ctime = va->va_birthtime = fstime;
623
624 return 0;
625 }
626
627 int
sysctlfs_node_setattr(struct puffs_usermount * pu,void * opc,const struct vattr * va,const struct puffs_cred * pcr)628 sysctlfs_node_setattr(struct puffs_usermount *pu, void *opc,
629 const struct vattr *va, const struct puffs_cred *pcr)
630 {
631
632 /* dummy, but required for write */
633 /* XXX: we could return EOPNOTSUPP or something */
634 return 0;
635 }
636
637 int
sysctlfs_node_readdir(struct puffs_usermount * pu,void * opc,struct dirent * dent,off_t * readoff,size_t * reslen,const struct puffs_cred * pcr,int * eofflag,off_t * cookies,size_t * ncookies)638 sysctlfs_node_readdir(struct puffs_usermount *pu, void *opc,
639 struct dirent *dent, off_t *readoff, size_t *reslen,
640 const struct puffs_cred *pcr, int *eofflag,
641 off_t *cookies, size_t *ncookies)
642 {
643 struct sysctlnode sn[SFS_NODEPERDIR];
644 struct sysctlnode qnode;
645 struct puffs_node *pn_dir = opc;
646 struct puffs_node *pn_res;
647 struct puffs_pathobj po;
648 struct sfsnode *sfs_dir = pn_dir->pn_data, *sfs_ent;
649 SfsName *sname;
650 size_t sl, i;
651 enum vtype vt;
652 ino_t id;
653
654 *ncookies = 0;
655
656 again:
657 if (*readoff == DENT_DOT || *readoff == DENT_DOTDOT) {
658 puffs_gendotdent(&dent, sfs_dir->myid, *readoff, reslen);
659 (*readoff)++;
660 PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
661 goto again;
662 }
663
664 memset(&qnode, 0, sizeof(qnode));
665 sl = SFS_NODEPERDIR * sizeof(struct sysctlnode);
666 qnode.sysctl_flags = SYSCTL_VERSION;
667 sname = PNPATH(pn_dir);
668 (*sname)[PNPLEN(pn_dir)] = CTL_QUERY;
669
670 if (sysctl(*sname, PNPLEN(pn_dir) + 1, sn, &sl,
671 &qnode, sizeof(qnode)) == -1)
672 return ENOENT;
673
674 po.po_path = sname;
675 po.po_len = PNPLEN(pn_dir)+1;
676
677 for (i = DENT_ADJ(*readoff); i < sl / sizeof(struct sysctlnode); i++) {
678 if (SYSCTL_TYPE(sn[i].sysctl_flags) == CTLTYPE_NODE)
679 vt = VDIR;
680 else
681 vt = VREG;
682
683 /*
684 * check if the node exists. if so, give it the real
685 * inode number. otherwise just fake it.
686 */
687 (*sname)[PNPLEN(pn_dir)] = sn[i].sysctl_num;
688 pn_res = puffs_pn_nodewalk(pu, puffs_path_walkcmp, &po);
689 if (pn_res) {
690 sfs_ent = pn_res->pn_data;
691 id = sfs_ent->myid;
692 } else {
693 id = nextid++;
694 }
695
696 if (!puffs_nextdent(&dent, sn[i].sysctl_name, id,
697 puffs_vtype2dt(vt), reslen))
698 return 0;
699
700 (*readoff)++;
701 PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
702 }
703
704 *eofflag = 1;
705 return 0;
706 }
707
708 int
sysctlfs_node_read(struct puffs_usermount * pu,void * opc,uint8_t * buf,off_t offset,size_t * resid,const struct puffs_cred * pcr,int ioflag)709 sysctlfs_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf,
710 off_t offset, size_t *resid, const struct puffs_cred *pcr,
711 int ioflag)
712 {
713 char localbuf[SFS_MAXFILE];
714 struct puffs_node *pn = opc;
715 struct sfsnode *sfs = pn->pn_data;
716 size_t sz = sizeof(localbuf);
717 int xfer;
718
719 if (ISADIR(sfs))
720 return EISDIR;
721
722 getnodedata(sfs, &pn->pn_po, localbuf, &sz);
723 if ((ssize_t)sz < offset)
724 xfer = 0;
725 else
726 xfer = MIN(*resid, sz - offset);
727
728 if (xfer <= 0)
729 return 0;
730
731 memcpy(buf, localbuf + offset, xfer);
732 *resid -= xfer;
733
734 if (*resid && !rflag) {
735 buf[xfer] = '\n';
736 (*resid)--;
737 }
738
739 return 0;
740 }
741
742 int
sysctlfs_node_write(struct puffs_usermount * pu,void * opc,uint8_t * buf,off_t offset,size_t * resid,const struct puffs_cred * cred,int ioflag)743 sysctlfs_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf,
744 off_t offset, size_t *resid, const struct puffs_cred *cred,
745 int ioflag)
746 {
747 struct puffs_node *pn = opc;
748 struct sfsnode *sfs = pn->pn_data;
749 long long ll;
750 int i, rv;
751 bool b;
752
753 /*
754 * I picked the wrong day to ... um, the wrong place to return errors
755 */
756
757 /* easy to support, but just unavailable now */
758 if (rflag)
759 return EOPNOTSUPP;
760
761 if (puffs_cred_isjuggernaut(cred) == 0)
762 return EACCES;
763
764 if (ISADIR(sfs))
765 return EISDIR;
766
767 if (offset != 0)
768 return EINVAL;
769
770 if (ioflag & PUFFS_IO_APPEND)
771 return EINVAL;
772
773 switch (SYSCTL_TYPE(sfs->sysctl_flags)) {
774 case CTLTYPE_BOOL:
775 if (strcasestr((const char *)buf, "true"))
776 b = true;
777 else if (strcasestr((const char *)buf, "false"))
778 b = false;
779 else
780 return EINVAL;
781 rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
782 &b, sizeof(b));
783 break;
784 case CTLTYPE_INT:
785 if (sscanf((const char *)buf, "%d", &i) != 1)
786 return EINVAL;
787 rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
788 &i, sizeof(int));
789 break;
790 case CTLTYPE_QUAD:
791 if (sscanf((const char *)buf, "%lld", &ll) != 1)
792 return EINVAL;
793 rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
794 &ll, sizeof(long long));
795 break;
796 case CTLTYPE_STRING:
797 rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL, buf, *resid);
798 break;
799 default:
800 rv = EINVAL;
801 break;
802 }
803
804 if (rv)
805 return rv;
806
807 *resid = 0;
808 return 0;
809 }
810