1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * logadm/opts.c -- options handling routines 28 */ 29 30 #include <stdio.h> 31 #include <libintl.h> 32 #include <stdlib.h> 33 #include <ctype.h> 34 #include <strings.h> 35 #include <time.h> 36 #include <sys/types.h> 37 #include <sys/stat.h> 38 #include <errno.h> 39 #include "err.h" 40 #include "lut.h" 41 #include "fn.h" 42 #include "opts.h" 43 44 /* forward declarations for private functions */ 45 static struct optinfo *opt_info(int c); 46 static void opts_setcmdarg(struct opts *opts, const char *cmdarg); 47 48 /* info created by opts_parse(), private to this module */ 49 struct opts { 50 struct lut *op_raw; /* the raw text for the options */ 51 struct lut *op_ints; /* the int values for the options */ 52 struct fn_list *op_cmdargs; /* the op_cmdargs */ 53 }; 54 55 static off_t opts_parse_ctime(const char *o, const char *optarg); 56 static off_t opts_parse_bytes(const char *o, const char *optarg); 57 static off_t opts_parse_atopi(const char *o, const char *optarg); 58 static off_t opts_parse_seconds(const char *o, const char *optarg); 59 60 static struct lut *Info; /* table driving parsing */ 61 62 /* table that drives argument parsing */ 63 struct optinfo Opttable[] = { 64 { "e", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 65 { "F", OPTTYPE_STRING, NULL, OPTF_CLI }, 66 { "f", OPTTYPE_STRING, NULL, OPTF_CLI }, 67 { "h", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 68 { "l", OPTTYPE_BOOLEAN, NULL, OPTF_CLI|OPTF_CONF }, 69 { "N", OPTTYPE_BOOLEAN, NULL, OPTF_CLI|OPTF_CONF }, 70 { "n", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 71 { "r", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 72 { "V", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 73 { "v", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 74 { "w", OPTTYPE_STRING, NULL, OPTF_CLI }, 75 { "p", OPTTYPE_INT, opts_parse_seconds, OPTF_CLI|OPTF_CONF }, 76 { "P", OPTTYPE_INT, opts_parse_ctime, OPTF_CLI|OPTF_CONF }, 77 { "s", OPTTYPE_INT, opts_parse_bytes, OPTF_CLI|OPTF_CONF }, 78 { "a", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 79 { "b", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 80 { "c", OPTTYPE_BOOLEAN, NULL, OPTF_CLI|OPTF_CONF }, 81 { "g", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 82 { "m", OPTTYPE_INT, opts_parse_atopi, OPTF_CLI|OPTF_CONF }, 83 { "M", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 84 { "o", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 85 { "R", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 86 { "t", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 87 { "z", OPTTYPE_INT, opts_parse_atopi, OPTF_CLI|OPTF_CONF }, 88 { "A", OPTTYPE_INT, opts_parse_seconds, OPTF_CLI|OPTF_CONF }, 89 { "C", OPTTYPE_INT, opts_parse_atopi, OPTF_CLI|OPTF_CONF }, 90 { "E", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 91 { "S", OPTTYPE_INT, opts_parse_bytes, OPTF_CLI|OPTF_CONF }, 92 { "T", OPTTYPE_STRING, NULL, OPTF_CLI|OPTF_CONF }, 93 }; 94 95 int Opttable_cnt = sizeof (Opttable) / sizeof (struct optinfo); 96 97 /* 98 * opts_init -- set current options parsing table 99 */ 100 void 101 opts_init(struct optinfo *table, int numentries) 102 { 103 while (numentries-- > 0) { 104 Info = lut_add(Info, table->oi_o, table); 105 table++; 106 } 107 } 108 109 /* 110 * opt_info -- fetch the optinfo struct for the given option 111 */ 112 static struct optinfo * 113 opt_info(int c) 114 { 115 char lhs[2]; 116 lhs[0] = c; 117 lhs[1] = '\0'; 118 return ((struct optinfo *)lut_lookup(Info, lhs)); 119 } 120 121 /* 122 * opts_parse -- parse an argv-style list of options 123 * 124 * prints a message to stderr and calls err(EF_FILE|EF_JMP, ...) on error 125 */ 126 struct opts * 127 opts_parse(struct opts *opts, char **argv, int flags) 128 { 129 int dashdash = 0; 130 char *ptr; 131 132 if (opts == NULL) { 133 opts = MALLOC(sizeof (*opts)); 134 opts->op_raw = opts->op_ints = NULL; 135 opts->op_cmdargs = fn_list_new(NULL); 136 } 137 138 /* no words to process, just return empty opts struct */ 139 if (argv == NULL) 140 return (opts); 141 142 /* foreach word... */ 143 for (; (ptr = *argv) != NULL; argv++) { 144 if (dashdash || *ptr != '-') { 145 /* found a cmdarg */ 146 opts_setcmdarg(opts, ptr); 147 continue; 148 } 149 if (*++ptr == '\0') 150 err(EF_FILE|EF_JMP, "Illegal option: dash by itself"); 151 if (*ptr == '-') { 152 /* (here's where support for --longname would go) */ 153 if (*(ptr + 1) != '\0') 154 err(EF_FILE|EF_JMP, "Illegal option: -%s", ptr); 155 dashdash++; 156 continue; 157 } 158 for (; *ptr; ptr++) { 159 struct optinfo *info = opt_info(*ptr); 160 161 /* see if option was in our parsing table */ 162 if (info == NULL) 163 err(EF_FILE|EF_JMP, "Illegal option: %c", *ptr); 164 165 /* see if context allows this option */ 166 if ((flags & OPTF_CLI) && 167 (info->oi_flags & OPTF_CLI) == 0) 168 err(EF_FILE|EF_JMP, 169 "Option '%c' not allowed on " 170 "command line", *ptr); 171 172 if ((flags & OPTF_CONF) && 173 (info->oi_flags & OPTF_CONF) == 0) 174 err(EF_FILE|EF_JMP, 175 "Option '%c' not allowed in " 176 "configuration file", *ptr); 177 178 /* for boolean options, we have all the info we need */ 179 if (info->oi_t == OPTTYPE_BOOLEAN) { 180 (void) opts_set(opts, info->oi_o, ""); 181 continue; 182 } 183 184 /* option expects argument */ 185 if (*++ptr == '\0' && 186 ((ptr = *++argv) == NULL || *ptr == '-')) 187 err(EF_FILE|EF_JMP, 188 "Option '%c' requires an argument", 189 info->oi_o[0]); 190 opts_set(opts, info->oi_o, ptr); 191 break; 192 } 193 } 194 195 return (opts); 196 } 197 198 /* 199 * opts_free -- free a struct opts previously allocated by opts_parse() 200 */ 201 void 202 opts_free(struct opts *opts) 203 { 204 if (opts) { 205 lut_free(opts->op_raw, NULL); 206 lut_free(opts->op_ints, NULL); 207 fn_list_free(opts->op_cmdargs); 208 FREE(opts); 209 } 210 } 211 212 /* 213 * opts_set -- set an option 214 */ 215 void 216 opts_set(struct opts *opts, const char *o, const char *optarg) 217 { 218 off_t *rval; 219 struct optinfo *info = opt_info(*o); 220 221 rval = MALLOC(sizeof (off_t)); 222 opts->op_raw = lut_add(opts->op_raw, o, (void *)optarg); 223 224 if (info->oi_parser) { 225 *rval = (*info->oi_parser)(o, optarg); 226 opts->op_ints = lut_add(opts->op_ints, o, (void *)rval); 227 } 228 } 229 230 /* 231 * opts_setcmdarg -- add a cmdarg to the list of op_cmdargs 232 */ 233 static void 234 opts_setcmdarg(struct opts *opts, const char *cmdarg) 235 { 236 fn_list_adds(opts->op_cmdargs, cmdarg); 237 } 238 239 /* 240 * opts_count -- return count of the options in *options that are set 241 */ 242 int 243 opts_count(struct opts *opts, const char *options) 244 { 245 int count = 0; 246 247 for (; *options; options++) { 248 char lhs[2]; 249 lhs[0] = *options; 250 lhs[1] = '\0'; 251 if (lut_lookup(opts->op_raw, lhs)) 252 count++; 253 } 254 return (count); 255 } 256 257 /* 258 * opts_optarg -- return the optarg for the given option, NULL if not set 259 */ 260 const char * 261 opts_optarg(struct opts *opts, const char *o) 262 { 263 return ((char *)lut_lookup(opts->op_raw, o)); 264 } 265 266 /* 267 * opts_optarg_int -- return the int value for the given option 268 */ 269 off_t 270 opts_optarg_int(struct opts *opts, const char *o) 271 { 272 off_t *ret; 273 274 ret = (off_t *)lut_lookup(opts->op_ints, o); 275 if (ret != NULL) 276 return (*ret); 277 return (0); 278 } 279 280 /* 281 * opts_cmdargs -- return list of op_cmdargs 282 */ 283 struct fn_list * 284 opts_cmdargs(struct opts *opts) 285 { 286 return (opts->op_cmdargs); 287 } 288 289 static void 290 merger(const char *lhs, void *rhs, void *arg) 291 { 292 struct lut **destlutp = (struct lut **)arg; 293 294 *destlutp = lut_add(*destlutp, lhs, rhs); 295 } 296 297 /* 298 * opts_merge -- merge two option lists together 299 */ 300 struct opts * 301 opts_merge(struct opts *back, struct opts *front) 302 { 303 struct opts *ret = MALLOC(sizeof (struct opts)); 304 305 ret->op_raw = lut_dup(back->op_raw); 306 lut_walk(front->op_raw, merger, &(ret->op_raw)); 307 308 ret->op_ints = lut_dup(back->op_ints); 309 lut_walk(front->op_ints, merger, &(ret->op_ints)); 310 311 ret->op_cmdargs = fn_list_dup(back->op_cmdargs); 312 313 return (ret); 314 } 315 316 /* 317 * opts_parse_ctime -- parse a ctime format optarg 318 */ 319 static off_t 320 opts_parse_ctime(const char *o, const char *optarg) 321 { 322 struct tm tm; 323 off_t ret; 324 325 if (strptime(optarg, "%a %b %e %T %Z %Y", &tm) == NULL && 326 strptime(optarg, "%c", &tm) == NULL) 327 err(EF_FILE|EF_JMP, 328 "Option '%c' requires ctime-style time", *o); 329 errno = 0; 330 if ((ret = (off_t)mktime(&tm)) == -1 && errno) 331 err(EF_FILE|EF_SYS|EF_JMP, "Option '%c' Illegal time", *o); 332 333 return (ret); 334 } 335 336 /* 337 * opts_parse_atopi -- parse a positive integer format optarg 338 */ 339 static off_t 340 opts_parse_atopi(const char *o, const char *optarg) 341 { 342 off_t ret = atoll(optarg); 343 344 while (isdigit(*optarg)) 345 optarg++; 346 347 if (*optarg) 348 err(EF_FILE|EF_JMP, 349 "Option '%c' requires non-negative number", *o); 350 351 return (ret); 352 } 353 354 /* 355 * opts_parse_atopi -- parse a size format optarg into bytes 356 */ 357 static off_t 358 opts_parse_bytes(const char *o, const char *optarg) 359 { 360 off_t ret = atoll(optarg); 361 while (isdigit(*optarg)) 362 optarg++; 363 364 switch (*optarg) { 365 case 'g': 366 case 'G': 367 ret *= 1024; 368 /*FALLTHROUGH*/ 369 case 'm': 370 case 'M': 371 ret *= 1024; 372 /*FALLTHROUGH*/ 373 case 'k': 374 case 'K': 375 ret *= 1024; 376 /*FALLTHROUGH*/ 377 case 'b': 378 case 'B': 379 if (optarg[1] == '\0') 380 return (ret); 381 } 382 383 err(EF_FILE|EF_JMP, 384 "Option '%c' requires number with suffix from [bkmg]", *o); 385 /*NOTREACHED*/ 386 return (0); 387 } 388 389 /* 390 * opts_parse_seconds -- parse a time format optarg into seconds 391 */ 392 static off_t 393 opts_parse_seconds(const char *o, const char *optarg) 394 { 395 off_t ret; 396 397 if (strcasecmp(optarg, "now") == 0) 398 return (OPTP_NOW); 399 400 if (strcasecmp(optarg, "never") == 0) 401 return (OPTP_NEVER); 402 403 ret = atoll(optarg); 404 while (isdigit(*optarg)) 405 optarg++; 406 407 if (optarg[1] == '\0') 408 switch (*optarg) { 409 case 'h': 410 case 'H': 411 ret *= 60 * 60; 412 return (ret); 413 case 'd': 414 case 'D': 415 ret *= 60 * 60 * 24; 416 return (ret); 417 case 'w': 418 case 'W': 419 ret *= 60 * 60 * 24 * 7; 420 return (ret); 421 case 'm': 422 case 'M': 423 ret *= 60 * 60 * 24 * 30; 424 return (ret); 425 case 'y': 426 case 'Y': 427 ret *= 60 * 60 * 24 * 365; 428 return (ret); 429 } 430 431 err(EF_FILE|EF_JMP, 432 "Option '%c' requires number with suffix from [hdwmy]", *o); 433 /*NOTREACHED*/ 434 return (0); 435 } 436 437 /* info passed between opts_print() and printer() */ 438 struct printerinfo { 439 FILE *stream; 440 int isswitch; 441 char *exclude; 442 }; 443 444 /* helper function for opts_print() */ 445 static void 446 printer(const char *lhs, void *rhs, void *arg) 447 { 448 struct printerinfo *pip = (struct printerinfo *)arg; 449 char *s = (char *)rhs; 450 451 if (pip->isswitch) { 452 char *ep = pip->exclude; 453 while (ep && *ep) 454 if (*ep++ == *lhs) 455 return; 456 } 457 458 (void) fprintf(pip->stream, " %s%s", (pip->isswitch) ? "-" : "", lhs); 459 if (s && *s) { 460 (void) fprintf(pip->stream, " "); 461 opts_printword(s, pip->stream); 462 } 463 } 464 465 /* 466 * opts_printword -- print a word, quoting as necessary 467 */ 468 void 469 opts_printword(const char *word, FILE *stream) 470 { 471 char *q = ""; 472 473 if (word != NULL) { 474 if (strchr(word, ' ') || strchr(word, '\t') || 475 strchr(word, '$') || strchr(word, '[') || 476 strchr(word, '?') || strchr(word, '{') || 477 strchr(word, '`') || strchr(word, ';')) { 478 if (strchr(word, '\'') == NULL) 479 q = "'"; 480 else if (strchr(word, '"') == NULL) 481 q = "\""; 482 else 483 err(EF_FILE|EF_JMP, 484 "Can't protect quotes in <%s>", word); 485 (void) fprintf(stream, "%s%s%s", q, word, q); 486 } else 487 (void) fprintf(stream, "%s", word); 488 } 489 } 490 491 /* 492 * opts_print -- print options to stream, leaving out those in "exclude" 493 */ 494 void 495 opts_print(struct opts *opts, FILE *stream, char *exclude) 496 { 497 struct printerinfo pi; 498 struct fn *fnp; 499 500 pi.stream = stream; 501 pi.isswitch = 1; 502 pi.exclude = exclude; 503 504 lut_walk(opts->op_raw, printer, &pi); 505 506 fn_list_rewind(opts->op_cmdargs); 507 while ((fnp = fn_list_next(opts->op_cmdargs)) != NULL) { 508 (void) fprintf(stream, " "); 509 opts_printword(fn_s(fnp), stream); 510 } 511 } 512 513 #ifdef TESTMODULE 514 515 /* table that drives argument parsing */ 516 static struct optinfo Testopttable[] = { 517 { "a", OPTTYPE_BOOLEAN, NULL, OPTF_CLI }, 518 { "b", OPTTYPE_STRING, NULL, OPTF_CLI }, 519 { "c", OPTTYPE_INT, opts_parse_seconds, OPTF_CLI|OPTF_CONF }, 520 { "d", OPTTYPE_INT, opts_parse_ctime, OPTF_CLI|OPTF_CONF }, 521 { "e", OPTTYPE_INT, opts_parse_bytes, OPTF_CLI|OPTF_CONF }, 522 { "f", OPTTYPE_INT, opts_parse_atopi, OPTF_CLI|OPTF_CONF }, 523 }; 524 525 /* 526 * test main for opts module, usage: a.out options... 527 */ 528 int 529 main(int argc, char *argv[]) 530 { 531 struct opts *opts; 532 533 err_init(argv[0]); 534 setbuf(stdout, NULL); 535 536 opts_init(Testopttable, 537 sizeof (Testopttable) / sizeof (struct optinfo)); 538 539 argv++; 540 541 if (SETJMP) 542 err(0, "opts parsing failed"); 543 else 544 opts = opts_parse(NULL, argv, OPTF_CLI); 545 546 printf("options:"); 547 opts_print(opts, stdout, NULL); 548 printf("\n"); 549 550 err_done(0); 551 /* NOTREACHED */ 552 return (0); 553 } 554 555 #endif /* TESTMODULE */ 556