contrib/ntp/sntp/libopts/restore.c

   1
   2 /*
   3  * \file restore.c
   4  *
   5  *  This module's routines will save the current option state to memory
   6  *  and restore it.  If saved prior to the initial optionProcess call,
   7  *  then the initial state will be restored.
   8  *
   9  * @addtogroup autoopts
  10  * @{
  11  */
  12 /*
  13  *  This file is part of AutoOpts, a companion to AutoGen.
  14  *  AutoOpts is free software.
  15  *  AutoOpts is Copyright (C) 1992-2015 by Bruce Korb - all rights reserved
  16  *
  17  *  AutoOpts is available under any one of two licenses.  The license
  18  *  in use must be one of these two and the choice is under the control
  19  *  of the user of the license.
  20  *
  21  *   The GNU Lesser General Public License, version 3 or later
  22  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  23  *
  24  *   The Modified Berkeley Software Distribution License
  25  *      See the file "COPYING.mbsd"
  26  *
  27  *  These files have the following sha256 sums:
  28  *
  29  *  8584710e9b04216a394078dc156b781d0b47e1729104d666658aecef8ee32e95  COPYING.gplv3
  30  *  4379e7444a0e2ce2b12dd6f5a52a27a4d02d39d247901d3285c88cf0d37f477b  COPYING.lgplv3
  31  *  13aa749a5b0a454917a944ed8fffc530b784f5ead522b1aacaf4ec8aa55a6239  COPYING.mbsd
  32  */
  33
  34 /*
  35  *  optionFixupSavedOpts  Really, it just wipes out option state for
  36  *  options that are troublesome to copy.  viz., stacked strings and
  37  *  hierarcicaly valued option args.  We do duplicate string args that
  38  *  have been marked as allocated though.
  39  */
  40 static void
  41 fixupSavedOptionArgs(tOptions * pOpts)
  42 {
  43     tOptions * p   = pOpts->pSavedState;
  44     tOptDesc * pOD = pOpts->pOptDesc;
  45     int        ct  = pOpts->optCt;
  46
  47     /*
  48      *  Make sure that allocated stuff is only referenced in the
  49      *  archived copy of the data.
  50      */
  51     for (; ct-- > 0; pOD++)  {
  52         switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
  53         case OPARG_TYPE_STRING:
  54             if (pOD->fOptState & OPTST_STACKED) {
  55                 tOptDesc * q = p->pOptDesc + (pOD - pOpts->pOptDesc);
  56                 q->optCookie = NULL;
  57             }
  58             if (pOD->fOptState & OPTST_ALLOC_ARG) {
  59                 tOptDesc * q = p->pOptDesc + (pOD - pOpts->pOptDesc);
  60                 AGDUPSTR(q->optArg.argString, pOD->optArg.argString, "arg");
  61             }
  62             break;
  63
  64         case OPARG_TYPE_HIERARCHY:
  65         {
  66             tOptDesc * q = p->pOptDesc + (pOD - pOpts->pOptDesc);
  67             q->optCookie = NULL;
  68         }
  69         }
  70     }
  71 }
  72
  73 /*=export_func optionSaveState
  74  *
  75  * what:  saves the option state to memory
  76  * arg:   tOptions *, pOpts, program options descriptor
  77  *
  78  * doc:
  79  *
  80  *  This routine will allocate enough memory to save the current option
  81  *  processing state.  If this routine has been called before, that memory
  82  *  will be reused.  You may only save one copy of the option state.  This
  83  *  routine may be called before optionProcess(3AO).  If you do call it
  84  *  before the first call to optionProcess, then you may also change the
  85  *  contents of argc/argv after you call optionRestore(3AO)
  86  *
  87  *  In fact, more strongly put: it is safest to only use this function
  88  *  before having processed any options.  In particular, the saving and
  89  *  restoring of stacked string arguments and hierarchical values is
  90  *  disabled.  The values are not saved.
  91  *
  92  * err:   If it fails to allocate the memory,
  93  *        it will print a message to stderr and exit.
  94  *        Otherwise, it will always succeed.
  95 =*/
  96 void
  97 optionSaveState(tOptions * pOpts)
  98 {
  99     tOptions * p = (tOptions *)pOpts->pSavedState;
 100
 101     if (p == NULL) {
 102         size_t sz = sizeof(*pOpts)
 103             + ((size_t)pOpts->optCt * sizeof(tOptDesc));
 104         p = AGALOC(sz, "saved option state");
 105
 106         pOpts->pSavedState = p;
 107     }
 108
 109     memcpy(p, pOpts, sizeof(*p));
 110     memcpy(p + 1, pOpts->pOptDesc, (size_t)p->optCt * sizeof(tOptDesc));
 111
 112     fixupSavedOptionArgs(pOpts);
 113 }
 114
 115
 116 /*=export_func optionRestore
 117  *
 118  * what:  restore option state from memory copy
 119  * arg:   tOptions *, pOpts, program options descriptor
 120  *
 121  * doc:  Copy back the option state from saved memory.
 122  *       The allocated memory is left intact, so this routine can be
 123  *       called repeatedly without having to call optionSaveState again.
 124  *       If you are restoring a state that was saved before the first call
 125  *       to optionProcess(3AO), then you may change the contents of the
 126  *       argc/argv parameters to optionProcess.
 127  *
 128  * err:  If you have not called @code{optionSaveState} before, a diagnostic is
 129  *       printed to @code{stderr} and exit is called.
 130 =*/
 131 void
 132 optionRestore(tOptions * pOpts)
 133 {
 134     tOptions * p = (tOptions *)pOpts->pSavedState;
 135
 136     if (p == NULL) {
 137         char const * pzName = pOpts->pzProgName;
 138         if (pzName == NULL) {
 139             pzName = pOpts->pzPROGNAME;
 140             if (pzName == NULL)
 141                 pzName = zNil;
 142         }
 143         fprintf(stderr, zNoState, pzName);
 144         option_exits(EXIT_FAILURE);
 145     }
 146
 147     pOpts->pSavedState = NULL;
 148     optionFree(pOpts);
 149
 150     memcpy(pOpts, p, sizeof(*p));
 151     memcpy(pOpts->pOptDesc, p+1, (size_t)p->optCt * sizeof(tOptDesc));
 152     pOpts->pSavedState = p;
 153
 154     fixupSavedOptionArgs(pOpts);
 155 }
 156
 157 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 158
 159 /*=export_func optionFree
 160  *
 161  * what:  free allocated option processing memory
 162  * arg:   tOptions *, pOpts, program options descriptor
 163  *
 164  * doc:   AutoOpts sometimes allocates memory and puts pointers to it in the
 165  *        option state structures.  This routine deallocates all such memory.
 166  *
 167  * err:   As long as memory has not been corrupted,
 168  *        this routine is always successful.
 169 =*/
 170 void
 171 optionFree(tOptions * pOpts)
 172 {
 173  free_saved_state:
 174     {
 175         tOptDesc * p = pOpts->pOptDesc;
 176         int ct = pOpts->optCt;
 177         do  {
 178             if (p->fOptState & OPTST_ALLOC_ARG) {
 179                 AGFREE(p->optArg.argString);
 180                 p->optArg.argString = NULL;
 181                 p->fOptState &= ~OPTST_ALLOC_ARG;
 182             }
 183
 184             switch (OPTST_GET_ARGTYPE(p->fOptState)) {
 185             case OPARG_TYPE_STRING:
 186 #ifdef WITH_LIBREGEX
 187                 if (  (p->fOptState & OPTST_STACKED)
 188                    && (p->optCookie != NULL)) {
 189                     p->optArg.argString = ".*";
 190                     optionUnstackArg(pOpts, p);
 191                 }
 192 #else
 193                 /* leak memory */;
 194 #endif
 195                 break;
 196
 197             case OPARG_TYPE_HIERARCHY:
 198                 if (p->optCookie != NULL)
 199                     unload_arg_list(p->optCookie);
 200                 break;
 201             }
 202
 203             p->optCookie = NULL;
 204         } while (p++, --ct > 0);
 205     }
 206     if (pOpts->pSavedState != NULL) {
 207         tOptions * p = (tOptions *)pOpts->pSavedState;
 208         memcpy(pOpts, p, sizeof(*p));
 209         memcpy(pOpts->pOptDesc, p+1, (size_t)p->optCt * sizeof(tOptDesc));
 210         AGFREE(pOpts->pSavedState);
 211         pOpts->pSavedState = NULL;
 212         goto free_saved_state;
 213     }
 214 }
 215
 216 /** @}
 217  *
 218  * Local Variables:
 219  * mode: C
 220  * c-file-style: "stroustrup"
 221  * indent-tabs-mode: nil
 222  * End:
 223  * end of autoopts/restore.c */