rule.c revision 154053
1100206Sdd/*- 2100206Sdd * Copyright (c) 2002 Dima Dorfman. 3100206Sdd * All rights reserved. 4100206Sdd * 5100206Sdd * Redistribution and use in source and binary forms, with or without 6100206Sdd * modification, are permitted provided that the following conditions 7100206Sdd * are met: 8100206Sdd * 1. Redistributions of source code must retain the above copyright 9100206Sdd * notice, this list of conditions and the following disclaimer. 10100206Sdd * 2. Redistributions in binary form must reproduce the above copyright 11100206Sdd * notice, this list of conditions and the following disclaimer in the 12100206Sdd * documentation and/or other materials provided with the distribution. 13100206Sdd * 14100206Sdd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15100206Sdd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16100206Sdd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17100206Sdd * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18100206Sdd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19100206Sdd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20100206Sdd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21100206Sdd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22100206Sdd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23100206Sdd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24100206Sdd * SUCH DAMAGE. 25100206Sdd */ 26100206Sdd 27100206Sdd/* 28100206Sdd * Rule subsystem manipulation. 29100206Sdd */ 30100206Sdd 31100206Sdd#include <sys/cdefs.h> 32100206Sdd__FBSDID("$FreeBSD: head/sbin/devfs/rule.c 154053 2006-01-05 13:37:07Z maxim $"); 33100206Sdd 34100206Sdd#include <sys/param.h> 35100206Sdd#include <sys/conf.h> 36100206Sdd#include <sys/ioctl.h> 37100206Sdd 38100799Sdd#include <assert.h> 39100206Sdd#include <err.h> 40100206Sdd#include <errno.h> 41100206Sdd#include <grp.h> 42100206Sdd#include <pwd.h> 43100206Sdd#include <stdio.h> 44100206Sdd#include <stdlib.h> 45100206Sdd#include <string.h> 46100206Sdd#include <unistd.h> 47100206Sdd 48100206Sdd#include "extern.h" 49100206Sdd 50100803Sddstatic void rulespec_infp(FILE *fp, unsigned long reqest, devfs_rsnum rsnum); 51100799Sddstatic void rulespec_instr(struct devfs_rule *dr, const char *str, 52100799Sdd devfs_rsnum rsnum); 53100206Sddstatic void rulespec_intok(struct devfs_rule *dr, int ac, char **av, 54100206Sdd devfs_rsnum rsnum); 55100206Sddstatic void rulespec_outfp(FILE *fp, struct devfs_rule *dr); 56100206Sdd 57100206Sddstatic command_t rule_add, rule_apply, rule_applyset; 58100206Sddstatic command_t rule_del, rule_delset, rule_show, rule_showsets; 59100206Sdd 60100206Sddstatic ctbl_t ctbl_rule = { 61100206Sdd { "add", rule_add }, 62100206Sdd { "apply", rule_apply }, 63100206Sdd { "applyset", rule_applyset }, 64100206Sdd { "del", rule_del }, 65100206Sdd { "delset", rule_delset }, 66100206Sdd { "show", rule_show }, 67100206Sdd { "showsets", rule_showsets }, 68100206Sdd { NULL, NULL } 69100206Sdd}; 70100206Sdd 71100206Sddstatic struct intstr ist_type[] = { 72100206Sdd { "disk", D_DISK }, 73100206Sdd { "mem", D_MEM }, 74100206Sdd { "tape", D_TAPE }, 75100206Sdd { "tty", D_TTY }, 76100206Sdd { NULL, -1 } 77100206Sdd}; 78100206Sdd 79100206Sdddevfs_rsnum in_rsnum; 80100206Sdd 81100206Sddint 82100206Sddrule_main(int ac, char **av) 83100206Sdd{ 84100206Sdd struct cmd *c; 85124830Sgrehan int ch; 86100206Sdd 87100206Sdd setprogname("devfs rule"); 88100206Sdd optreset = optind = 1; 89100206Sdd while ((ch = getopt(ac, av, "s:")) != -1) 90100206Sdd switch (ch) { 91100206Sdd case 's': 92100206Sdd in_rsnum = eatonum(optarg); 93100206Sdd break; 94100206Sdd default: 95100206Sdd usage(); 96100206Sdd } 97100206Sdd ac -= optind; 98100206Sdd av += optind; 99100206Sdd if (ac < 1) 100100206Sdd usage(); 101100206Sdd 102100206Sdd for (c = ctbl_rule; c->name != NULL; ++c) 103100206Sdd if (strcmp(c->name, av[0]) == 0) 104100206Sdd exit((*c->handler)(ac, av)); 105100206Sdd errx(1, "unknown command: %s", av[0]); 106100206Sdd} 107100206Sdd 108100206Sddstatic int 109100206Sddrule_add(int ac, char **av) 110100206Sdd{ 111100206Sdd struct devfs_rule dr; 112100206Sdd int rv; 113100206Sdd 114100206Sdd if (ac < 2) 115100206Sdd usage(); 116100799Sdd if (strcmp(av[1], "-") == 0) 117100799Sdd rulespec_infp(stdin, DEVFSIO_RADD, in_rsnum); 118100799Sdd else { 119100799Sdd rulespec_intok(&dr, ac - 1, av + 1, in_rsnum); 120100799Sdd rv = ioctl(mpfd, DEVFSIO_RADD, &dr); 121100799Sdd if (rv == -1) 122100799Sdd err(1, "ioctl DEVFSIO_RADD"); 123100799Sdd } 124100206Sdd return (0); 125100206Sdd} 126100206Sdd 127100206Sddstatic int 128100206Sddrule_apply(int ac __unused, char **av __unused) 129100206Sdd{ 130100206Sdd struct devfs_rule dr; 131100206Sdd devfs_rnum rnum; 132100206Sdd devfs_rid rid; 133100206Sdd int rv; 134100206Sdd 135100206Sdd if (ac < 2) 136100206Sdd usage(); 137100206Sdd if (!atonum(av[1], &rnum)) { 138100799Sdd if (strcmp(av[1], "-") == 0) 139100799Sdd rulespec_infp(stdin, DEVFSIO_RAPPLY, in_rsnum); 140100799Sdd else { 141100799Sdd rulespec_intok(&dr, ac - 1, av + 1, in_rsnum); 142100799Sdd rv = ioctl(mpfd, DEVFSIO_RAPPLY, &dr); 143100799Sdd if (rv == -1) 144100799Sdd err(1, "ioctl DEVFSIO_RAPPLY"); 145100799Sdd } 146100206Sdd } else { 147100206Sdd rid = mkrid(in_rsnum, rnum); 148100206Sdd rv = ioctl(mpfd, DEVFSIO_RAPPLYID, &rid); 149100206Sdd if (rv == -1) 150100206Sdd err(1, "ioctl DEVFSIO_RAPPLYID"); 151100206Sdd } 152100206Sdd return (0); 153100206Sdd} 154100206Sdd 155100206Sddstatic int 156100206Sddrule_applyset(int ac, char **av __unused) 157100206Sdd{ 158100206Sdd int rv; 159100206Sdd 160100206Sdd if (ac != 1) 161100206Sdd usage(); 162100206Sdd rv = ioctl(mpfd, DEVFSIO_SAPPLY, &in_rsnum); 163100206Sdd if (rv == -1) 164100206Sdd err(1, "ioctl DEVFSIO_SAPPLY"); 165100206Sdd return (0); 166100206Sdd} 167100206Sdd 168100206Sddstatic int 169100206Sddrule_del(int ac __unused, char **av) 170100206Sdd{ 171100206Sdd devfs_rid rid; 172100206Sdd int rv; 173100206Sdd 174100206Sdd if (av[1] == NULL) 175100206Sdd usage(); 176100206Sdd rid = mkrid(in_rsnum, eatoi(av[1])); 177100206Sdd rv = ioctl(mpfd, DEVFSIO_RDEL, &rid); 178100206Sdd if (rv == -1) 179100206Sdd err(1, "ioctl DEVFSIO_RDEL"); 180100206Sdd return (0); 181100206Sdd} 182100206Sdd 183100206Sddstatic int 184100206Sddrule_delset(int ac, char **av __unused) 185100206Sdd{ 186100206Sdd struct devfs_rule dr; 187100206Sdd int rv; 188100206Sdd 189100206Sdd if (ac != 1) 190100206Sdd usage(); 191100206Sdd memset(&dr, '\0', sizeof(dr)); 192100206Sdd dr.dr_magic = DEVFS_MAGIC; 193100206Sdd dr.dr_id = mkrid(in_rsnum, 0); 194100206Sdd while (ioctl(mpfd, DEVFSIO_RGETNEXT, &dr) != -1) { 195100206Sdd rv = ioctl(mpfd, DEVFSIO_RDEL, &dr.dr_id); 196100206Sdd if (rv == -1) 197100206Sdd err(1, "ioctl DEVFSIO_RDEL"); 198100206Sdd } 199100206Sdd if (errno != ENOENT) 200100206Sdd err(1, "ioctl DEVFSIO_RGETNEXT"); 201100206Sdd return (0); 202100206Sdd} 203100206Sdd 204100206Sddstatic int 205100206Sddrule_show(int ac __unused, char **av) 206100206Sdd{ 207100206Sdd struct devfs_rule dr; 208100206Sdd devfs_rnum rnum; 209100206Sdd int rv; 210100206Sdd 211100206Sdd memset(&dr, '\0', sizeof(dr)); 212100206Sdd dr.dr_magic = DEVFS_MAGIC; 213100206Sdd if (av[1] != NULL) { 214100206Sdd rnum = eatoi(av[1]); 215100206Sdd dr.dr_id = mkrid(in_rsnum, rnum - 1); 216100206Sdd rv = ioctl(mpfd, DEVFSIO_RGETNEXT, &dr); 217100206Sdd if (rv == -1) 218100206Sdd err(1, "ioctl DEVFSIO_RGETNEXT"); 219100206Sdd if (rid2rn(dr.dr_id) == rnum) 220100206Sdd rulespec_outfp(stdout, &dr); 221100206Sdd } else { 222100206Sdd dr.dr_id = mkrid(in_rsnum, 0); 223100206Sdd while (ioctl(mpfd, DEVFSIO_RGETNEXT, &dr) != -1) 224100206Sdd rulespec_outfp(stdout, &dr); 225100206Sdd if (errno != ENOENT) 226100206Sdd err(1, "ioctl DEVFSIO_RGETNEXT"); 227100206Sdd } 228100206Sdd return (0); 229100805Sdd} 230100206Sdd 231100206Sddstatic int 232100206Sddrule_showsets(int ac, char **av __unused) 233100206Sdd{ 234100206Sdd devfs_rsnum rsnum; 235100206Sdd 236100206Sdd if (ac != 1) 237100206Sdd usage(); 238100206Sdd rsnum = 0; 239100206Sdd while (ioctl(mpfd, DEVFSIO_SGETNEXT, &rsnum) != -1) 240100206Sdd printf("%d\n", rsnum); 241100206Sdd if (errno != ENOENT) 242100206Sdd err(1, "ioctl DEVFSIO_SGETNEXT"); 243100206Sdd return (0); 244100206Sdd} 245100206Sdd 246100206Sddint 247100206Sddruleset_main(int ac, char **av) 248100206Sdd{ 249100206Sdd devfs_rsnum rsnum; 250100206Sdd int rv; 251100206Sdd 252100206Sdd setprogname("devfs ruleset"); 253100206Sdd if (ac < 2) 254100206Sdd usage(); 255100206Sdd rsnum = eatonum(av[1]); 256100206Sdd rv = ioctl(mpfd, DEVFSIO_SUSE, &rsnum); 257100206Sdd if (rv == -1) 258100206Sdd err(1, "ioctl DEVFSIO_SUSE"); 259100206Sdd return (0); 260100206Sdd} 261100206Sdd 262100206Sdd 263100206Sdd/* 264100799Sdd * Input rules from a file (probably the standard input). This 265100799Sdd * differs from the other rulespec_in*() routines in that it also 266100799Sdd * calls ioctl() for the rules, since it is impractical (and not very 267100799Sdd * useful) to return a list (or array) of rules, just so the caller 268100799Sdd * can call call ioctl() for each of them. 269100799Sdd */ 270100799Sddstatic void 271100803Sddrulespec_infp(FILE *fp, unsigned long request, devfs_rsnum rsnum) 272100799Sdd{ 273100799Sdd struct devfs_rule dr; 274100799Sdd char *line; 275100799Sdd int rv; 276100799Sdd 277100799Sdd assert(fp == stdin); /* XXX: De-hardcode "stdin" from error msg. */ 278100799Sdd while (efgetln(fp, &line)) { 279100799Sdd rulespec_instr(&dr, line, rsnum); 280100803Sdd rv = ioctl(mpfd, request, &dr); 281100799Sdd if (rv == -1) 282100799Sdd err(1, "ioctl"); 283100799Sdd free(line); /* efgetln() always malloc()s. */ 284100799Sdd } 285100799Sdd if (ferror(stdin)) 286100799Sdd err(1, "stdin"); 287100799Sdd} 288100799Sdd 289100799Sdd/* 290100799Sdd * Construct a /struct devfs_rule/ from a string. 291100799Sdd */ 292100799Sddstatic void 293100799Sddrulespec_instr(struct devfs_rule *dr, const char *str, devfs_rsnum rsnum) 294100799Sdd{ 295100799Sdd char **av; 296100799Sdd int ac; 297100799Sdd 298100799Sdd tokenize(str, &ac, &av); 299100799Sdd if (ac == 0) 300100799Sdd errx(1, "unexpected end of rulespec"); 301100799Sdd rulespec_intok(dr, ac, av, rsnum); 302100799Sdd free(av[0]); 303100799Sdd free(av); 304100799Sdd} 305100799Sdd 306100799Sdd/* 307100206Sdd * Construct a /struct devfs_rule/ from ac and av. 308100206Sdd */ 309100206Sddstatic void 310100206Sddrulespec_intok(struct devfs_rule *dr, int ac __unused, char **av, 311100206Sdd devfs_rsnum rsnum) 312100206Sdd{ 313100206Sdd struct intstr *is; 314100206Sdd struct passwd *pw; 315100206Sdd struct group *gr; 316100206Sdd devfs_rnum rnum; 317137303Sdd void *set; 318100206Sdd 319100206Sdd memset(dr, '\0', sizeof(*dr)); 320100206Sdd 321100206Sdd /* 322100206Sdd * We don't maintain ac hereinafter. 323100206Sdd */ 324100206Sdd if (av[0] == NULL) 325100206Sdd errx(1, "unexpected end of rulespec"); 326100206Sdd 327100206Sdd /* If the first argument is an integer, treat it as a rule number. */ 328100206Sdd if (!atonum(av[0], &rnum)) 329100206Sdd rnum = 0; /* auto-number */ 330100206Sdd else 331100206Sdd ++av; 332100206Sdd 333100206Sdd /* 334100206Sdd * These aren't table-driven since that would result in more 335100206Sdd * tiny functions than I care to deal with. 336100206Sdd */ 337100206Sdd for (;;) { 338100206Sdd if (av[0] == NULL) 339100206Sdd break; 340100206Sdd else if (strcmp(av[0], "type") == 0) { 341100206Sdd if (av[1] == NULL) 342100206Sdd errx(1, "expecting argument for type"); 343100206Sdd for (is = ist_type; is->s != NULL; ++is) 344100206Sdd if (strcmp(av[1], is->s) == 0) { 345100206Sdd dr->dr_dswflags |= is->i; 346100206Sdd break; 347100206Sdd } 348100206Sdd if (is->s == NULL) 349100206Sdd errx(1, "unknown type: %s", av[1]); 350100206Sdd dr->dr_icond |= DRC_DSWFLAGS; 351100206Sdd av += 2; 352100206Sdd } else if (strcmp(av[0], "path") == 0) { 353100206Sdd if (av[1] == NULL) 354100206Sdd errx(1, "expecting argument for path"); 355100206Sdd if (strlcpy(dr->dr_pathptrn, av[1], DEVFS_MAXPTRNLEN) 356100206Sdd >= DEVFS_MAXPTRNLEN) 357100206Sdd warnx("pattern specified too long; truncated"); 358100206Sdd dr->dr_icond |= DRC_PATHPTRN; 359100206Sdd av += 2; 360100206Sdd } else 361100206Sdd break; 362100206Sdd } 363137303Sdd while (av[0] != NULL) { 364137303Sdd if (strcmp(av[0], "hide") == 0) { 365100206Sdd dr->dr_iacts |= DRA_BACTS; 366100206Sdd dr->dr_bacts |= DRB_HIDE; 367100206Sdd ++av; 368100206Sdd } else if (strcmp(av[0], "unhide") == 0) { 369100206Sdd dr->dr_iacts |= DRA_BACTS; 370100206Sdd dr->dr_bacts |= DRB_UNHIDE; 371100206Sdd ++av; 372100206Sdd } else if (strcmp(av[0], "user") == 0) { 373100206Sdd if (av[1] == NULL) 374100206Sdd errx(1, "expecting argument for user"); 375100206Sdd dr->dr_iacts |= DRA_UID; 376100206Sdd pw = getpwnam(av[1]); 377100206Sdd if (pw != NULL) 378100206Sdd dr->dr_uid = pw->pw_uid; 379100206Sdd else 380100206Sdd dr->dr_uid = eatoi(av[1]); /* XXX overflow */ 381100206Sdd av += 2; 382100206Sdd } else if (strcmp(av[0], "group") == 0) { 383100206Sdd if (av[1] == NULL) 384100206Sdd errx(1, "expecting argument for group"); 385100206Sdd dr->dr_iacts |= DRA_GID; 386100206Sdd gr = getgrnam(av[1]); 387100206Sdd if (gr != NULL) 388100206Sdd dr->dr_gid = gr->gr_gid; 389100206Sdd else 390100206Sdd dr->dr_gid = eatoi(av[1]); /* XXX overflow */ 391100206Sdd av += 2; 392100206Sdd } else if (strcmp(av[0], "mode") == 0) { 393100206Sdd if (av[1] == NULL) 394100206Sdd errx(1, "expecting argument for mode"); 395100206Sdd dr->dr_iacts |= DRA_MODE; 396137303Sdd set = setmode(av[1]); 397137303Sdd if (set == NULL) 398154053Smaxim errx(1, "invalid mode: %s", av[1]); 399137303Sdd dr->dr_mode = getmode(set, 0); 400100206Sdd av += 2; 401100206Sdd } else if (strcmp(av[0], "include") == 0) { 402100206Sdd if (av[1] == NULL) 403100206Sdd errx(1, "expecting argument for include"); 404100206Sdd dr->dr_iacts |= DRA_INCSET; 405100206Sdd dr->dr_incset = eatonum(av[1]); 406100206Sdd av += 2; 407100206Sdd } else 408100206Sdd errx(1, "unknown argument: %s", av[0]); 409100206Sdd } 410100206Sdd 411100206Sdd dr->dr_id = mkrid(rsnum, rnum); 412100206Sdd dr->dr_magic = DEVFS_MAGIC; 413100206Sdd} 414100206Sdd 415100206Sdd/* 416100206Sdd * Write a human-readable (and machine-parsable, by rulespec_in*()) 417100206Sdd * representation of dr to bufp. *bufp should be free(3)'d when the 418100206Sdd * caller is finished with it. 419100206Sdd */ 420100206Sddstatic void 421100206Sddrulespec_outfp(FILE *fp, struct devfs_rule *dr) 422100206Sdd{ 423100206Sdd struct intstr *is; 424100206Sdd struct passwd *pw; 425100206Sdd struct group *gr; 426100206Sdd 427100206Sdd fprintf(fp, "%d", rid2rn(dr->dr_id)); 428100206Sdd 429100206Sdd if (dr->dr_icond & DRC_DSWFLAGS) 430100206Sdd for (is = ist_type; is->s != NULL; ++is) 431100206Sdd if (dr->dr_dswflags & is->i) 432100206Sdd fprintf(fp, " type %s", is->s); 433100206Sdd if (dr->dr_icond & DRC_PATHPTRN) 434100206Sdd fprintf(fp, " path %s", dr->dr_pathptrn); 435100206Sdd 436100206Sdd if (dr->dr_iacts & DRA_BACTS) { 437100206Sdd if (dr->dr_bacts & DRB_HIDE) 438100206Sdd fprintf(fp, " hide"); 439100206Sdd if (dr->dr_bacts & DRB_UNHIDE) 440100206Sdd fprintf(fp, " unhide"); 441100206Sdd } 442100206Sdd if (dr->dr_iacts & DRA_UID) { 443100206Sdd pw = getpwuid(dr->dr_uid); 444100206Sdd if (pw == NULL) 445100206Sdd fprintf(fp, " user %d", dr->dr_uid); 446100206Sdd else 447100206Sdd fprintf(fp, " user %s", pw->pw_name); 448100206Sdd } 449100206Sdd if (dr->dr_iacts & DRA_GID) { 450100206Sdd gr = getgrgid(dr->dr_gid); 451100206Sdd if (gr == NULL) 452100206Sdd fprintf(fp, " group %d", dr->dr_gid); 453100206Sdd else 454100206Sdd fprintf(fp, " group %s", gr->gr_name); 455100206Sdd } 456100206Sdd if (dr->dr_iacts & DRA_MODE) 457100206Sdd fprintf(fp, " mode %o", dr->dr_mode); 458100206Sdd if (dr->dr_iacts & DRA_INCSET) 459100206Sdd fprintf(fp, " include %d", dr->dr_incset); 460100206Sdd 461100206Sdd fprintf(fp, "\n"); 462100206Sdd} 463