Return to file.c CVS log

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

ntp 4.2.6p5

    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 */