Return to file.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts

Annotation of embedaddon/ntp/sntp/libopts/file.c, revision 1.1

1.1     ! misho       1: 
        !             2: /**
        !             3:  * \file file.c
        !             4:  *
        !             5:  *  Time-stamp:      "2010-07-10 11:00:59 bkorb"
        !             6:  *
        !             7:  *  This file is part of AutoOpts, a companion to AutoGen.
        !             8:  *  AutoOpts is free software.
        !             9:  *  AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
        !            10:  *
        !            11:  *  AutoOpts is available under any one of two licenses.  The license
        !            12:  *  in use must be one of these two and the choice is under the control
        !            13:  *  of the user of the license.
        !            14:  *
        !            15:  *   The GNU Lesser General Public License, version 3 or later
        !            16:  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
        !            17:  *
        !            18:  *   The Modified Berkeley Software Distribution License
        !            19:  *      See the file "COPYING.mbsd"
        !            20:  *
        !            21:  *  These files have the following md5sums:
        !            22:  *
        !            23:  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
        !            24:  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
        !            25:  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
        !            26:  */
        !            27: 
        !            28: /*=export_func  optionFileCheck
        !            29:  * private:
        !            30:  *
        !            31:  * what:  Decipher a boolean value
        !            32:  * arg:   + tOptions*     + pOpts    + program options descriptor  +
        !            33:  * arg:   + tOptDesc*     + pOptDesc + the descriptor for this arg +
        !            34:  * arg:   + teOptFileType + ftype    + File handling type          +
        !            35:  * arg:   + tuFileMode    + mode     + file open mode (if needed)  +
        !            36:  *
        !            37:  * doc:
        !            38:  *   Make sure the named file conforms with the file type mode.
        !            39:  *   The mode specifies if the file must exist, must not exist or may
        !            40:  *   (or may not) exist.  The mode may also specify opening the
        !            41:  *   file: don't, open just the descriptor (fd), or open as a stream
        !            42:  *   (FILE* pointer).
        !            43: =*/
        !            44: void
        !            45: optionFileCheck(tOptions* pOpts, tOptDesc* pOD,
        !            46:                 teOptFileType ftype, tuFileMode mode)
        !            47: {
        !            48:     if (pOpts <= OPTPROC_EMIT_LIMIT) {
        !            49:         if (pOpts != OPTPROC_EMIT_USAGE)
        !            50:             return;
        !            51: 
        !            52:         switch (ftype & FTYPE_MODE_EXIST_MASK) {
        !            53:         case FTYPE_MODE_MUST_NOT_EXIST:
        !            54:             fputs(zFileCannotExist, option_usage_fp);
        !            55:             break;
        !            56: 
        !            57:         case FTYPE_MODE_MUST_EXIST:
        !            58:             fputs(zFileMustExist, option_usage_fp);
        !            59:             break;
        !            60:         }
        !            61:         return;
        !            62:     }
        !            63: 
        !            64:     if ((pOD->fOptState & OPTST_RESET) != 0) {
        !            65:         if (pOD->optCookie != NULL)
        !            66:             AGFREE(pOD->optCookie);
        !            67:         return;
        !            68:     }
        !            69: 
        !            70:     {
        !            71:         struct stat sb;
        !            72: 
        !            73:         errno = 0;
        !            74: 
        !            75:         switch (ftype & FTYPE_MODE_EXIST_MASK) {
        !            76:         case FTYPE_MODE_MUST_NOT_EXIST:
        !            77:             if (  (stat(pOD->optArg.argString, &sb) == 0)
        !            78:                || (errno != ENOENT) ){
        !            79:                 if (errno == 0)
        !            80:                     errno = EINVAL;
        !            81:                 fprintf(stderr, zFSOptError, errno, strerror(errno),
        !            82:                         zFSOptErrNoExist, pOD->optArg.argString, pOD->pz_Name);
        !            83:                 pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !            84:                 /* NOTREACHED */
        !            85:             }
        !            86:             /* FALLTHROUGH */
        !            87: 
        !            88:         default:
        !            89:         case FTYPE_MODE_MAY_EXIST:
        !            90:         {
        !            91:             char * p = strrchr(pOD->optArg.argString, DIRCH);
        !            92:             if (p == NULL)
        !            93:                 break; /* assume "." always exists. */
        !            94: 
        !            95:             *p = NUL;
        !            96:             if (  (stat(pOD->optArg.argString, &sb) != 0)
        !            97:                || (errno = EINVAL, ! S_ISDIR(sb.st_mode)) ){
        !            98:                 fprintf(stderr, zFSOptError, errno, strerror(errno),
        !            99:                         zFSOptErrMayExist, pOD->optArg.argString, pOD->pz_Name);
        !           100:                 pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !           101:                 /* NOTREACHED */
        !           102:             }
        !           103:             if (p != NULL)
        !           104:                 *p = DIRCH;
        !           105:             break;
        !           106:         }
        !           107: 
        !           108:         case FTYPE_MODE_MUST_EXIST:
        !           109:             if (  (stat(pOD->optArg.argString, &sb) != 0)
        !           110:                || (errno = EINVAL, ! S_ISREG(sb.st_mode)) ){
        !           111:                 fprintf(stderr, zFSOptError, errno, strerror(errno),
        !           112:                         zFSOptErrMustExist, pOD->optArg.argString,
        !           113:                         pOD->pz_Name);
        !           114:                 pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !           115:                 /* NOTREACHED */
        !           116:             }
        !           117:             break;
        !           118:         }
        !           119:     }
        !           120: 
        !           121:     switch (ftype & FTYPE_MODE_OPEN_MASK) {
        !           122:     default:
        !           123:     case FTYPE_MODE_NO_OPEN:
        !           124:         break;
        !           125: 
        !           126:     case FTYPE_MODE_OPEN_FD:
        !           127:     {
        !           128:         int fd = open(pOD->optArg.argString, mode.file_flags);
        !           129:         if (fd < 0) {
        !           130:             fprintf(stderr, zFSOptError, errno, strerror(errno),
        !           131:                     zFSOptErrOpen, pOD->optArg.argString, pOD->pz_Name);
        !           132:             pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !           133:             /* NOTREACHED */
        !           134:         }
        !           135: 
        !           136:         if ((pOD->fOptState & OPTST_ALLOC_ARG) != 0)
        !           137:             pOD->optCookie = (void *)pOD->optArg.argString;
        !           138:         else
        !           139:             AGDUPSTR(pOD->optCookie, pOD->optArg.argString, "file name");
        !           140: 
        !           141:         pOD->optArg.argFd = fd;
        !           142:         pOD->fOptState &= ~OPTST_ALLOC_ARG;
        !           143:         break;
        !           144:     }
        !           145: 
        !           146:     case FTYPE_MODE_FOPEN_FP:
        !           147:     {
        !           148:         FILE* fp = fopen(pOD->optArg.argString, mode.file_mode);
        !           149:         if (fp == NULL) {
        !           150:             fprintf(stderr, zFSOptError, errno, strerror(errno),
        !           151:                     zFSOptErrFopen, pOD->optArg.argString, pOD->pz_Name);
        !           152:             pOpts->pUsageProc(pOpts, EXIT_FAILURE);
        !           153:             /* NOTREACHED */
        !           154:         }
        !           155: 
        !           156:         if ((pOD->fOptState & OPTST_ALLOC_ARG) != 0)
        !           157:             pOD->optCookie = (void *)pOD->optArg.argString;
        !           158:         else
        !           159:             AGDUPSTR(pOD->optCookie, pOD->optArg.argString, "file name");
        !           160: 
        !           161:         pOD->optArg.argFp = fp;
        !           162:         pOD->fOptState &= ~OPTST_ALLOC_ARG;
        !           163:         break;
        !           164:     }
        !           165:     }
        !           166: }
        !           167: /*
        !           168:  * Local Variables:
        !           169:  * mode: C
        !           170:  * c-file-style: "stroustrup"
        !           171:  * indent-tabs-mode: nil
        !           172:  * End:
        !           173:  * end of autoopts/file.c */