Annotation of embedaddon/ntp/sntp/libopts/load.c, revision 1.1
1.1 ! misho 1:
! 2: /**
! 3: * \file load.c
! 4: * Time-stamp: "2010-12-18 11:46:07 bkorb"
! 5: *
! 6: * This file contains the routines that deal with processing text strings
! 7: * for options, either from a NUL-terminated string passed in or from an
! 8: * rc/ini file.
! 9: *
! 10: * This file is part of AutoOpts, a companion to AutoGen.
! 11: * AutoOpts is free software.
! 12: * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
! 13: *
! 14: * AutoOpts is available under any one of two licenses. The license
! 15: * in use must be one of these two and the choice is under the control
! 16: * of the user of the license.
! 17: *
! 18: * The GNU Lesser General Public License, version 3 or later
! 19: * See the files "COPYING.lgplv3" and "COPYING.gplv3"
! 20: *
! 21: * The Modified Berkeley Software Distribution License
! 22: * See the file "COPYING.mbsd"
! 23: *
! 24: * These files have the following md5sums:
! 25: *
! 26: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
! 27: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
! 28: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
! 29: */
! 30:
! 31: /* = = = START-STATIC-FORWARD = = = */
! 32: static ag_bool
! 33: insertProgramPath(char * pzBuf, int bufSize, char const * pzName,
! 34: char const * pzProgPath);
! 35:
! 36: static ag_bool
! 37: insertEnvVal(char * pzBuf, int bufSize, char const * pzName,
! 38: char const * pzProgPath);
! 39:
! 40: static char*
! 41: assembleArgValue(char* pzTxt, tOptionLoadMode mode);
! 42: /* = = = END-STATIC-FORWARD = = = */
! 43:
! 44: /*=export_func optionMakePath
! 45: * private:
! 46: *
! 47: * what: translate and construct a path
! 48: * arg: + char* + pzBuf + The result buffer +
! 49: * arg: + int + bufSize + The size of this buffer +
! 50: * arg: + char const* + pzName + The input name +
! 51: * arg: + char const* + pzProgPath + The full path of the current program +
! 52: *
! 53: * ret-type: ag_bool
! 54: * ret-desc: AG_TRUE if the name was handled, otherwise AG_FALSE.
! 55: * If the name does not start with ``$'', then it is handled
! 56: * simply by copying the input name to the output buffer and
! 57: * resolving the name with either
! 58: * @code{canonicalize_file_name(3GLIBC)} or @code{realpath(3C)}.
! 59: *
! 60: * doc:
! 61: *
! 62: * This routine will copy the @code{pzName} input name into the
! 63: * @code{pzBuf} output buffer, not exceeding @code{bufSize} bytes. If the
! 64: * first character of the input name is a @code{'$'} character, then there
! 65: * is special handling:
! 66: * @*
! 67: * @code{$$} is replaced with the directory name of the @code{pzProgPath},
! 68: * searching @code{$PATH} if necessary.
! 69: * @*
! 70: * @code{$@} is replaced with the AutoGen package data installation directory
! 71: * (aka @code{pkgdatadir}).
! 72: * @*
! 73: * @code{$NAME} is replaced by the contents of the @code{NAME} environment
! 74: * variable. If not found, the search fails.
! 75: *
! 76: * Please note: both @code{$$} and @code{$NAME} must be at the start of the
! 77: * @code{pzName} string and must either be the entire string or be followed
! 78: * by the @code{'/'} (backslash on windows) character.
! 79: *
! 80: * err: @code{AG_FALSE} is returned if:
! 81: * @*
! 82: * @bullet{} The input name exceeds @code{bufSize} bytes.
! 83: * @*
! 84: * @bullet{} @code{$$}, @code{$@@} or @code{$NAME} is not the full string
! 85: * and the next character is not '/'.
! 86: * @*
! 87: * @bullet{} libopts was built without PKGDATADIR defined and @code{$@@}
! 88: * was specified.
! 89: * @*
! 90: * @bullet{} @code{NAME} is not a known environment variable
! 91: * @*
! 92: * @bullet{} @code{canonicalize_file_name} or @code{realpath} return
! 93: * errors (cannot resolve the resulting path).
! 94: =*/
! 95: ag_bool
! 96: optionMakePath(char * pzBuf, int bufSize, char const * pzName,
! 97: char const * pzProgPath)
! 98: {
! 99: size_t name_len = strlen(pzName);
! 100:
! 101: if ((bufSize <= name_len) || (name_len == 0))
! 102: return AG_FALSE;
! 103:
! 104: /*
! 105: * IF not an environment variable, just copy the data
! 106: */
! 107: if (*pzName != '$') {
! 108: char const* pzS = pzName;
! 109: char* pzD = pzBuf;
! 110: int ct = bufSize;
! 111:
! 112: for (;;) {
! 113: if ( (*(pzD++) = *(pzS++)) == NUL)
! 114: break;
! 115: if (--ct <= 0)
! 116: return AG_FALSE;
! 117: }
! 118: }
! 119:
! 120: /*
! 121: * IF the name starts with "$$", then it must be "$$" or
! 122: * it must start with "$$/". In either event, replace the "$$"
! 123: * with the path to the executable and append a "/" character.
! 124: */
! 125: else switch (pzName[1]) {
! 126: case NUL:
! 127: return AG_FALSE;
! 128:
! 129: case '$':
! 130: if (! insertProgramPath(pzBuf, bufSize, pzName, pzProgPath))
! 131: return AG_FALSE;
! 132: break;
! 133:
! 134: case '@':
! 135: if (program_pkgdatadir[0] == NUL)
! 136: return AG_FALSE;
! 137:
! 138: if (snprintf(pzBuf, bufSize, "%s%s", program_pkgdatadir, pzName + 2)
! 139: >= bufSize)
! 140: return AG_FALSE;
! 141: break;
! 142:
! 143: default:
! 144: if (! insertEnvVal(pzBuf, bufSize, pzName, pzProgPath))
! 145: return AG_FALSE;
! 146: }
! 147:
! 148: #if defined(HAVE_CANONICALIZE_FILE_NAME)
! 149: {
! 150: char * pz = canonicalize_file_name(pzBuf);
! 151: if (pz == NULL)
! 152: return AG_FALSE;
! 153:
! 154: name_len = strlen(pz);
! 155: if (name_len >= bufSize) {
! 156: free(pz);
! 157: return AG_FALSE;
! 158: }
! 159:
! 160: memcpy(pzBuf, pz, name_len + 1);
! 161: free(pz);
! 162: }
! 163:
! 164: #elif defined(HAVE_REALPATH)
! 165: {
! 166: char z[PATH_MAX+1];
! 167:
! 168: if (realpath(pzBuf, z) == NULL)
! 169: return AG_FALSE;
! 170:
! 171: name_len = strlen(z);
! 172: if (name_len >= bufSize)
! 173: return AG_FALSE;
! 174:
! 175: memcpy(pzBuf, z, name_len + 1);
! 176: }
! 177: #endif
! 178:
! 179: return AG_TRUE;
! 180: }
! 181:
! 182:
! 183: static ag_bool
! 184: insertProgramPath(char * pzBuf, int bufSize, char const * pzName,
! 185: char const * pzProgPath)
! 186: {
! 187: char const* pzPath;
! 188: char const* pz;
! 189: int skip = 2;
! 190:
! 191: switch (pzName[2]) {
! 192: case DIRCH:
! 193: skip = 3;
! 194: case NUL:
! 195: break;
! 196: default:
! 197: return AG_FALSE;
! 198: }
! 199:
! 200: /*
! 201: * See if the path is included in the program name.
! 202: * If it is, we're done. Otherwise, we have to hunt
! 203: * for the program using "pathfind".
! 204: */
! 205: if (strchr(pzProgPath, DIRCH) != NULL)
! 206: pzPath = pzProgPath;
! 207: else {
! 208: pzPath = pathfind(getenv("PATH"), (char*)pzProgPath, "rx");
! 209:
! 210: if (pzPath == NULL)
! 211: return AG_FALSE;
! 212: }
! 213:
! 214: pz = strrchr(pzPath, DIRCH);
! 215:
! 216: /*
! 217: * IF we cannot find a directory name separator,
! 218: * THEN we do not have a path name to our executable file.
! 219: */
! 220: if (pz == NULL)
! 221: return AG_FALSE;
! 222:
! 223: pzName += skip;
! 224:
! 225: /*
! 226: * Concatenate the file name to the end of the executable path.
! 227: * The result may be either a file or a directory.
! 228: */
! 229: if ((pz - pzPath)+1 + strlen(pzName) >= bufSize)
! 230: return AG_FALSE;
! 231:
! 232: memcpy(pzBuf, pzPath, (size_t)((pz - pzPath)+1));
! 233: strcpy(pzBuf + (pz - pzPath) + 1, pzName);
! 234:
! 235: /*
! 236: * If the "pzPath" path was gotten from "pathfind()", then it was
! 237: * allocated and we need to deallocate it.
! 238: */
! 239: if (pzPath != pzProgPath)
! 240: AGFREE(pzPath);
! 241: return AG_TRUE;
! 242: }
! 243:
! 244:
! 245: static ag_bool
! 246: insertEnvVal(char * pzBuf, int bufSize, char const * pzName,
! 247: char const * pzProgPath)
! 248: {
! 249: char* pzDir = pzBuf;
! 250:
! 251: for (;;) {
! 252: int ch = (int)*++pzName;
! 253: if (! IS_VALUE_NAME_CHAR(ch))
! 254: break;
! 255: *(pzDir++) = (char)ch;
! 256: }
! 257:
! 258: if (pzDir == pzBuf)
! 259: return AG_FALSE;
! 260:
! 261: *pzDir = NUL;
! 262:
! 263: pzDir = getenv(pzBuf);
! 264:
! 265: /*
! 266: * Environment value not found -- skip the home list entry
! 267: */
! 268: if (pzDir == NULL)
! 269: return AG_FALSE;
! 270:
! 271: if (strlen(pzDir) + 1 + strlen(pzName) >= bufSize)
! 272: return AG_FALSE;
! 273:
! 274: sprintf(pzBuf, "%s%s", pzDir, pzName);
! 275: return AG_TRUE;
! 276: }
! 277:
! 278:
! 279: LOCAL void
! 280: mungeString(char* pzTxt, tOptionLoadMode mode)
! 281: {
! 282: char* pzE;
! 283:
! 284: if (mode == OPTION_LOAD_KEEP)
! 285: return;
! 286:
! 287: if (IS_WHITESPACE_CHAR(*pzTxt)) {
! 288: char* pzS = pzTxt;
! 289: char* pzD = pzTxt;
! 290: while (IS_WHITESPACE_CHAR(*++pzS)) ;
! 291: while ((*(pzD++) = *(pzS++)) != NUL) ;
! 292: pzE = pzD-1;
! 293: } else
! 294: pzE = pzTxt + strlen(pzTxt);
! 295:
! 296: while ((pzE > pzTxt) && IS_WHITESPACE_CHAR(pzE[-1])) pzE--;
! 297: *pzE = NUL;
! 298:
! 299: if (mode == OPTION_LOAD_UNCOOKED)
! 300: return;
! 301:
! 302: switch (*pzTxt) {
! 303: default: return;
! 304: case '"':
! 305: case '\'': break;
! 306: }
! 307:
! 308: switch (pzE[-1]) {
! 309: default: return;
! 310: case '"':
! 311: case '\'': break;
! 312: }
! 313:
! 314: (void)ao_string_cook(pzTxt, NULL);
! 315: }
! 316:
! 317:
! 318: static char*
! 319: assembleArgValue(char* pzTxt, tOptionLoadMode mode)
! 320: {
! 321: static char const zBrk[] = " \t\n:=";
! 322: char* pzEnd = strpbrk(pzTxt, zBrk);
! 323: int space_break;
! 324:
! 325: /*
! 326: * Not having an argument to a configurable name is okay.
! 327: */
! 328: if (pzEnd == NULL)
! 329: return pzTxt + strlen(pzTxt);
! 330:
! 331: /*
! 332: * If we are keeping all whitespace, then the modevalue starts with the
! 333: * character that follows the end of the configurable name, regardless
! 334: * of which character caused it.
! 335: */
! 336: if (mode == OPTION_LOAD_KEEP) {
! 337: *(pzEnd++) = NUL;
! 338: return pzEnd;
! 339: }
! 340:
! 341: /*
! 342: * If the name ended on a white space character, remember that
! 343: * because we'll have to skip over an immediately following ':' or '='
! 344: * (and the white space following *that*).
! 345: */
! 346: space_break = IS_WHITESPACE_CHAR(*pzEnd);
! 347: *(pzEnd++) = NUL;
! 348: while (IS_WHITESPACE_CHAR(*pzEnd)) pzEnd++;
! 349: if (space_break && ((*pzEnd == ':') || (*pzEnd == '=')))
! 350: while (IS_WHITESPACE_CHAR(*++pzEnd)) ;
! 351:
! 352: return pzEnd;
! 353: }
! 354:
! 355:
! 356: /*
! 357: * Load an option from a block of text. The text must start with the
! 358: * configurable/option name and be followed by its associated value.
! 359: * That value may be processed in any of several ways. See "tOptionLoadMode"
! 360: * in autoopts.h.
! 361: */
! 362: LOCAL void
! 363: loadOptionLine(
! 364: tOptions* pOpts,
! 365: tOptState* pOS,
! 366: char* pzLine,
! 367: tDirection direction,
! 368: tOptionLoadMode load_mode )
! 369: {
! 370: while (IS_WHITESPACE_CHAR(*pzLine)) pzLine++;
! 371:
! 372: {
! 373: char* pzArg = assembleArgValue(pzLine, load_mode);
! 374:
! 375: if (! SUCCESSFUL(longOptionFind(pOpts, pzLine, pOS)))
! 376: return;
! 377: if (pOS->flags & OPTST_NO_INIT)
! 378: return;
! 379: pOS->pzOptArg = pzArg;
! 380: }
! 381:
! 382: switch (pOS->flags & (OPTST_IMM|OPTST_DISABLE_IMM)) {
! 383: case 0:
! 384: /*
! 385: * The selected option has no immediate action.
! 386: * THEREFORE, if the direction is PRESETTING
! 387: * THEN we skip this option.
! 388: */
! 389: if (PRESETTING(direction))
! 390: return;
! 391: break;
! 392:
! 393: case OPTST_IMM:
! 394: if (PRESETTING(direction)) {
! 395: /*
! 396: * We are in the presetting direction with an option we handle
! 397: * immediately for enablement, but normally for disablement.
! 398: * Therefore, skip if disabled.
! 399: */
! 400: if ((pOS->flags & OPTST_DISABLED) == 0)
! 401: return;
! 402: } else {
! 403: /*
! 404: * We are in the processing direction with an option we handle
! 405: * immediately for enablement, but normally for disablement.
! 406: * Therefore, skip if NOT disabled.
! 407: */
! 408: if ((pOS->flags & OPTST_DISABLED) != 0)
! 409: return;
! 410: }
! 411: break;
! 412:
! 413: case OPTST_DISABLE_IMM:
! 414: if (PRESETTING(direction)) {
! 415: /*
! 416: * We are in the presetting direction with an option we handle
! 417: * immediately for disablement, but normally for disablement.
! 418: * Therefore, skip if NOT disabled.
! 419: */
! 420: if ((pOS->flags & OPTST_DISABLED) != 0)
! 421: return;
! 422: } else {
! 423: /*
! 424: * We are in the processing direction with an option we handle
! 425: * immediately for disablement, but normally for disablement.
! 426: * Therefore, skip if disabled.
! 427: */
! 428: if ((pOS->flags & OPTST_DISABLED) == 0)
! 429: return;
! 430: }
! 431: break;
! 432:
! 433: case OPTST_IMM|OPTST_DISABLE_IMM:
! 434: /*
! 435: * The selected option is always for immediate action.
! 436: * THEREFORE, if the direction is PROCESSING
! 437: * THEN we skip this option.
! 438: */
! 439: if (PROCESSING(direction))
! 440: return;
! 441: break;
! 442: }
! 443:
! 444: /*
! 445: * Fix up the args.
! 446: */
! 447: if (OPTST_GET_ARGTYPE(pOS->pOD->fOptState) == OPARG_TYPE_NONE) {
! 448: if (*pOS->pzOptArg != NUL)
! 449: return;
! 450: pOS->pzOptArg = NULL;
! 451:
! 452: } else if (pOS->pOD->fOptState & OPTST_ARG_OPTIONAL) {
! 453: if (*pOS->pzOptArg == NUL)
! 454: pOS->pzOptArg = NULL;
! 455: else {
! 456: AGDUPSTR(pOS->pzOptArg, pOS->pzOptArg, "option argument");
! 457: pOS->flags |= OPTST_ALLOC_ARG;
! 458: }
! 459:
! 460: } else {
! 461: if (*pOS->pzOptArg == NUL)
! 462: pOS->pzOptArg = zNil;
! 463: else {
! 464: AGDUPSTR(pOS->pzOptArg, pOS->pzOptArg, "option argument");
! 465: pOS->flags |= OPTST_ALLOC_ARG;
! 466: }
! 467: }
! 468:
! 469: {
! 470: tOptionLoadMode sv = option_load_mode;
! 471: option_load_mode = load_mode;
! 472: handle_opt(pOpts, pOS);
! 473: option_load_mode = sv;
! 474: }
! 475: }
! 476:
! 477:
! 478: /*=export_func optionLoadLine
! 479: *
! 480: * what: process a string for an option name and value
! 481: *
! 482: * arg: tOptions*, pOpts, program options descriptor
! 483: * arg: char const*, pzLine, NUL-terminated text
! 484: *
! 485: * doc:
! 486: *
! 487: * This is a client program callable routine for setting options from, for
! 488: * example, the contents of a file that they read in. Only one option may
! 489: * appear in the text. It will be treated as a normal (non-preset) option.
! 490: *
! 491: * When passed a pointer to the option struct and a string, it will find
! 492: * the option named by the first token on the string and set the option
! 493: * argument to the remainder of the string. The caller must NUL terminate
! 494: * the string. Any embedded new lines will be included in the option
! 495: * argument. If the input looks like one or more quoted strings, then the
! 496: * input will be "cooked". The "cooking" is identical to the string
! 497: * formation used in AutoGen definition files (@pxref{basic expression}),
! 498: * except that you may not use backquotes.
! 499: *
! 500: * err: Invalid options are silently ignored. Invalid option arguments
! 501: * will cause a warning to print, but the function should return.
! 502: =*/
! 503: void
! 504: optionLoadLine(tOptions * pOpts, char const * pzLine)
! 505: {
! 506: tOptState st = OPTSTATE_INITIALIZER(SET);
! 507: char* pz;
! 508: AGDUPSTR(pz, pzLine, "user option line");
! 509: loadOptionLine(pOpts, &st, pz, DIRECTION_PROCESS, OPTION_LOAD_COOKED);
! 510: AGFREE(pz);
! 511: }
! 512: /*
! 513: * Local Variables:
! 514: * mode: C
! 515: * c-file-style: "stroustrup"
! 516: * indent-tabs-mode: nil
! 517: * End:
! 518: * end of autoopts/load.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to load.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