276da39af9
Approved by: roberto, delphij Security: VuXML: 0d0f3050-1f69-11e5-9ba9-d050996490d0 Security: http://bugs.ntp.org/show_bug.cgi?id=2853 Security: https://www.kb.cert.org/vuls/id/668167 Security: http://support.ntp.org/bin/view/Main/SecurityNotice#June_2015_NTP_Security_Vulnerabi
398 lines
12 KiB
C
398 lines
12 KiB
C
|
|
/**
|
|
* \file autoopts.c
|
|
*
|
|
* This file contains all of the routines that must be linked into
|
|
* an executable to use the generated option processing. The optional
|
|
* routines are in separately compiled modules so that they will not
|
|
* necessarily be linked in.
|
|
*
|
|
* @addtogroup autoopts
|
|
* @{
|
|
*/
|
|
/*
|
|
* This file is part of AutoOpts, a companion to AutoGen.
|
|
* AutoOpts is free software.
|
|
* AutoOpts is Copyright (C) 1992-2015 by Bruce Korb - all rights reserved
|
|
*
|
|
* AutoOpts is available under any one of two licenses. The license
|
|
* in use must be one of these two and the choice is under the control
|
|
* of the user of the license.
|
|
*
|
|
* The GNU Lesser General Public License, version 3 or later
|
|
* See the files "COPYING.lgplv3" and "COPYING.gplv3"
|
|
*
|
|
* The Modified Berkeley Software Distribution License
|
|
* See the file "COPYING.mbsd"
|
|
*
|
|
* These files have the following sha256 sums:
|
|
*
|
|
* 8584710e9b04216a394078dc156b781d0b47e1729104d666658aecef8ee32e95 COPYING.gplv3
|
|
* 4379e7444a0e2ce2b12dd6f5a52a27a4d02d39d247901d3285c88cf0d37f477b COPYING.lgplv3
|
|
* 13aa749a5b0a454917a944ed8fffc530b784f5ead522b1aacaf4ec8aa55a6239 COPYING.mbsd
|
|
*/
|
|
|
|
/**
|
|
* The number of tab characters to skip when printing continuation lines.
|
|
*/
|
|
static unsigned int tab_skip_ct = 0;
|
|
|
|
#ifndef HAVE_PATHFIND
|
|
# define pathfind(_p, _n, _m) option_pathfind(_p, _n, _m)
|
|
# include "compat/pathfind.c"
|
|
#endif
|
|
|
|
#ifndef HAVE_SNPRINTF
|
|
# define vsnprintf option_vsnprintf
|
|
# define snprintf option_snprintf
|
|
# include "compat/snprintf.c"
|
|
#endif
|
|
|
|
#ifndef HAVE_STRDUP
|
|
# define strdup(_s) option_strdup(_s)
|
|
# include "compat/strdup.c"
|
|
#endif
|
|
|
|
#ifndef HAVE_STRCHR
|
|
# define strrchr(_s, _c) option_strrchr(_s, _c)
|
|
# define strchr(_s, _c) option_strchr(_s, _c)
|
|
# include "compat/strchr.c"
|
|
#endif
|
|
|
|
LOCAL void *
|
|
ao_malloc(size_t sz)
|
|
{
|
|
void * res = malloc(sz);
|
|
if (res == NULL) {
|
|
fprintf(stderr, zalloc_fail, (int)sz);
|
|
option_exits(EXIT_FAILURE);
|
|
}
|
|
return res;
|
|
}
|
|
#undef malloc
|
|
#define malloc(_s) ao_malloc(_s)
|
|
|
|
LOCAL void *
|
|
ao_realloc(void *p, size_t sz)
|
|
{
|
|
void * res = (p == NULL) ? malloc(sz) : realloc(p, sz);
|
|
if (res == NULL) {
|
|
fprintf(stderr, zrealloc_fail, (int)sz, p);
|
|
option_exits(EXIT_FAILURE);
|
|
}
|
|
return res;
|
|
}
|
|
#undef realloc
|
|
#define realloc(_p,_s) ao_realloc(_p,_s)
|
|
|
|
LOCAL char *
|
|
ao_strdup(char const *str)
|
|
{
|
|
char * res = strdup(str);
|
|
if (res == NULL) {
|
|
fprintf(stderr, zalloc_fail, (int)strlen(str));
|
|
option_exits(EXIT_FAILURE);
|
|
}
|
|
return res;
|
|
}
|
|
#undef strdup
|
|
#define strdup(_p) ao_strdup(_p)
|
|
|
|
/**
|
|
* handle an option.
|
|
*
|
|
* This routine handles equivalencing, sets the option state flags and
|
|
* invokes the handler procedure, if any.
|
|
*/
|
|
LOCAL tSuccess
|
|
handle_opt(tOptions * opts, tOptState * o_st)
|
|
{
|
|
/*
|
|
* Save a copy of the option procedure pointer.
|
|
* If this is an equivalence class option, we still want this proc.
|
|
*/
|
|
tOptDesc * od = o_st->pOD;
|
|
tOptProc * opt_proc = od->pOptProc;
|
|
if (od->fOptState & OPTST_ALLOC_ARG)
|
|
AGFREE(od->optArg.argString);
|
|
|
|
od->optArg.argString = o_st->pzOptArg;
|
|
|
|
/*
|
|
* IF we are presetting options, then we will ignore any un-presettable
|
|
* options. They are the ones either marked as such.
|
|
*/
|
|
if ( ((opts->fOptSet & OPTPROC_PRESETTING) != 0)
|
|
&& ((od->fOptState & OPTST_NO_INIT) != 0)
|
|
)
|
|
return PROBLEM;
|
|
|
|
/*
|
|
* IF this is an equivalence class option,
|
|
* THEN
|
|
* Save the option value that got us to this option
|
|
* entry. (It may not be od->optChar[0], if this is an
|
|
* equivalence entry.)
|
|
* set the pointer to the equivalence class base
|
|
*/
|
|
if (od->optEquivIndex != NO_EQUIVALENT) {
|
|
tOptDesc * eqv_od = opts->pOptDesc + od->optEquivIndex;
|
|
|
|
/*
|
|
* IF the current option state has not been defined (set on the
|
|
* command line), THEN we will allow continued resetting of
|
|
* the value. Once "defined", then it must not change.
|
|
*/
|
|
if ((od->fOptState & OPTST_DEFINED) != 0) {
|
|
/*
|
|
* The equivalenced-to option has been found on the command
|
|
* line before. Make sure new occurrences are the same type.
|
|
*
|
|
* IF this option has been previously equivalenced and
|
|
* it was not the same equivalenced-to option,
|
|
* THEN we have a usage problem.
|
|
*/
|
|
if (eqv_od->optActualIndex != od->optIndex) {
|
|
fprintf(stderr, zmultiway_bug, eqv_od->pz_Name, od->pz_Name,
|
|
(opts->pOptDesc + eqv_od->optActualIndex)->pz_Name);
|
|
return FAILURE;
|
|
}
|
|
} else {
|
|
/*
|
|
* Set the equivalenced-to actual option index to no-equivalent
|
|
* so that we set all the entries below. This option may either
|
|
* never have been selected before, or else it was selected by
|
|
* some sort of "presetting" mechanism.
|
|
*/
|
|
eqv_od->optActualIndex = NO_EQUIVALENT;
|
|
}
|
|
|
|
if (eqv_od->optActualIndex != od->optIndex) {
|
|
/*
|
|
* First time through, copy over the state
|
|
* and add in the equivalence flag
|
|
*/
|
|
eqv_od->optActualValue = od->optValue;
|
|
eqv_od->optActualIndex = od->optIndex;
|
|
o_st->flags |= OPTST_EQUIVALENCE;
|
|
}
|
|
|
|
/*
|
|
* Copy the most recent option argument. set membership state
|
|
* is kept in 'eqv_od->optCookie'. Do not overwrite.
|
|
*/
|
|
eqv_od->optArg.argString = od->optArg.argString;
|
|
od = eqv_od;
|
|
|
|
} else {
|
|
od->optActualValue = od->optValue;
|
|
od->optActualIndex = od->optIndex;
|
|
}
|
|
|
|
od->fOptState &= OPTST_PERSISTENT_MASK;
|
|
od->fOptState |= (o_st->flags & ~OPTST_PERSISTENT_MASK);
|
|
|
|
/*
|
|
* Keep track of count only for DEFINED (command line) options.
|
|
* IF we have too many, build up an error message and bail.
|
|
*/
|
|
if ( (od->fOptState & OPTST_DEFINED)
|
|
&& (++od->optOccCt > od->optMaxCt) )
|
|
return too_many_occurrences(opts, od);
|
|
/*
|
|
* If provided a procedure to call, call it
|
|
*/
|
|
if (opt_proc != NULL)
|
|
(*opt_proc)(opts, od);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Find the option descriptor and option argument (if any) for the
|
|
* next command line argument. DO NOT modify the descriptor. Put
|
|
* all the state in the state argument so that the option can be skipped
|
|
* without consequence (side effect).
|
|
*
|
|
* @param opts the program option descriptor
|
|
* @param o_st the state of the next found option
|
|
*/
|
|
LOCAL tSuccess
|
|
next_opt(tOptions * opts, tOptState * o_st)
|
|
{
|
|
{
|
|
tSuccess res = find_opt(opts, o_st);
|
|
if (! SUCCESSFUL(res))
|
|
return res;
|
|
}
|
|
|
|
if ( ((o_st->flags & OPTST_DEFINED) != 0)
|
|
&& ((o_st->pOD->fOptState & OPTST_NO_COMMAND) != 0)) {
|
|
fprintf(stderr, zNotCmdOpt, o_st->pOD->pz_Name);
|
|
return FAILURE;
|
|
}
|
|
|
|
return get_opt_arg(opts, o_st);
|
|
}
|
|
|
|
/**
|
|
* Process all the options from our current position onward. (This allows
|
|
* interspersed options and arguments for the few non-standard programs that
|
|
* require it.) Thus, do not rewind option indexes because some programs
|
|
* choose to re-invoke after a non-option.
|
|
*
|
|
* @param[in,out] opts program options descriptor
|
|
* @returns SUCCESS or FAILURE
|
|
*/
|
|
LOCAL tSuccess
|
|
regular_opts(tOptions * opts)
|
|
{
|
|
/* assert: opts->fOptSet & OPTPROC_IMMEDIATE == 0 */
|
|
for (;;) {
|
|
tOptState opt_st = OPTSTATE_INITIALIZER(DEFINED);
|
|
|
|
switch (next_opt(opts, &opt_st)) {
|
|
case FAILURE: goto failed_option;
|
|
case PROBLEM: return SUCCESS; /* no more args */
|
|
case SUCCESS: break;
|
|
}
|
|
|
|
/*
|
|
* IF this is an immediate action option,
|
|
* THEN skip it (unless we are supposed to do it a second time).
|
|
*/
|
|
if (! DO_NORMALLY(opt_st.flags)) {
|
|
if (! DO_SECOND_TIME(opt_st.flags))
|
|
continue;
|
|
opt_st.pOD->optOccCt--; /* don't count this repetition */
|
|
}
|
|
|
|
if (! SUCCESSFUL(handle_opt(opts, &opt_st)))
|
|
break;
|
|
} failed_option:;
|
|
|
|
if ((opts->fOptSet & OPTPROC_ERRSTOP) != 0)
|
|
(*opts->pUsageProc)(opts, EXIT_FAILURE);
|
|
|
|
return FAILURE;
|
|
}
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* THESE ROUTINES ARE CALLABLE FROM THE GENERATED OPTION PROCESSING CODE
|
|
*/
|
|
/*=--subblock=arg=arg_type,arg_name,arg_desc =*/
|
|
/*=*
|
|
* library: opts
|
|
* header: your-opts.h
|
|
*
|
|
* lib_description:
|
|
*
|
|
* These are the routines that libopts users may call directly from their
|
|
* code. There are several other routines that can be called by code
|
|
* generated by the libopts option templates, but they are not to be
|
|
* called from any other user code. The @file{options.h} header is
|
|
* fairly clear about this, too.
|
|
=*/
|
|
|
|
/*=export_func optionProcess
|
|
*
|
|
* what: this is the main option processing routine
|
|
*
|
|
* arg: + tOptions * + opts + program options descriptor +
|
|
* arg: + int + a_ct + program arg count +
|
|
* arg: + char ** + a_v + program arg vector +
|
|
*
|
|
* ret_type: int
|
|
* ret_desc: the count of the arguments processed
|
|
*
|
|
* doc:
|
|
*
|
|
* This is the main entry point for processing options. It is intended
|
|
* that this procedure be called once at the beginning of the execution of
|
|
* a program. Depending on options selected earlier, it is sometimes
|
|
* necessary to stop and restart option processing, or to select completely
|
|
* different sets of options. This can be done easily, but you generally
|
|
* do not want to do this.
|
|
*
|
|
* The number of arguments processed always includes the program name.
|
|
* If one of the arguments is "--", then it is counted and the processing
|
|
* stops. If an error was encountered and errors are to be tolerated, then
|
|
* the returned value is the index of the argument causing the error.
|
|
* A hyphen by itself ("-") will also cause processing to stop and will
|
|
* @emph{not} be counted among the processed arguments. A hyphen by itself
|
|
* is treated as an operand. Encountering an operand stops option
|
|
* processing.
|
|
*
|
|
* err: Errors will cause diagnostics to be printed. @code{exit(3)} may
|
|
* or may not be called. It depends upon whether or not the options
|
|
* were generated with the "allow-errors" attribute, or if the
|
|
* ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.
|
|
=*/
|
|
int
|
|
optionProcess(tOptions * opts, int a_ct, char ** a_v)
|
|
{
|
|
if (! SUCCESSFUL(validate_struct(opts, a_v[0])))
|
|
ao_bug(zbad_data_msg);
|
|
|
|
/*
|
|
* Establish the real program name, the program full path,
|
|
* and do all the presetting the first time thru only.
|
|
*/
|
|
if (! ao_initialize(opts, a_ct, a_v))
|
|
return 0;
|
|
|
|
/*
|
|
* IF we are (re)starting,
|
|
* THEN reset option location
|
|
*/
|
|
if (opts->curOptIdx <= 0) {
|
|
opts->curOptIdx = 1;
|
|
opts->pzCurOpt = NULL;
|
|
}
|
|
|
|
if (! SUCCESSFUL(regular_opts(opts)))
|
|
return (int)opts->origArgCt;
|
|
|
|
/*
|
|
* IF there were no errors
|
|
* AND we have RC/INI files
|
|
* AND there is a request to save the files
|
|
* THEN do that now before testing for conflicts.
|
|
* (conflicts are ignored in preset options)
|
|
*/
|
|
switch (opts->specOptIdx.save_opts) {
|
|
case 0:
|
|
case NO_EQUIVALENT:
|
|
break;
|
|
default:
|
|
{
|
|
tOptDesc * od = opts->pOptDesc + opts->specOptIdx.save_opts;
|
|
|
|
if (SELECTED_OPT(od)) {
|
|
optionSaveFile(opts);
|
|
option_exits(EXIT_SUCCESS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* IF we are checking for errors,
|
|
* THEN look for too few occurrences of required options
|
|
*/
|
|
if (((opts->fOptSet & OPTPROC_ERRSTOP) != 0)
|
|
&& (! is_consistent(opts)))
|
|
(*opts->pUsageProc)(opts, EXIT_FAILURE);
|
|
|
|
return (int)opts->curOptIdx;
|
|
}
|
|
|
|
/** @}
|
|
*
|
|
* Local Variables:
|
|
* mode: C
|
|
* c-file-style: "stroustrup"
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
* end of autoopts/autoopts.c */
|