Annotation of embedaddon/ntp/sntp/libopts/configfile.c, revision 1.1
1.1 ! misho 1: /**
! 2: * \file configfile.c
! 3: *
! 4: * Time-stamp: "2011-04-06 09:31:24 bkorb"
! 5: *
! 6: * configuration/rc/ini file handling.
! 7: *
! 8: * This file is part of AutoOpts, a companion to AutoGen.
! 9: * AutoOpts is free software.
! 10: * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
! 11: *
! 12: * AutoOpts is available under any one of two licenses. The license
! 13: * in use must be one of these two and the choice is under the control
! 14: * of the user of the license.
! 15: *
! 16: * The GNU Lesser General Public License, version 3 or later
! 17: * See the files "COPYING.lgplv3" and "COPYING.gplv3"
! 18: *
! 19: * The Modified Berkeley Software Distribution License
! 20: * See the file "COPYING.mbsd"
! 21: *
! 22: * These files have the following md5sums:
! 23: *
! 24: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
! 25: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
! 26: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
! 27: */
! 28:
! 29: static void
! 30: set_usage_flags(tOptions * opts, char const * flg_txt);
! 31:
! 32: /* = = = START-STATIC-FORWARD = = = */
! 33: static void
! 34: file_preset(tOptions * opts, char const * fname, int dir);
! 35:
! 36: static char*
! 37: handle_comment(char* pzText);
! 38:
! 39: static char *
! 40: handle_cfg(tOptions * pOpts, tOptState * pOS, char * pzText, int dir);
! 41:
! 42: static char *
! 43: handle_directive(tOptions * pOpts, char * pzText);
! 44:
! 45: static char *
! 46: aoflags_directive(tOptions * pOpts, char * pzText);
! 47:
! 48: static char *
! 49: program_directive(tOptions * pOpts, char * pzText);
! 50:
! 51: static char *
! 52: handle_section(tOptions * pOpts, char * pzText);
! 53:
! 54: static int
! 55: parse_xml_encoding(char ** ppz);
! 56:
! 57: static char *
! 58: trim_xml_text(char * pztxt, char const * pznm, tOptionLoadMode mode);
! 59:
! 60: static void
! 61: cook_xml_text(char * pzData);
! 62:
! 63: static char *
! 64: handle_struct(tOptions * pOpts, tOptState * pOS, char * pzText, int dir);
! 65:
! 66: static char*
! 67: parse_keyword(tOptions * pOpts, char * pzText, tOptionValue * pType);
! 68:
! 69: static char*
! 70: parse_set_mem(tOptions * pOpts, char * pzText, tOptionValue * pType);
! 71:
! 72: static char *
! 73: parse_value(char * pzText, tOptionValue * pType);
! 74:
! 75: static char *
! 76: skip_unkn(char* pzText);
! 77: /* = = = END-STATIC-FORWARD = = = */
! 78:
! 79:
! 80: /*=export_func configFileLoad
! 81: *
! 82: * what: parse a configuration file
! 83: * arg: + char const* + pzFile + the file to load +
! 84: *
! 85: * ret_type: const tOptionValue*
! 86: * ret_desc: An allocated, compound value structure
! 87: *
! 88: * doc:
! 89: * This routine will load a named configuration file and parse the
! 90: * text as a hierarchically valued option. The option descriptor
! 91: * created from an option definition file is not used via this interface.
! 92: * The returned value is "named" with the input file name and is of
! 93: * type "@code{OPARG_TYPE_HIERARCHY}". It may be used in calls to
! 94: * @code{optionGetValue()}, @code{optionNextValue()} and
! 95: * @code{optionUnloadNested()}.
! 96: *
! 97: * err:
! 98: * If the file cannot be loaded or processed, @code{NULL} is returned and
! 99: * @var{errno} is set. It may be set by a call to either @code{open(2)}
! 100: * @code{mmap(2)} or other file system calls, or it may be:
! 101: * @itemize @bullet
! 102: * @item
! 103: * @code{ENOENT} - the file was empty.
! 104: * @item
! 105: * @code{EINVAL} - the file contents are invalid -- not properly formed.
! 106: * @item
! 107: * @code{ENOMEM} - not enough memory to allocate the needed structures.
! 108: * @end itemize
! 109: =*/
! 110: const tOptionValue*
! 111: configFileLoad(char const* pzFile)
! 112: {
! 113: tmap_info_t cfgfile;
! 114: tOptionValue* pRes = NULL;
! 115: tOptionLoadMode save_mode = option_load_mode;
! 116:
! 117: char* pzText =
! 118: text_mmap(pzFile, PROT_READ, MAP_PRIVATE, &cfgfile);
! 119:
! 120: if (TEXT_MMAP_FAILED_ADDR(pzText))
! 121: return NULL; /* errno is set */
! 122:
! 123: option_load_mode = OPTION_LOAD_COOKED;
! 124: pRes = optionLoadNested(pzText, pzFile, strlen(pzFile));
! 125:
! 126: if (pRes == NULL) {
! 127: int err = errno;
! 128: text_munmap(&cfgfile);
! 129: errno = err;
! 130: } else
! 131: text_munmap(&cfgfile);
! 132:
! 133: option_load_mode = save_mode;
! 134: return pRes;
! 135: }
! 136:
! 137:
! 138: /*=export_func optionFindValue
! 139: *
! 140: * what: find a hierarcicaly valued option instance
! 141: * arg: + const tOptDesc* + pOptDesc + an option with a nested arg type +
! 142: * arg: + char const* + name + name of value to find +
! 143: * arg: + char const* + value + the matching value +
! 144: *
! 145: * ret_type: const tOptionValue*
! 146: * ret_desc: a compound value structure
! 147: *
! 148: * doc:
! 149: * This routine will find an entry in a nested value option or configurable.
! 150: * It will search through the list and return a matching entry.
! 151: *
! 152: * err:
! 153: * The returned result is NULL and errno is set:
! 154: * @itemize @bullet
! 155: * @item
! 156: * @code{EINVAL} - the @code{pOptValue} does not point to a valid
! 157: * hierarchical option value.
! 158: * @item
! 159: * @code{ENOENT} - no entry matched the given name.
! 160: * @end itemize
! 161: =*/
! 162: const tOptionValue*
! 163: optionFindValue(const tOptDesc* pOptDesc, char const* pzName,
! 164: char const* pzVal)
! 165: {
! 166: const tOptionValue* pRes = NULL;
! 167:
! 168: if ( (pOptDesc == NULL)
! 169: || (OPTST_GET_ARGTYPE(pOptDesc->fOptState) != OPARG_TYPE_HIERARCHY)) {
! 170: errno = EINVAL;
! 171: }
! 172:
! 173: else if (pOptDesc->optCookie == NULL) {
! 174: errno = ENOENT;
! 175: }
! 176:
! 177: else do {
! 178: tArgList* pAL = pOptDesc->optCookie;
! 179: int ct = pAL->useCt;
! 180: void** ppOV = (void**)(pAL->apzArgs);
! 181:
! 182: if (ct == 0) {
! 183: errno = ENOENT;
! 184: break;
! 185: }
! 186:
! 187: if (pzName == NULL) {
! 188: pRes = (tOptionValue*)*ppOV;
! 189: break;
! 190: }
! 191:
! 192: while (--ct >= 0) {
! 193: const tOptionValue* pOV = *(ppOV++);
! 194: const tOptionValue* pRV = optionGetValue(pOV, pzName);
! 195:
! 196: if (pRV == NULL)
! 197: continue;
! 198:
! 199: if (pzVal == NULL) {
! 200: pRes = pOV;
! 201: break;
! 202: }
! 203: }
! 204: if (pRes == NULL)
! 205: errno = ENOENT;
! 206: } while (0);
! 207:
! 208: return pRes;
! 209: }
! 210:
! 211:
! 212: /*=export_func optionFindNextValue
! 213: *
! 214: * what: find a hierarcicaly valued option instance
! 215: * arg: + const tOptDesc* + pOptDesc + an option with a nested arg type +
! 216: * arg: + const tOptionValue* + pPrevVal + the last entry +
! 217: * arg: + char const* + name + name of value to find +
! 218: * arg: + char const* + value + the matching value +
! 219: *
! 220: * ret_type: const tOptionValue*
! 221: * ret_desc: a compound value structure
! 222: *
! 223: * doc:
! 224: * This routine will find the next entry in a nested value option or
! 225: * configurable. It will search through the list and return the next entry
! 226: * that matches the criteria.
! 227: *
! 228: * err:
! 229: * The returned result is NULL and errno is set:
! 230: * @itemize @bullet
! 231: * @item
! 232: * @code{EINVAL} - the @code{pOptValue} does not point to a valid
! 233: * hierarchical option value.
! 234: * @item
! 235: * @code{ENOENT} - no entry matched the given name.
! 236: * @end itemize
! 237: =*/
! 238: tOptionValue const *
! 239: optionFindNextValue(const tOptDesc * pOptDesc, const tOptionValue * pPrevVal,
! 240: char const * pzName, char const * pzVal)
! 241: {
! 242: int foundOldVal = 0;
! 243: tOptionValue* pRes = NULL;
! 244:
! 245: if ( (pOptDesc == NULL)
! 246: || (OPTST_GET_ARGTYPE(pOptDesc->fOptState) != OPARG_TYPE_HIERARCHY)) {
! 247: errno = EINVAL;
! 248: }
! 249:
! 250: else if (pOptDesc->optCookie == NULL) {
! 251: errno = ENOENT;
! 252: }
! 253:
! 254: else do {
! 255: tArgList* pAL = pOptDesc->optCookie;
! 256: int ct = pAL->useCt;
! 257: void** ppOV = (void**)pAL->apzArgs;
! 258:
! 259: if (ct == 0) {
! 260: errno = ENOENT;
! 261: break;
! 262: }
! 263:
! 264: while (--ct >= 0) {
! 265: tOptionValue* pOV = *(ppOV++);
! 266: if (foundOldVal) {
! 267: pRes = pOV;
! 268: break;
! 269: }
! 270: if (pOV == pPrevVal)
! 271: foundOldVal = 1;
! 272: }
! 273: if (pRes == NULL)
! 274: errno = ENOENT;
! 275: } while (0);
! 276:
! 277: return pRes;
! 278: }
! 279:
! 280:
! 281: /*=export_func optionGetValue
! 282: *
! 283: * what: get a specific value from a hierarcical list
! 284: * arg: + const tOptionValue* + pOptValue + a hierarchcal value +
! 285: * arg: + char const* + valueName + name of value to get +
! 286: *
! 287: * ret_type: const tOptionValue*
! 288: * ret_desc: a compound value structure
! 289: *
! 290: * doc:
! 291: * This routine will find an entry in a nested value option or configurable.
! 292: * If "valueName" is NULL, then the first entry is returned. Otherwise,
! 293: * the first entry with a name that exactly matches the argument will be
! 294: * returned.
! 295: *
! 296: * err:
! 297: * The returned result is NULL and errno is set:
! 298: * @itemize @bullet
! 299: * @item
! 300: * @code{EINVAL} - the @code{pOptValue} does not point to a valid
! 301: * hierarchical option value.
! 302: * @item
! 303: * @code{ENOENT} - no entry matched the given name.
! 304: * @end itemize
! 305: =*/
! 306: const tOptionValue*
! 307: optionGetValue(const tOptionValue* pOld, char const* pzValName)
! 308: {
! 309: tArgList* pAL;
! 310: tOptionValue* pRes = NULL;
! 311:
! 312: if ((pOld == NULL) || (pOld->valType != OPARG_TYPE_HIERARCHY)) {
! 313: errno = EINVAL;
! 314: return NULL;
! 315: }
! 316: pAL = pOld->v.nestVal;
! 317:
! 318: if (pAL->useCt > 0) {
! 319: int ct = pAL->useCt;
! 320: void** papOV = (void**)(pAL->apzArgs);
! 321:
! 322: if (pzValName == NULL) {
! 323: pRes = (tOptionValue*)*papOV;
! 324: }
! 325:
! 326: else do {
! 327: tOptionValue* pOV = *(papOV++);
! 328: if (strcmp(pOV->pzName, pzValName) == 0) {
! 329: pRes = pOV;
! 330: break;
! 331: }
! 332: } while (--ct > 0);
! 333: }
! 334: if (pRes == NULL)
! 335: errno = ENOENT;
! 336: return pRes;
! 337: }
! 338:
! 339:
! 340: /*=export_func optionNextValue
! 341: *
! 342: * what: get the next value from a hierarchical list
! 343: * arg: + const tOptionValue* + pOptValue + a hierarchcal list value +
! 344: * arg: + const tOptionValue* + pOldValue + a value from this list +
! 345: *
! 346: * ret_type: const tOptionValue*
! 347: * ret_desc: a compound value structure
! 348: *
! 349: * doc:
! 350: * This routine will return the next entry after the entry passed in. At the
! 351: * end of the list, NULL will be returned. If the entry is not found on the
! 352: * list, NULL will be returned and "@var{errno}" will be set to EINVAL.
! 353: * The "@var{pOldValue}" must have been gotten from a prior call to this
! 354: * routine or to "@code{opitonGetValue()}".
! 355: *
! 356: * err:
! 357: * The returned result is NULL and errno is set:
! 358: * @itemize @bullet
! 359: * @item
! 360: * @code{EINVAL} - the @code{pOptValue} does not point to a valid
! 361: * hierarchical option value or @code{pOldValue} does not point to a
! 362: * member of that option value.
! 363: * @item
! 364: * @code{ENOENT} - the supplied @code{pOldValue} pointed to the last entry.
! 365: * @end itemize
! 366: =*/
! 367: tOptionValue const *
! 368: optionNextValue(tOptionValue const * pOVList,tOptionValue const * pOldOV )
! 369: {
! 370: tArgList* pAL;
! 371: tOptionValue* pRes = NULL;
! 372: int err = EINVAL;
! 373:
! 374: if ((pOVList == NULL) || (pOVList->valType != OPARG_TYPE_HIERARCHY)) {
! 375: errno = EINVAL;
! 376: return NULL;
! 377: }
! 378: pAL = pOVList->v.nestVal;
! 379: {
! 380: int ct = pAL->useCt;
! 381: void** papNV = (void**)(pAL->apzArgs);
! 382:
! 383: while (ct-- > 0) {
! 384: tOptionValue* pNV = *(papNV++);
! 385: if (pNV == pOldOV) {
! 386: if (ct == 0) {
! 387: err = ENOENT;
! 388:
! 389: } else {
! 390: err = 0;
! 391: pRes = (tOptionValue*)*papNV;
! 392: }
! 393: break;
! 394: }
! 395: }
! 396: }
! 397: if (err != 0)
! 398: errno = err;
! 399: return pRes;
! 400: }
! 401:
! 402:
! 403: /**
! 404: * Load a file containing presetting information (a configuration file).
! 405: */
! 406: static void
! 407: file_preset(tOptions * opts, char const * fname, int dir)
! 408: {
! 409: tmap_info_t cfgfile;
! 410: tOptState optst = OPTSTATE_INITIALIZER(PRESET);
! 411: tAoUL st_flags = optst.flags;
! 412: char * ftext =
! 413: text_mmap(fname, PROT_READ|PROT_WRITE, MAP_PRIVATE, &cfgfile);
! 414:
! 415: if (TEXT_MMAP_FAILED_ADDR(ftext))
! 416: return;
! 417:
! 418: if (dir == DIRECTION_CALLED) {
! 419: st_flags = OPTST_DEFINED;
! 420: dir = DIRECTION_PROCESS;
! 421: }
! 422:
! 423: /*
! 424: * IF this is called via "optionProcess", then we are presetting.
! 425: * This is the default and the PRESETTING bit will be set.
! 426: * If this is called via "optionFileLoad", then the bit is not set
! 427: * and we consider stuff set herein to be "set" by the client program.
! 428: */
! 429: if ((opts->fOptSet & OPTPROC_PRESETTING) == 0)
! 430: st_flags = OPTST_SET;
! 431:
! 432: do {
! 433: optst.flags = st_flags;
! 434: while (IS_WHITESPACE_CHAR(*ftext)) ftext++;
! 435:
! 436: if (IS_VAR_FIRST_CHAR(*ftext)) {
! 437: ftext = handle_cfg(opts, &optst, ftext, dir);
! 438:
! 439: } else switch (*ftext) {
! 440: case '<':
! 441: if (IS_VAR_FIRST_CHAR(ftext[1]))
! 442: ftext = handle_struct(opts, &optst, ftext, dir);
! 443:
! 444: else switch (ftext[1]) {
! 445: case '?':
! 446: ftext = handle_directive(opts, ftext);
! 447: break;
! 448:
! 449: case '!':
! 450: ftext = handle_comment(ftext);
! 451: break;
! 452:
! 453: case '/':
! 454: ftext = strchr(ftext + 2, '>');
! 455: if (ftext++ != NULL)
! 456: break;
! 457:
! 458: default:
! 459: goto all_done;
! 460: }
! 461: break;
! 462:
! 463: case '[':
! 464: ftext = handle_section(opts, ftext);
! 465: break;
! 466:
! 467: case '#':
! 468: ftext = strchr(ftext + 1, '\n');
! 469: break;
! 470:
! 471: default:
! 472: goto all_done; /* invalid format */
! 473: }
! 474: } while (ftext != NULL);
! 475:
! 476: all_done:
! 477: text_munmap(&cfgfile);
! 478: }
! 479:
! 480:
! 481: /**
! 482: * "pzText" points to a "<!" sequence.
! 483: * Theoretically, we should ensure that it begins with "<!--",
! 484: * but actually I don't care that much. It ends with "-->".
! 485: */
! 486: static char*
! 487: handle_comment(char* pzText)
! 488: {
! 489: char* pz = strstr(pzText, "-->");
! 490: if (pz != NULL)
! 491: pz += 3;
! 492: return pz;
! 493: }
! 494:
! 495:
! 496: /**
! 497: * "pzText" points to the start of some value name.
! 498: * The end of the entry is the end of the line that is not preceded by
! 499: * a backslash escape character. The string value is always processed
! 500: * in "cooked" mode.
! 501: */
! 502: static char *
! 503: handle_cfg(tOptions * pOpts, tOptState * pOS, char * pzText, int dir)
! 504: {
! 505: char* pzName = pzText++;
! 506: char* pzEnd = strchr(pzText, '\n');
! 507:
! 508: if (pzEnd == NULL)
! 509: return pzText + strlen(pzText);
! 510:
! 511: while (IS_VALUE_NAME_CHAR(*pzText)) pzText++;
! 512: while (IS_WHITESPACE_CHAR(*pzText)) pzText++;
! 513: if (pzText > pzEnd) {
! 514: name_only:
! 515: *pzEnd++ = NUL;
! 516: loadOptionLine(pOpts, pOS, pzName, dir, OPTION_LOAD_UNCOOKED);
! 517: return pzEnd;
! 518: }
! 519:
! 520: /*
! 521: * Either the first character after the name is a ':' or '=',
! 522: * or else we must have skipped over white space. Anything else
! 523: * is an invalid format and we give up parsing the text.
! 524: */
! 525: if ((*pzText == '=') || (*pzText == ':')) {
! 526: while (IS_WHITESPACE_CHAR(*++pzText)) ;
! 527: if (pzText > pzEnd)
! 528: goto name_only;
! 529: } else if (! IS_WHITESPACE_CHAR(pzText[-1]))
! 530: return NULL;
! 531:
! 532: /*
! 533: * IF the value is continued, remove the backslash escape and push "pzEnd"
! 534: * on to a newline *not* preceded by a backslash.
! 535: */
! 536: if (pzEnd[-1] == '\\') {
! 537: char* pcD = pzEnd-1;
! 538: char* pcS = pzEnd;
! 539:
! 540: for (;;) {
! 541: char ch = *(pcS++);
! 542: switch (ch) {
! 543: case NUL:
! 544: pcS = NULL;
! 545:
! 546: case '\n':
! 547: *pcD = NUL;
! 548: pzEnd = pcS;
! 549: goto copy_done;
! 550:
! 551: case '\\':
! 552: if (*pcS == '\n') {
! 553: ch = *(pcS++);
! 554: }
! 555: /* FALLTHROUGH */
! 556: default:
! 557: *(pcD++) = ch;
! 558: }
! 559: } copy_done:;
! 560:
! 561: } else {
! 562: /*
! 563: * The newline was not preceded by a backslash. NUL it out
! 564: */
! 565: *(pzEnd++) = NUL;
! 566: }
! 567:
! 568: /*
! 569: * "pzName" points to what looks like text for one option/configurable.
! 570: * It is NUL terminated. Process it.
! 571: */
! 572: loadOptionLine(pOpts, pOS, pzName, dir, OPTION_LOAD_UNCOOKED);
! 573:
! 574: return pzEnd;
! 575: }
! 576:
! 577:
! 578: /**
! 579: * "pzText" points to a "<?" sequence.
! 580: * We handle "<?program" and "<?auto-options" directives.
! 581: * All others are treated as comments.
! 582: */
! 583: static char *
! 584: handle_directive(tOptions * pOpts, char * pzText)
! 585: {
! 586: # define DIRECTIVE_TABLE \
! 587: _dt_(zCfgProg, program_directive) \
! 588: _dt_(zCfgAO_Flags, aoflags_directive)
! 589:
! 590: typedef char * (directive_func_t)(tOptions *, char *);
! 591: # define _dt_(_s, _fn) _fn,
! 592: static directive_func_t * dir_disp[] = {
! 593: DIRECTIVE_TABLE
! 594: };
! 595: # undef _dt_
! 596:
! 597: # define _dt_(_s, _fn) 1 +
! 598: static int const dir_ct = DIRECTIVE_TABLE 0;
! 599: static char const * dir_names[DIRECTIVE_TABLE 0];
! 600: # undef _dt_
! 601:
! 602: int ix;
! 603:
! 604: if (dir_names[0] == NULL) {
! 605: ix = 0;
! 606: # define _dt_(_s, _fn) dir_names[ix++] = _s;
! 607: DIRECTIVE_TABLE;
! 608: # undef _dt_
! 609: }
! 610:
! 611: for (ix = 0; ix < dir_ct; ix++) {
! 612: size_t len = strlen(dir_names[ix]);
! 613: if ( (strncmp(pzText + 2, dir_names[ix], len) == 0)
! 614: && (! IS_VALUE_NAME_CHAR(pzText[len+2])) )
! 615: return dir_disp[ix](pOpts, pzText + len + 2);
! 616: }
! 617:
! 618: /*
! 619: * We don't know what this is. Skip it.
! 620: */
! 621: pzText = strchr(pzText+2, '>');
! 622: if (pzText != NULL)
! 623: pzText++;
! 624: return pzText;
! 625: }
! 626:
! 627: /**
! 628: * handle AutoOpts mode flags
! 629: */
! 630: static char *
! 631: aoflags_directive(tOptions * pOpts, char * pzText)
! 632: {
! 633: char * pz = pzText;
! 634:
! 635: while (IS_WHITESPACE_CHAR(*++pz)) ;
! 636: pzText = strchr(pz, '>');
! 637: if (pzText != NULL) {
! 638:
! 639: size_t len = pzText - pz;
! 640: char * ftxt = AGALOC(len + 1, "aoflags");
! 641:
! 642: memcpy(ftxt, pz, len);
! 643: ftxt[len] = NUL;
! 644: set_usage_flags(pOpts, ftxt);
! 645: AGFREE(ftxt);
! 646:
! 647: pzText++;
! 648: }
! 649:
! 650: return pzText;
! 651: }
! 652:
! 653: /**
! 654: * handle program segmentation of config file.
! 655: */
! 656: static char *
! 657: program_directive(tOptions * pOpts, char * pzText)
! 658: {
! 659: static char const ttlfmt[] = "<?";
! 660: size_t ttl_len = sizeof(ttlfmt) + strlen(zCfgProg);
! 661: char * ttl = AGALOC(ttl_len, "prog title");
! 662: size_t name_len = strlen(pOpts->pzProgName);
! 663:
! 664: memcpy(ttl, ttlfmt, sizeof(ttlfmt) - 1);
! 665: memcpy(ttl + sizeof(ttlfmt) - 1, zCfgProg, ttl_len - (sizeof(ttlfmt) - 1));
! 666:
! 667: do {
! 668: while (IS_WHITESPACE_CHAR(*++pzText)) ;
! 669:
! 670: if ( (strneqvcmp(pzText, pOpts->pzProgName, (int)name_len) == 0)
! 671: && (IS_END_XML_TOKEN_CHAR(pzText[name_len])) ) {
! 672: pzText += name_len;
! 673: break;
! 674: }
! 675:
! 676: pzText = strstr(pzText, ttl);
! 677: } while (pzText != NULL);
! 678:
! 679: AGFREE(ttl);
! 680: if (pzText != NULL)
! 681: for (;;) {
! 682: if (*pzText == NUL) {
! 683: pzText = NULL;
! 684: break;
! 685: }
! 686: if (*(pzText++) == '>')
! 687: break;
! 688: }
! 689:
! 690: return pzText;
! 691: }
! 692:
! 693:
! 694: /**
! 695: * "pzText" points to a '[' character.
! 696: * The "traditional" [PROG_NAME] segmentation of the config file.
! 697: * Do not ever mix with the "<?program prog-name>" variation.
! 698: */
! 699: static char *
! 700: handle_section(tOptions * pOpts, char * pzText)
! 701: {
! 702: size_t len = strlen(pOpts->pzPROGNAME);
! 703: if ( (strncmp(pzText+1, pOpts->pzPROGNAME, len) == 0)
! 704: && (pzText[len+1] == ']'))
! 705: return strchr(pzText + len + 2, '\n');
! 706:
! 707: if (len > 16)
! 708: return NULL;
! 709:
! 710: {
! 711: char z[24];
! 712: sprintf(z, "[%s]", pOpts->pzPROGNAME);
! 713: pzText = strstr(pzText, z);
! 714: }
! 715:
! 716: if (pzText != NULL)
! 717: pzText = strchr(pzText, '\n');
! 718: return pzText;
! 719: }
! 720:
! 721: /**
! 722: * parse XML encodings
! 723: */
! 724: static int
! 725: parse_xml_encoding(char ** ppz)
! 726: {
! 727: # define XMLTABLE \
! 728: _xmlNm_(amp, '&') \
! 729: _xmlNm_(lt, '<') \
! 730: _xmlNm_(gt, '>') \
! 731: _xmlNm_(ff, '\f') \
! 732: _xmlNm_(ht, '\t') \
! 733: _xmlNm_(cr, '\r') \
! 734: _xmlNm_(vt, '\v') \
! 735: _xmlNm_(bel, '\a') \
! 736: _xmlNm_(nl, '\n') \
! 737: _xmlNm_(space, ' ') \
! 738: _xmlNm_(quot, '"') \
! 739: _xmlNm_(apos, '\'')
! 740:
! 741: static struct {
! 742: char const * const nm_str;
! 743: unsigned short nm_len;
! 744: short nm_val;
! 745: } const xml_names[] = {
! 746: # define _xmlNm_(_n, _v) { #_n ";", sizeof(#_n), _v },
! 747: XMLTABLE
! 748: # undef _xmlNm_
! 749: # undef XMLTABLE
! 750: };
! 751:
! 752: static int const nm_ct = sizeof(xml_names) / sizeof(xml_names[0]);
! 753: int base = 10;
! 754:
! 755: char * pz = *ppz;
! 756:
! 757: if (*pz == '#') {
! 758: pz++;
! 759: goto parse_number;
! 760: }
! 761:
! 762: if (IS_DEC_DIGIT_CHAR(*pz)) {
! 763: unsigned long v;
! 764:
! 765: parse_number:
! 766: switch (*pz) {
! 767: case 'x': case 'X':
! 768: /*
! 769: * Some forms specify hex with: &#xNN;
! 770: */
! 771: base = 16;
! 772: pz++;
! 773: break;
! 774:
! 775: case '0':
! 776: /*
! 777: *  is hex and  is decimal. Cool.
! 778: * Ya gotta love it.
! 779: */
! 780: if (pz[1] == '0')
! 781: base = 16;
! 782: break;
! 783: }
! 784:
! 785: v = strtoul(pz, &pz, base);
! 786: if ((*pz != ';') || (v > 0x7F))
! 787: return NUL;
! 788: *ppz = pz + 1;
! 789: return (int)v;
! 790: }
! 791:
! 792: {
! 793: int ix = 0;
! 794: do {
! 795: if (strncmp(pz, xml_names[ix].nm_str, xml_names[ix].nm_len)
! 796: == 0) {
! 797: *ppz = pz + xml_names[ix].nm_len;
! 798: return xml_names[ix].nm_val;
! 799: }
! 800: } while (++ix < nm_ct);
! 801: }
! 802:
! 803: return NUL;
! 804: }
! 805:
! 806: /**
! 807: * Find the end marker for the named section of XML.
! 808: * Trim that text there, trimming trailing white space for all modes
! 809: * except for OPTION_LOAD_UNCOOKED.
! 810: */
! 811: static char *
! 812: trim_xml_text(char * pztxt, char const * pznm, tOptionLoadMode mode)
! 813: {
! 814: static char const fmt[] = "</%s>";
! 815: char z[64], *pz = z;
! 816: size_t len = strlen(pznm) + sizeof(fmt) - 2 /* for %s */;
! 817:
! 818: if (len > sizeof(z))
! 819: pz = AGALOC(len, "scan name");
! 820:
! 821: sprintf(pz, fmt, pznm);
! 822: *pztxt = ' ';
! 823: pztxt = strstr(pztxt, pz);
! 824: if (pz != z) AGFREE(pz);
! 825:
! 826: if (pztxt == NULL)
! 827: return pztxt;
! 828:
! 829: if (mode != OPTION_LOAD_UNCOOKED)
! 830: while (IS_WHITESPACE_CHAR(pztxt[-1])) len++, pztxt--;
! 831:
! 832: *pztxt = NUL;
! 833: return pztxt + len - 1 /* for NUL byte */;
! 834: }
! 835:
! 836: /**
! 837: */
! 838: static void
! 839: cook_xml_text(char * pzData)
! 840: {
! 841: char * pzs = pzData;
! 842: char * pzd = pzData;
! 843: char bf[4];
! 844: bf[2] = NUL;
! 845:
! 846: for (;;) {
! 847: int ch = ((int)*(pzs++)) & 0xFF;
! 848: switch (ch) {
! 849: case NUL:
! 850: *pzd = NUL;
! 851: return;
! 852:
! 853: case '&':
! 854: *(pzd++) = \
! 855: ch = parse_xml_encoding(&pzs);
! 856: if (ch == NUL)
! 857: return;
! 858: break;
! 859:
! 860: case '%':
! 861: bf[0] = *(pzs++);
! 862: bf[1] = *(pzs++);
! 863: if ((bf[0] == NUL) || (bf[1] == NUL)) {
! 864: *pzd = NUL;
! 865: return;
! 866: }
! 867:
! 868: ch = strtoul(bf, NULL, 16);
! 869: /* FALLTHROUGH */
! 870:
! 871: default:
! 872: *(pzd++) = ch;
! 873: }
! 874: }
! 875: }
! 876:
! 877: /**
! 878: * "pzText" points to a '<' character, followed by an alpha.
! 879: * The end of the entry is either the "/>" following the name, or else a
! 880: * "</name>" string.
! 881: */
! 882: static char *
! 883: handle_struct(tOptions * pOpts, tOptState * pOS, char * pzText, int dir)
! 884: {
! 885: tOptionLoadMode mode = option_load_mode;
! 886: tOptionValue valu;
! 887:
! 888: char* pzName = ++pzText;
! 889: char* pzData;
! 890: char* pcNulPoint;
! 891:
! 892: while (IS_VALUE_NAME_CHAR(*pzText)) pzText++;
! 893: pcNulPoint = pzText;
! 894: valu.valType = OPARG_TYPE_STRING;
! 895:
! 896: switch (*pzText) {
! 897: case ' ':
! 898: case '\t':
! 899: pzText = parseAttributes(pOpts, pzText, &mode, &valu);
! 900: if (*pzText == '>')
! 901: break;
! 902: if (*pzText != '/')
! 903: return NULL;
! 904: /* FALLTHROUGH */
! 905:
! 906: case '/':
! 907: if (pzText[1] != '>')
! 908: return NULL;
! 909: *pzText = NUL;
! 910: pzText += 2;
! 911: loadOptionLine(pOpts, pOS, pzName, dir, mode);
! 912: return pzText;
! 913:
! 914: case '>':
! 915: break;
! 916:
! 917: default:
! 918: pzText = strchr(pzText, '>');
! 919: if (pzText != NULL)
! 920: pzText++;
! 921: return pzText;
! 922: }
! 923:
! 924: /*
! 925: * If we are here, we have a value. "pzText" points to a closing angle
! 926: * bracket. Separate the name from the value for a moment.
! 927: */
! 928: *pcNulPoint = NUL;
! 929: pzData = ++pzText;
! 930: pzText = trim_xml_text(pzText, pzName, mode);
! 931: if (pzText == NULL)
! 932: return pzText;
! 933:
! 934: /*
! 935: * Rejoin the name and value for parsing by "loadOptionLine()".
! 936: * Erase any attributes parsed by "parseAttributes()".
! 937: */
! 938: memset(pcNulPoint, ' ', pzData - pcNulPoint);
! 939:
! 940: /*
! 941: * If we are getting a "string" value that is to be cooked,
! 942: * then process the XML-ish &xx; XML-ish and %XX hex characters.
! 943: */
! 944: if ( (valu.valType == OPARG_TYPE_STRING)
! 945: && (mode == OPTION_LOAD_COOKED))
! 946: cook_xml_text(pzData);
! 947:
! 948: /*
! 949: * "pzName" points to what looks like text for one option/configurable.
! 950: * It is NUL terminated. Process it.
! 951: */
! 952: loadOptionLine(pOpts, pOS, pzName, dir, mode);
! 953:
! 954: return pzText;
! 955: }
! 956:
! 957:
! 958: /**
! 959: * Load a configuration file. This may be invoked either from
! 960: * scanning the "homerc" list, or from a specific file request.
! 961: * (see "optionFileLoad()", the implementation for --load-opts)
! 962: */
! 963: LOCAL void
! 964: internalFileLoad(tOptions* pOpts)
! 965: {
! 966: uint32_t svfl;
! 967: int idx;
! 968: int inc;
! 969: char zFileName[ AG_PATH_MAX+1 ];
! 970:
! 971: if (pOpts->papzHomeList == NULL)
! 972: return;
! 973:
! 974: svfl = pOpts->fOptSet;
! 975: inc = DIRECTION_PRESET;
! 976:
! 977: /*
! 978: * Never stop on errors in config files.
! 979: */
! 980: pOpts->fOptSet &= ~OPTPROC_ERRSTOP;
! 981:
! 982: /*
! 983: * Find the last RC entry (highest priority entry)
! 984: */
! 985: for (idx = 0; pOpts->papzHomeList[ idx+1 ] != NULL; ++idx) ;
! 986:
! 987: /*
! 988: * For every path in the home list, ... *TWICE* We start at the last
! 989: * (highest priority) entry, work our way down to the lowest priority,
! 990: * handling the immediate options.
! 991: * Then we go back up, doing the normal options.
! 992: */
! 993: for (;;) {
! 994: struct stat StatBuf;
! 995: cch_t* pzPath;
! 996:
! 997: /*
! 998: * IF we've reached the bottom end, change direction
! 999: */
! 1000: if (idx < 0) {
! 1001: inc = DIRECTION_PROCESS;
! 1002: idx = 0;
! 1003: }
! 1004:
! 1005: pzPath = pOpts->papzHomeList[ idx ];
! 1006:
! 1007: /*
! 1008: * IF we've reached the top end, bail out
! 1009: */
! 1010: if (pzPath == NULL)
! 1011: break;
! 1012:
! 1013: idx += inc;
! 1014:
! 1015: if (! optionMakePath(zFileName, (int)sizeof(zFileName),
! 1016: pzPath, pOpts->pzProgPath))
! 1017: continue;
! 1018:
! 1019: /*
! 1020: * IF the file name we constructed is a directory,
! 1021: * THEN append the Resource Configuration file name
! 1022: * ELSE we must have the complete file name
! 1023: */
! 1024: if (stat(zFileName, &StatBuf) != 0)
! 1025: continue; /* bogus name - skip the home list entry */
! 1026:
! 1027: if (S_ISDIR(StatBuf.st_mode)) {
! 1028: size_t len = strlen(zFileName);
! 1029: size_t nln = strlen(pOpts->pzRcName) + 1;
! 1030: char * pz = zFileName + len;
! 1031:
! 1032: if (len + 1 + nln >= sizeof(zFileName))
! 1033: continue;
! 1034:
! 1035: if (pz[-1] != DIRCH)
! 1036: *(pz++) = DIRCH;
! 1037: memcpy(pz, pOpts->pzRcName, nln);
! 1038: }
! 1039:
! 1040: file_preset(pOpts, zFileName, inc);
! 1041:
! 1042: /*
! 1043: * IF we are now to skip config files AND we are presetting,
! 1044: * THEN change direction. We must go the other way.
! 1045: */
! 1046: {
! 1047: tOptDesc * pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts+1;
! 1048: if (DISABLED_OPT(pOD) && PRESETTING(inc)) {
! 1049: idx -= inc; /* go back and reprocess current file */
! 1050: inc = DIRECTION_PROCESS;
! 1051: }
! 1052: }
! 1053: } /* twice for every path in the home list, ... */
! 1054:
! 1055: pOpts->fOptSet = svfl;
! 1056: }
! 1057:
! 1058:
! 1059: /*=export_func optionFileLoad
! 1060: *
! 1061: * what: Load the locatable config files, in order
! 1062: *
! 1063: * arg: + tOptions* + pOpts + program options descriptor +
! 1064: * arg: + char const* + pzProg + program name +
! 1065: *
! 1066: * ret_type: int
! 1067: * ret_desc: 0 -> SUCCESS, -1 -> FAILURE
! 1068: *
! 1069: * doc:
! 1070: *
! 1071: * This function looks in all the specified directories for a configuration
! 1072: * file ("rc" file or "ini" file) and processes any found twice. The first
! 1073: * time through, they are processed in reverse order (last file first). At
! 1074: * that time, only "immediate action" configurables are processed. For
! 1075: * example, if the last named file specifies not processing any more
! 1076: * configuration files, then no more configuration files will be processed.
! 1077: * Such an option in the @strong{first} named directory will have no effect.
! 1078: *
! 1079: * Once the immediate action configurables have been handled, then the
! 1080: * directories are handled in normal, forward order. In that way, later
! 1081: * config files can override the settings of earlier config files.
! 1082: *
! 1083: * See the AutoOpts documentation for a thorough discussion of the
! 1084: * config file format.
! 1085: *
! 1086: * Configuration files not found or not decipherable are simply ignored.
! 1087: *
! 1088: * err: Returns the value, "-1" if the program options descriptor
! 1089: * is out of date or indecipherable. Otherwise, the value "0" will
! 1090: * always be returned.
! 1091: =*/
! 1092: int
! 1093: optionFileLoad(tOptions* pOpts, char const* pzProgram)
! 1094: {
! 1095: if (! SUCCESSFUL(validateOptionsStruct(pOpts, pzProgram)))
! 1096: return -1;
! 1097:
! 1098: {
! 1099: char const ** pp =
! 1100: (char const **)(void *)&(pOpts->pzProgName);
! 1101: *pp = pzProgram;
! 1102: }
! 1103:
! 1104: internalFileLoad(pOpts);
! 1105: return 0;
! 1106: }
! 1107:
! 1108:
! 1109: /*=export_func optionLoadOpt
! 1110: * private:
! 1111: *
! 1112: * what: Load an option rc/ini file
! 1113: * arg: + tOptions* + pOpts + program options descriptor +
! 1114: * arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
! 1115: *
! 1116: * doc:
! 1117: * Processes the options found in the file named with
! 1118: * pOptDesc->optArg.argString.
! 1119: =*/
! 1120: void
! 1121: optionLoadOpt(tOptions* pOpts, tOptDesc* pOptDesc)
! 1122: {
! 1123: struct stat sb;
! 1124:
! 1125: /*
! 1126: * IF the option is not being disabled, THEN load the file. There must
! 1127: * be a file. (If it is being disabled, then the disablement processing
! 1128: * already took place. It must be done to suppress preloading of ini/rc
! 1129: * files.)
! 1130: */
! 1131: if ( DISABLED_OPT(pOptDesc)
! 1132: || ((pOptDesc->fOptState & OPTST_RESET) != 0))
! 1133: return;
! 1134:
! 1135: if (stat(pOptDesc->optArg.argString, &sb) != 0) {
! 1136: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0)
! 1137: return;
! 1138:
! 1139: fprintf(stderr, zFSErrOptLoad, errno, strerror(errno),
! 1140: pOptDesc->optArg.argString);
! 1141: exit(EX_NOINPUT);
! 1142: /* NOT REACHED */
! 1143: }
! 1144:
! 1145: if (! S_ISREG(sb.st_mode)) {
! 1146: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0)
! 1147: return;
! 1148:
! 1149: fprintf(stderr, zNotFile, pOptDesc->optArg.argString);
! 1150: exit(EX_NOINPUT);
! 1151: /* NOT REACHED */
! 1152: }
! 1153:
! 1154: file_preset(pOpts, pOptDesc->optArg.argString, DIRECTION_CALLED);
! 1155: }
! 1156:
! 1157:
! 1158: /**
! 1159: * Parse the various attributes of an XML-styled config file entry
! 1160: */
! 1161: LOCAL char*
! 1162: parseAttributes(
! 1163: tOptions* pOpts,
! 1164: char* pzText,
! 1165: tOptionLoadMode* pMode,
! 1166: tOptionValue* pType )
! 1167: {
! 1168: size_t len;
! 1169:
! 1170: do {
! 1171: if (! IS_WHITESPACE_CHAR(*pzText))
! 1172: switch (*pzText) {
! 1173: case '/': pType->valType = OPARG_TYPE_NONE;
! 1174: case '>': return pzText;
! 1175:
! 1176: default:
! 1177: case NUL: return NULL;
! 1178: }
! 1179:
! 1180: while (IS_WHITESPACE_CHAR(*++pzText)) ;
! 1181: len = 0;
! 1182: while (IS_LOWER_CASE_CHAR(pzText[len])) len++;
! 1183:
! 1184: switch (find_xat_attribute_id(pzText, len)) {
! 1185: case XAT_KWD_TYPE:
! 1186: pzText = parse_value(pzText+len, pType);
! 1187: break;
! 1188:
! 1189: case XAT_KWD_WORDS:
! 1190: pzText = parse_keyword(pOpts, pzText+len, pType);
! 1191: break;
! 1192:
! 1193: case XAT_KWD_MEMBERS:
! 1194: pzText = parse_set_mem(pOpts, pzText+len, pType);
! 1195: break;
! 1196:
! 1197: case XAT_KWD_COOKED:
! 1198: pzText += len;
! 1199: if (! IS_END_XML_TOKEN_CHAR(*pzText))
! 1200: goto invalid_kwd;
! 1201:
! 1202: *pMode = OPTION_LOAD_COOKED;
! 1203: break;
! 1204:
! 1205: case XAT_KWD_UNCOOKED:
! 1206: pzText += len;
! 1207: if (! IS_END_XML_TOKEN_CHAR(*pzText))
! 1208: goto invalid_kwd;
! 1209:
! 1210: *pMode = OPTION_LOAD_UNCOOKED;
! 1211: break;
! 1212:
! 1213: case XAT_KWD_KEEP:
! 1214: pzText += len;
! 1215: if (! IS_END_XML_TOKEN_CHAR(*pzText))
! 1216: goto invalid_kwd;
! 1217:
! 1218: *pMode = OPTION_LOAD_KEEP;
! 1219: break;
! 1220:
! 1221: default:
! 1222: case XAT_KWD_INVALID:
! 1223: invalid_kwd:
! 1224: pType->valType = OPARG_TYPE_NONE;
! 1225: return skip_unkn(pzText);
! 1226: }
! 1227: } while (pzText != NULL);
! 1228:
! 1229: return pzText;
! 1230: }
! 1231:
! 1232:
! 1233: /**
! 1234: * "pzText" points to the character after "words=".
! 1235: * What should follow is a name of a keyword (enumeration) list.
! 1236: */
! 1237: static char*
! 1238: parse_keyword(tOptions * pOpts, char * pzText, tOptionValue * pType)
! 1239: {
! 1240: return skip_unkn(pzText);
! 1241: }
! 1242:
! 1243:
! 1244: /**
! 1245: * "pzText" points to the character after "members="
! 1246: * What should follow is a name of a "set membership".
! 1247: * A collection of bit flags.
! 1248: */
! 1249: static char*
! 1250: parse_set_mem(tOptions * pOpts, char * pzText, tOptionValue * pType)
! 1251: {
! 1252: return skip_unkn(pzText);
! 1253: }
! 1254:
! 1255:
! 1256: /**
! 1257: * "pzText" points to the character after "type="
! 1258: */
! 1259: static char *
! 1260: parse_value(char * pzText, tOptionValue * pType)
! 1261: {
! 1262: size_t len = 0;
! 1263:
! 1264: if (*(pzText++) != '=')
! 1265: goto woops;
! 1266:
! 1267: while (IS_OPTION_NAME_CHAR(pzText[len])) len++;
! 1268: pzText += len;
! 1269:
! 1270: if ((len == 0) || (! IS_END_XML_TOKEN_CHAR(*pzText))) {
! 1271: woops:
! 1272: pType->valType = OPARG_TYPE_NONE;
! 1273: return skip_unkn(pzText);
! 1274: }
! 1275:
! 1276: switch (find_value_type_id(pzText - len, len)) {
! 1277: default:
! 1278: case VTP_KWD_INVALID: goto woops;
! 1279:
! 1280: case VTP_KWD_STRING:
! 1281: pType->valType = OPARG_TYPE_STRING;
! 1282: break;
! 1283:
! 1284: case VTP_KWD_INTEGER:
! 1285: pType->valType = OPARG_TYPE_NUMERIC;
! 1286: break;
! 1287:
! 1288: case VTP_KWD_BOOL:
! 1289: case VTP_KWD_BOOLEAN:
! 1290: pType->valType = OPARG_TYPE_BOOLEAN;
! 1291: break;
! 1292:
! 1293: case VTP_KWD_KEYWORD:
! 1294: pType->valType = OPARG_TYPE_ENUMERATION;
! 1295: break;
! 1296:
! 1297: case VTP_KWD_SET:
! 1298: case VTP_KWD_SET_MEMBERSHIP:
! 1299: pType->valType = OPARG_TYPE_MEMBERSHIP;
! 1300: break;
! 1301:
! 1302: case VTP_KWD_NESTED:
! 1303: case VTP_KWD_HIERARCHY:
! 1304: pType->valType = OPARG_TYPE_HIERARCHY;
! 1305: }
! 1306:
! 1307: return pzText;
! 1308: }
! 1309:
! 1310:
! 1311: /**
! 1312: * Skip over some unknown attribute
! 1313: */
! 1314: static char *
! 1315: skip_unkn(char* pzText)
! 1316: {
! 1317: for (;; pzText++) {
! 1318: if (IS_END_XML_TOKEN_CHAR(*pzText)) return pzText;
! 1319: if (*pzText == NUL) return NULL;
! 1320: }
! 1321: }
! 1322:
! 1323:
! 1324: /**
! 1325: * Make sure the option descriptor is there and that we understand it.
! 1326: * This should be called from any user entry point where one needs to
! 1327: * worry about validity. (Some entry points are free to assume that
! 1328: * the call is not the first to the library and, thus, that this has
! 1329: * already been called.)
! 1330: */
! 1331: LOCAL tSuccess
! 1332: validateOptionsStruct(tOptions* pOpts, char const* pzProgram)
! 1333: {
! 1334: if (pOpts == NULL) {
! 1335: fputs(zAO_Bad, stderr);
! 1336: exit(EX_CONFIG);
! 1337: }
! 1338:
! 1339: /*
! 1340: * IF the client has enabled translation and the translation procedure
! 1341: * is available, then go do it.
! 1342: */
! 1343: if ( ((pOpts->fOptSet & OPTPROC_TRANSLATE) != 0)
! 1344: && (pOpts->pTransProc != NULL) ) {
! 1345: /*
! 1346: * If option names are not to be translated at all, then do not do
! 1347: * it for configuration parsing either. (That is the bit that really
! 1348: * gets tested anyway.)
! 1349: */
! 1350: if ((pOpts->fOptSet & OPTPROC_NO_XLAT_MASK) == OPTPROC_NXLAT_OPT)
! 1351: pOpts->fOptSet |= OPTPROC_NXLAT_OPT_CFG;
! 1352: (*pOpts->pTransProc)();
! 1353: pOpts->fOptSet &= ~OPTPROC_TRANSLATE;
! 1354: }
! 1355:
! 1356: /*
! 1357: * IF the struct version is not the current, and also
! 1358: * either too large (?!) or too small,
! 1359: * THEN emit error message and fail-exit
! 1360: */
! 1361: if ( ( pOpts->structVersion != OPTIONS_STRUCT_VERSION )
! 1362: && ( (pOpts->structVersion > OPTIONS_STRUCT_VERSION )
! 1363: || (pOpts->structVersion < OPTIONS_MINIMUM_VERSION )
! 1364: ) ) {
! 1365: static char const aover[] =
! 1366: __STR(AO_CURRENT)":"__STR(AO_REVISION)":"__STR(AO_AGE)"\n";
! 1367:
! 1368: fprintf(stderr, zAO_Err, pzProgram, NUM_TO_VER(pOpts->structVersion));
! 1369: if (pOpts->structVersion > OPTIONS_STRUCT_VERSION )
! 1370: fputs(zAO_Big, stderr);
! 1371: else
! 1372: fputs(zAO_Sml, stderr);
! 1373:
! 1374: fwrite(aover, sizeof(aover) - 1, 1, stderr);
! 1375: return FAILURE;
! 1376: }
! 1377:
! 1378: /*
! 1379: * If the program name hasn't been set, then set the name and the path
! 1380: * and the set of equivalent characters.
! 1381: */
! 1382: if (pOpts->pzProgName == NULL) {
! 1383: char const * pz = strrchr(pzProgram, DIRCH);
! 1384: char const ** pp =
! 1385: (char const **)(void **)&(pOpts->pzProgName);
! 1386: if (pz == NULL)
! 1387: *pp = pzProgram;
! 1388: else *pp = pz+1;
! 1389:
! 1390: pp = (char const **)(void **)&(pOpts->pzProgPath);
! 1391: *pp = pzProgram;
! 1392:
! 1393: /*
! 1394: * when comparing long names, these are equivalent
! 1395: */
! 1396: strequate(zSepChars);
! 1397: }
! 1398:
! 1399: return SUCCESS;
! 1400: }
! 1401:
! 1402:
! 1403: /**
! 1404: * Local Variables:
! 1405: * mode: C
! 1406: * c-file-style: "stroustrup"
! 1407: * indent-tabs-mode: nil
! 1408: * End:
! 1409: * end of autoopts/configfile.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to configfile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts