| Current Path : /usr/src/contrib/ntp/libopts/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //usr/src/contrib/ntp/libopts/save.c |
/*
* save.c $Id: save.c,v 4.18 2007/04/15 19:01:18 bkorb Exp $
* Time-stamp: "2007-04-15 11:11:10 bkorb"
*
* This module's routines will take the currently set options and
* store them into an ".rc" file for re-interpretation the next
* time the invoking program is run.
*/
/*
* Automated Options copyright 1992-2007 Bruce Korb
*
* Automated Options is free software.
* You may redistribute it and/or modify it under the terms of the
* GNU General Public License, as published by the Free Software
* Foundation; either version 2, or (at your option) any later version.
*
* Automated Options is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Automated Options. See the file "COPYING". If not,
* write to: The Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
* As a special exception, Bruce Korb gives permission for additional
* uses of the text contained in his release of AutoOpts.
*
* The exception is that, if you link the AutoOpts library with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the AutoOpts library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by Bruce Korb under
* the name AutoOpts. If you copy code from other sources under the
* General Public License into a copy of AutoOpts, as the General Public
* License permits, the exception does not apply to the code that you add
* in this way. To avoid misleading anyone as to the status of such
* modified files, you must delete this exception notice from them.
*
* If you write modifications of your own for AutoOpts, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*/
tSCC zWarn[] = "%s WARNING: cannot save options - ";
/* = = = START-STATIC-FORWARD = = = */
/* static forward declarations maintained by :mkfwd */
static tCC*
findDirName( tOptions* pOpts, int* p_free );
static tCC*
findFileName( tOptions* pOpts, int* p_free_name );
static void
printEntry(
FILE * fp,
tOptDesc * p,
tCC* pzLA );
/* = = = END-STATIC-FORWARD = = = */
static tCC*
findDirName( tOptions* pOpts, int* p_free )
{
tCC* pzDir;
if (pOpts->specOptIdx.save_opts == 0)
return NULL;
pzDir = pOpts->pOptDesc[ pOpts->specOptIdx.save_opts ].optArg.argString;
if ((pzDir != NULL) && (*pzDir != NUL))
return pzDir;
/*
* This function only works if there is a directory where
* we can stash the RC (INI) file.
*/
{
tCC* const* papz = pOpts->papzHomeList;
if (papz == NULL)
return NULL;
while (papz[1] != NULL) papz++;
pzDir = *papz;
}
/*
* IF it does not require deciphering an env value, then just copy it
*/
if (*pzDir != '$')
return pzDir;
{
tCC* pzEndDir = strchr( ++pzDir, DIRCH );
char* pzFileName;
char* pzEnv;
if (pzEndDir != NULL) {
char z[ AO_NAME_SIZE ];
if ((pzEndDir - pzDir) > AO_NAME_LIMIT )
return NULL;
strncpy( z, pzDir, (size_t)(pzEndDir - pzDir) );
z[ (pzEndDir - pzDir) ] = NUL;
pzEnv = getenv( z );
} else {
/*
* Make sure we can get the env value (after stripping off
* any trailing directory or file names)
*/
pzEnv = getenv( pzDir );
}
if (pzEnv == NULL) {
fprintf( stderr, zWarn, pOpts->pzProgName );
fprintf( stderr, zNotDef, pzDir );
return NULL;
}
if (pzEndDir == NULL)
return pzEnv;
{
size_t sz = strlen( pzEnv ) + strlen( pzEndDir ) + 2;
pzFileName = (char*)AGALOC( sz, "dir name" );
}
if (pzFileName == NULL)
return NULL;
*p_free = 1;
/*
* Glue together the full name into the allocated memory.
* FIXME: We lose track of this memory.
*/
sprintf( pzFileName, "%s/%s", pzEnv, pzEndDir );
return pzFileName;
}
}
static tCC*
findFileName( tOptions* pOpts, int* p_free_name )
{
tCC* pzDir;
struct stat stBuf;
int free_dir_name = 0;
pzDir = findDirName( pOpts, &free_dir_name );
if (pzDir == NULL)
return NULL;
/*
* See if we can find the specified directory. We use a once-only loop
* structure so we can bail out early.
*/
if (stat( pzDir, &stBuf ) != 0) do {
/*
* IF we could not, check to see if we got a full
* path to a file name that has not been created yet.
*/
if (errno == ENOENT) {
char z[AG_PATH_MAX];
/*
* Strip off the last component, stat the remaining string and
* that string must name a directory
*/
char* pzDirCh = strrchr( pzDir, DIRCH );
if (pzDirCh == NULL) {
stBuf.st_mode = S_IFREG;
continue; /* bail out of error condition */
}
strncpy( z, pzDir, (size_t)(pzDirCh - pzDir));
z[ pzDirCh - pzDir ] = NUL;
if ( (stat( z, &stBuf ) == 0)
&& S_ISDIR( stBuf.st_mode )) {
/*
* We found the directory. Restore the file name and
* mark the full name as a regular file
*/
stBuf.st_mode = S_IFREG;
continue; /* bail out of error condition */
}
}
/*
* We got a bogus name.
*/
fprintf( stderr, zWarn, pOpts->pzProgName );
fprintf( stderr, zNoStat, errno, strerror( errno ), pzDir );
if (free_dir_name)
AGFREE( (void*)pzDir );
return NULL;
} while (0);
/*
* IF what we found was a directory,
* THEN tack on the config file name
*/
if (S_ISDIR( stBuf.st_mode )) {
size_t sz = strlen( pzDir ) + strlen( pOpts->pzRcName ) + 2;
{
char* pzPath = (char*)AGALOC( sz, "file name" );
#ifdef HAVE_SNPRINTF
snprintf( pzPath, sz, "%s/%s", pzDir, pOpts->pzRcName );
#else
sprintf( pzPath, "%s/%s", pzDir, pOpts->pzRcName );
#endif
if (free_dir_name)
AGFREE( (void*)pzDir );
pzDir = pzPath;
free_dir_name = 1;
}
/*
* IF we cannot stat the object for any reason other than
* it does not exist, then we bail out
*/
if (stat( pzDir, &stBuf ) != 0) {
if (errno != ENOENT) {
fprintf( stderr, zWarn, pOpts->pzProgName );
fprintf( stderr, zNoStat, errno, strerror( errno ),
pzDir );
AGFREE( (void*)pzDir );
return NULL;
}
/*
* It does not exist yet, but it will be a regular file
*/
stBuf.st_mode = S_IFREG;
}
}
/*
* Make sure that whatever we ultimately found, that it either is
* or will soon be a file.
*/
if (! S_ISREG( stBuf.st_mode )) {
fprintf( stderr, zWarn, pOpts->pzProgName );
fprintf( stderr, zNotFile, pzDir );
if (free_dir_name)
AGFREE( (void*)pzDir );
return NULL;
}
/*
* Get rid of the old file
*/
unlink( pzDir );
*p_free_name = free_dir_name;
return pzDir;
}
static void
printEntry(
FILE * fp,
tOptDesc * p,
tCC* pzLA )
{
/*
* There is an argument. Pad the name so values line up.
* Not disabled *OR* this got equivalenced to another opt,
* then use current option name.
* Otherwise, there must be a disablement name.
*/
{
char const * pz;
if (! DISABLED_OPT(p) || (p->optEquivIndex != NO_EQUIVALENT))
pz = p->pz_Name;
else
pz = p->pz_DisableName;
fprintf(fp, "%-18s", pz);
}
/*
* IF the option is numeric only,
* THEN the char pointer is really the number
*/
if (OPTST_GET_ARGTYPE(p->fOptState) == OPARG_TYPE_NUMERIC)
fprintf( fp, " %d\n", (int)(t_word)pzLA );
/*
* OTHERWISE, FOR each line of the value text, ...
*/
else if (pzLA == NULL)
fputc( '\n', fp );
else {
fputc( ' ', fp ); fputc( ' ', fp );
for (;;) {
tCC* pzNl = strchr( pzLA, '\n' );
/*
* IF this is the last line
* THEN bail and print it
*/
if (pzNl == NULL)
break;
/*
* Print the continuation and the text from the current line
*/
(void)fwrite( pzLA, (size_t)(pzNl - pzLA), (size_t)1, fp );
pzLA = pzNl+1; /* advance the Last Arg pointer */
fputs( "\\\n", fp );
}
/*
* Terminate the entry
*/
fputs( pzLA, fp );
fputc( '\n', fp );
}
}
/*=export_func optionSaveFile
*
* what: saves the option state to a file
*
* arg: tOptions*, pOpts, program options descriptor
*
* doc:
*
* This routine will save the state of option processing to a file. The name
* of that file can be specified with the argument to the @code{--save-opts}
* option, or by appending the @code{rcfile} attribute to the last
* @code{homerc} attribute. If no @code{rcfile} attribute was specified, it
* will default to @code{.@i{programname}rc}. If you wish to specify another
* file, you should invoke the @code{SET_OPT_SAVE_OPTS( @i{filename} )} macro.
*
* err:
*
* If no @code{homerc} file was specified, this routine will silently return
* and do nothing. If the output file cannot be created or updated, a message
* will be printed to @code{stderr} and the routine will return.
=*/
void
optionSaveFile( tOptions* pOpts )
{
tOptDesc* pOD;
int ct;
FILE* fp;
{
int free_name = 0;
tCC* pzFName = findFileName( pOpts, &free_name );
if (pzFName == NULL)
return;
fp = fopen( pzFName, "w" FOPEN_BINARY_FLAG );
if (fp == NULL) {
fprintf( stderr, zWarn, pOpts->pzProgName );
fprintf( stderr, zNoCreat, errno, strerror( errno ), pzFName );
if (free_name)
AGFREE((void*) pzFName );
return;
}
if (free_name)
AGFREE( (void*)pzFName );
}
{
char const* pz = pOpts->pzUsageTitle;
fputs( "# ", fp );
do { fputc( *pz, fp ); } while (*(pz++) != '\n');
}
{
time_t timeVal = time( NULL );
char* pzTime = ctime( &timeVal );
fprintf( fp, zPresetFile, pzTime );
#ifdef HAVE_ALLOCATED_CTIME
/*
* The return values for ctime(), localtime(), and gmtime()
* normally point to static data that is overwritten by each call.
* The test to detect allocated ctime, so we leak the memory.
*/
AGFREE( (void*)pzTime );
#endif
}
/*
* FOR each of the defined options, ...
*/
ct = pOpts->presetOptCt;
pOD = pOpts->pOptDesc;
do {
int arg_state;
tOptDesc* p;
/*
* IF the option has not been defined
* OR it does not take an initialization value
* OR it is equivalenced to another option
* THEN continue (ignore it)
*/
if (UNUSED_OPT( pOD ))
continue;
if ((pOD->fOptState & (OPTST_NO_INIT|OPTST_DOCUMENT|OPTST_OMITTED))
!= 0)
continue;
if ( (pOD->optEquivIndex != NO_EQUIVALENT)
&& (pOD->optEquivIndex != pOD->optIndex))
continue;
/*
* Set a temporary pointer to the real option description
* (i.e. account for equivalencing)
*/
p = ((pOD->fOptState & OPTST_EQUIVALENCE) != 0)
? (pOpts->pOptDesc + pOD->optActualIndex) : pOD;
/*
* IF no arguments are allowed
* THEN just print the name and continue
*/
if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NONE) {
char const * pznm =
(DISABLED_OPT( p )) ? p->pz_DisableName : p->pz_Name;
/*
* If the option was disabled and the disablement name is NULL,
* then the disablement was caused by aliasing.
* Use the name as the string to emit.
*/
if (pznm == NULL)
pznm = p->pz_Name;
fprintf(fp, "%s\n", pznm);
continue;
}
arg_state = OPTST_GET_ARGTYPE(p->fOptState);
switch (arg_state) {
case 0:
case OPARG_TYPE_NUMERIC:
printEntry( fp, p, (void*)(p->optArg.argInt));
break;
case OPARG_TYPE_STRING:
if (p->fOptState & OPTST_STACKED) {
tArgList* pAL = (tArgList*)p->optCookie;
int uct = pAL->useCt;
tCC** ppz = pAL->apzArgs;
/*
* Disallow multiple copies of disabled options.
*/
if (uct > 1)
p->fOptState &= ~OPTST_DISABLED;
while (uct-- > 0)
printEntry( fp, p, *(ppz++) );
} else {
printEntry( fp, p, p->optArg.argString );
}
break;
case OPARG_TYPE_ENUMERATION:
case OPARG_TYPE_MEMBERSHIP:
{
uintptr_t val = p->optArg.argEnum;
/*
* This is a magic incantation that will convert the
* bit flag values back into a string suitable for printing.
*/
(*(p->pOptProc))( (tOptions*)2UL, p );
printEntry( fp, p, (void*)(p->optArg.argString));
if ( (p->optArg.argString != NULL)
&& (arg_state != OPARG_TYPE_ENUMERATION)) {
/*
* set membership strings get allocated
*/
AGFREE( (void*)p->optArg.argString );
p->fOptState &= ~OPTST_ALLOC_ARG;
}
p->optArg.argEnum = val;
break;
}
case OPARG_TYPE_BOOLEAN:
printEntry( fp, p, p->optArg.argBool ? "true" : "false" );
break;
default:
break; /* cannot handle - skip it */
}
} while ( (pOD++), (--ct > 0));
fclose( fp );
}
/*
* Local Variables:
* mode: C
* c-file-style: "stroustrup"
* indent-tabs-mode: nil
* End:
* end of autoopts/save.c */