file.c revision 258945 
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=*/
44void
45optionFileCheck(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 */
174