Logo Search packages:      
Sourcecode: samba-doc-ja version File versions

popt.c

/* (C) 1998 Red Hat Software, Inc. -- Licensing details are in the COPYING
   file accompanying popt source distributions, available from
   ftp://ftp.redhat.com/pub/code/popt */

#include "system.h"
#include "findme.h"
#include "poptint.h"

#ifndef HAVE_STRERROR
static char * strerror(int errno) {
    extern int sys_nerr;
    extern char * sys_errlist[];

    if ((0 <= errno) && (errno < sys_nerr))
      return sys_errlist[errno];
    else
      return POPT_("unknown errno");
}
#endif

void poptSetExecPath(poptContext con, const char * path, int allowAbsolute) {
    if (con->execPath) xfree(con->execPath);
    con->execPath = xstrdup(path);
    con->execAbsolute = allowAbsolute;
}

static void invokeCallbacks(poptContext con, const struct poptOption * table,
                      int post) {
    const struct poptOption * opt = table;
    poptCallbackType cb;

    while (opt->longName || opt->shortName || opt->arg) {
      if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
          invokeCallbacks(con, opt->arg, post);
      } else if (((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK) &&
               ((!post && (opt->argInfo & POPT_CBFLAG_PRE)) ||
                ( post && (opt->argInfo & POPT_CBFLAG_POST)))) {
          cb = (poptCallbackType)opt->arg;
          cb(con, post ? POPT_CALLBACK_REASON_POST : POPT_CALLBACK_REASON_PRE,
             NULL, NULL, opt->descrip);
      }
      opt++;
    }
}

poptContext poptGetContext(const char * name, int argc, const char ** argv,
                     const struct poptOption * options, int flags) {
    poptContext con = (poptContext)malloc(sizeof(*con));

    memset(con, 0, sizeof(*con));

    con->os = con->optionStack;
    con->os->argc = argc;
    con->os->argv = argv;
    con->os->argb = NULL;

    if (!(flags & POPT_CONTEXT_KEEP_FIRST))
      con->os->next = 1;                  /* skip argv[0] */

    con->leftovers = (const char **)calloc( (argc + 1), sizeof(char *) );
    con->options = options;
    con->aliases = NULL;
    con->numAliases = 0;
    con->flags = flags;
    con->execs = NULL;
    con->numExecs = 0;
    con->finalArgvAlloced = argc * 2;
    con->finalArgv = (const char **)calloc( con->finalArgvAlloced, sizeof(*con->finalArgv) );
    con->execAbsolute = 1;
    con->arg_strip = NULL;

    if (getenv("POSIXLY_CORRECT") || getenv("POSIX_ME_HARDER"))
      con->flags |= POPT_CONTEXT_POSIXMEHARDER;

    if (name)
      con->appName = strcpy(malloc(strlen(name) + 1), name);

    invokeCallbacks(con, con->options, 0);

    return con;
}

static void cleanOSE(struct optionStackEntry *os)
{
    if (os->nextArg) {
      xfree(os->nextArg);
      os->nextArg = NULL;
    }
    if (os->argv) {
      xfree(os->argv);
      os->argv = NULL;
    }
    if (os->argb) {
      PBM_FREE(os->argb);
      os->argb = NULL;
    }
}

void poptResetContext(poptContext con) {
    int i;

    while (con->os > con->optionStack) {
      cleanOSE(con->os--);
    }
    if (con->os->argb) {
      PBM_FREE(con->os->argb);
      con->os->argb = NULL;
    }
    con->os->currAlias = NULL;
    con->os->nextCharArg = NULL;
    con->os->nextArg = NULL;
    con->os->next = 1;              /* skip argv[0] */

    con->numLeftovers = 0;
    con->nextLeftover = 0;
    con->restLeftover = 0;
    con->doExec = NULL;

    for (i = 0; i < con->finalArgvCount; i++) {
      if (con->finalArgv[i]) {
          xfree(con->finalArgv[i]);
          con->finalArgv[i] = NULL;
      }
    }

    con->finalArgvCount = 0;

    if (con->arg_strip) {
      PBM_FREE(con->arg_strip);
      con->arg_strip = NULL;
    }
}

/* Only one of longName, shortName may be set at a time */
static int handleExec(poptContext con, char * longName, char shortName) {
    int i;

    i = con->numExecs - 1;
    if (longName) {
      while (i >= 0 && (!con->execs[i].longName ||
          strcmp(con->execs[i].longName, longName))) i--;
    } else {
      while (i >= 0 &&
          con->execs[i].shortName != shortName) i--;
    }

    if (i < 0) return 0;

    if (con->flags & POPT_CONTEXT_NO_EXEC)
      return 1;

    if (con->doExec == NULL) {
      con->doExec = con->execs + i;
      return 1;
    }

    /* We already have an exec to do; remember this option for next
       time 'round */
    if ((con->finalArgvCount + 1) >= (con->finalArgvAlloced)) {
      con->finalArgvAlloced += 10;
      con->finalArgv = (const char **)realloc(con->finalArgv,
                  sizeof(*con->finalArgv) * con->finalArgvAlloced);
    }

    i = con->finalArgvCount++;
    { char *s  = malloc((longName ? strlen(longName) : 0) + 3);
      if (longName)
          sprintf(s, "--%s", longName);
      else
          sprintf(s, "-%c", shortName);
      con->finalArgv[i] = s;
    }

    return 1;
}

/* Only one of longName, shortName may be set at a time */
static int handleAlias(poptContext con, const char * longName, char shortName,
                   /*@keep@*/ const char * nextCharArg) {
    int i;

    if (con->os->currAlias && con->os->currAlias->longName && longName &&
      !strcmp(con->os->currAlias->longName, longName))
      return 0;
    if (con->os->currAlias && shortName &&
          shortName == con->os->currAlias->shortName)
      return 0;

    i = con->numAliases - 1;
    if (longName) {
      while (i >= 0 && (!con->aliases[i].longName ||
          strcmp(con->aliases[i].longName, longName))) i--;
    } else {
      while (i >= 0 &&
          con->aliases[i].shortName != shortName) i--;
    }

    if (i < 0) return 0;

    if ((con->os - con->optionStack + 1) == POPT_OPTION_DEPTH)
      return POPT_ERROR_OPTSTOODEEP;

    if (nextCharArg && *nextCharArg)
      con->os->nextCharArg = nextCharArg;

    con->os++;
    con->os->next = 0;
    con->os->stuffed = 0;
    con->os->nextArg = NULL;
    con->os->nextCharArg = NULL;
    con->os->currAlias = con->aliases + i;
    poptDupArgv(con->os->currAlias->argc, con->os->currAlias->argv,
            &con->os->argc, &con->os->argv);
    con->os->argb = NULL;

    return 1;
}

static void execCommand(poptContext con) {
    const char ** argv;
    int pos = 0;
    const char * script = con->doExec->script;

    argv = (const char **)malloc(sizeof(*argv) *
                  (6 + con->numLeftovers + con->finalArgvCount));

    if (!con->execAbsolute && strchr(script, '/')) return;

    if (!strchr(script, '/') && con->execPath) {
      char *s = malloc(strlen(con->execPath) + strlen(script) + 2);
      sprintf(s, "%s/%s", con->execPath, script);
      argv[pos] = s;
    } else {
      argv[pos] = script;
    }
    pos++;

    argv[pos] = findProgramPath(con->os->argv[0]);
    if (argv[pos]) pos++;
    argv[pos++] = ";";

    memcpy(argv + pos, con->finalArgv, sizeof(*argv) * con->finalArgvCount);
    pos += con->finalArgvCount;

    if (con->numLeftovers) {
      argv[pos++] = "--";
      memcpy(argv + pos, con->leftovers, sizeof(*argv) * con->numLeftovers);
      pos += con->numLeftovers;
    }

    argv[pos++] = NULL;

#ifdef __hpux
    setresuid(getuid(), getuid(),-1);
#else
/*
 * XXX " ... on BSD systems setuid() should be preferred over setreuid()"
 * XXX      sez' Timur Bakeyev <mc@bat.ru>
 * XXX      from Norbert Warmuth <nwarmuth@privat.circular.de>
 */
#if defined(HAVE_SETUID)
    setuid(getuid());
#elif defined (HAVE_SETREUID)
    setreuid(getuid(), getuid()); /*hlauer: not portable to hpux9.01 */
#else
    ; /* Can't drop privileges */
#endif
#endif

    execvp(argv[0], (char *const *)argv);
}

/*@observer@*/ static const struct poptOption *
findOption(const struct poptOption * table, const char * longName,
    char shortName,
    /*@out@*/ poptCallbackType * callback, /*@out@*/ const void ** callbackData,
    int singleDash)
{
    const struct poptOption * opt = table;
    const struct poptOption * opt2;
    const struct poptOption * cb = NULL;

    /* This happens when a single - is given */
    if (singleDash && !shortName && !*longName)
      shortName = '-';

    while (opt->longName || opt->shortName || opt->arg) {
      if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
          opt2 = findOption(opt->arg, longName, shortName, callback,
                        callbackData, singleDash);
          if (opt2) {
            if (*callback && !*callbackData)
                *callbackData = opt->descrip;
            return opt2;
          }
      } else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK) {
          cb = opt;
      } else if (longName && opt->longName &&
               (!singleDash || (opt->argInfo & POPT_ARGFLAG_ONEDASH)) &&
               !strcmp(longName, opt->longName)) {
          break;
      } else if (shortName && shortName == opt->shortName) {
          break;
      }
      opt++;
    }

    if (!opt->longName && !opt->shortName) return NULL;
    *callbackData = NULL;
    *callback = NULL;
    if (cb) {
      *callback = (poptCallbackType)cb->arg;
      if (!(cb->argInfo & POPT_CBFLAG_INC_DATA))
          *callbackData = cb->descrip;
    }

    return opt;
}

static const char *findNextArg(poptContext con, unsigned argx, int delete)
{
    struct optionStackEntry * os = con->os;
    const char * arg;

    do {
      int i;
      arg = NULL;
      while (os->next == os->argc && os > con->optionStack) os--;
      if (os->next == os->argc && os == con->optionStack) break;
      for (i = os->next; i < os->argc; i++) {
          if (os->argb && PBM_ISSET(i, os->argb)) continue;
          if (*os->argv[i] == '-') continue;
          if (--argx > 0) continue;
          arg = os->argv[i];
          if (delete) {
            if (os->argb == NULL) os->argb = PBM_ALLOC(os->argc);
            PBM_SET(i, os->argb);
          }
          break;
      }
      if (os > con->optionStack) os--;
    } while (arg == NULL);
    return arg;
}

static /*@only@*/ const char * expandNextArg(poptContext con, const char * s)
{
    const char *a;
    size_t alen;
    char *t, *te;
    size_t tn = strlen(s) + 1;
    char c;

    te = t = malloc(tn);;
    while ((c = *s++) != '\0') {
      switch (c) {
#if 0 /* XXX can't do this */
      case '\\':  /* escape */
          c = *s++;
          break;
#endif
      case '!':
          if (!(s[0] == '#' && s[1] == ':' && s[2] == '+'))
            break;
          if ((a = findNextArg(con, 1, 1)) == NULL)
            break;
          s += 3;

          alen = strlen(a);
          tn += alen;
          *te = '\0';
          t = realloc(t, tn);
          te = t + strlen(t);
          strncpy(te, a, alen); te += alen;
          continue;
          /*@notreached@*/ break;
      default:
          break;
      }
      *te++ = c;
    }
    *te = '\0';
    t = realloc(t, strlen(t)+1);    /* XXX memory leak, hard to plug */
    return t;
}

static void poptStripArg(poptContext con, int which)
{
    if(con->arg_strip == NULL) {
      con->arg_strip = PBM_ALLOC(con->optionStack[0].argc);
    }
    PBM_SET(which, con->arg_strip);
}

/* returns 'val' element, -1 on last item, POPT_ERROR_* on error */
int poptGetNextOpt(poptContext con)
{
    const struct poptOption * opt = NULL;
    int done = 0;

    /* looks a bit tricky to get rid of alloca properly in this fn */
#if HAVE_ALLOCA_H
#define ALLOCA(x) alloca(x)
#else
#define ALLOCA(x) malloc(x)
#endif


    while (!done) {
      const char * origOptString = NULL;
      poptCallbackType cb = NULL;
      const void * cbData = NULL;
      const char * longArg = NULL;
      int canstrip = 0;

      while (!con->os->nextCharArg && con->os->next == con->os->argc
            && con->os > con->optionStack) {
          cleanOSE(con->os--);
      }
      if (!con->os->nextCharArg && con->os->next == con->os->argc) {
          invokeCallbacks(con, con->options, 1);
          if (con->doExec) execCommand(con);
          return -1;
      }

      /* Process next long option */
      if (!con->os->nextCharArg) {
          char * localOptString, * optString;
          int thisopt;

          if (con->os->argb && PBM_ISSET(con->os->next, con->os->argb)) {
            con->os->next++;
            continue;
          }
          thisopt=con->os->next;
          origOptString = con->os->argv[con->os->next++];

          if (con->restLeftover || *origOptString != '-') {
            con->leftovers[con->numLeftovers++] = origOptString;
            if (con->flags & POPT_CONTEXT_POSIXMEHARDER)
                con->restLeftover = 1;
            continue;
          }

          /* Make a copy we can hack at */
          localOptString = optString =
                  strcpy(ALLOCA(strlen(origOptString) + 1),
                  origOptString);

          if (!optString[0])
            return POPT_ERROR_BADOPT;

          if (optString[1] == '-' && !optString[2]) {
            con->restLeftover = 1;
            continue;
          } else {
            char *oe;
            int singleDash;

            optString++;
            if (*optString == '-')
                singleDash = 0, optString++;
            else
                singleDash = 1;

            /* XXX aliases with arg substitution need "--alias=arg" */
            if (handleAlias(con, optString, '\0', NULL))
                continue;
            if (handleExec(con, optString, '\0'))
                continue;

            /* Check for "--long=arg" option. */
            for (oe = optString; *oe && *oe != '='; oe++)
                ;
            if (*oe == '=') {
                *oe++ = '\0';
                /* XXX longArg is mapped back to persistent storage. */
                longArg = origOptString + (oe - localOptString);
            }

            opt = findOption(con->options, optString, '\0', &cb, &cbData,
                         singleDash);
            if (!opt && !singleDash)
                return POPT_ERROR_BADOPT;
          }

          if (!opt) {
            con->os->nextCharArg = origOptString + 1;
          } else {
            if(con->os == con->optionStack &&
               opt->argInfo & POPT_ARGFLAG_STRIP) {
                canstrip = 1;
                poptStripArg(con, thisopt);
            }
          }
      }

      /* Process next short option */
      if (con->os->nextCharArg) {
          origOptString = con->os->nextCharArg;

          con->os->nextCharArg = NULL;

          if (handleAlias(con, NULL, *origOptString,
                      origOptString + 1)) {
            origOptString++;
            continue;
          }
          if (handleExec(con, NULL, *origOptString))
            continue;

          opt = findOption(con->options, NULL, *origOptString, &cb,
                       &cbData, 0);
          if (!opt)
            return POPT_ERROR_BADOPT;

          origOptString++;
          if (*origOptString)
            con->os->nextCharArg = origOptString;
      }

      if (opt->arg && (opt->argInfo & POPT_ARG_MASK) == POPT_ARG_NONE) {
          *((int *)opt->arg) = 1;
      } else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_VAL) {
          if (opt->arg)
            *((int *) opt->arg) = opt->val;
      } else if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE) {
          if (con->os->nextArg) {
            xfree(con->os->nextArg);
            con->os->nextArg = NULL;
          }
          if (longArg) {
            con->os->nextArg = expandNextArg(con, longArg);
          } else if (con->os->nextCharArg) {
            con->os->nextArg = expandNextArg(con, con->os->nextCharArg);
            con->os->nextCharArg = NULL;
          } else {
            while (con->os->next == con->os->argc &&
                   con->os > con->optionStack) {
                cleanOSE(con->os--);
            }
            if (con->os->next == con->os->argc)
                return POPT_ERROR_NOARG;

            /* make sure this isn't part of a short arg or the
                   result of an alias expansion */
            if(con->os == con->optionStack &&
               opt->argInfo & POPT_ARGFLAG_STRIP &&
               canstrip) {
                poptStripArg(con, con->os->next);
            }
            
            con->os->nextArg = expandNextArg(con, con->os->argv[con->os->next++]);
          }

          if (opt->arg) {
            long aLong;
            char *end;

            switch (opt->argInfo & POPT_ARG_MASK) {
              case POPT_ARG_STRING:
                /* XXX memory leak, hard to plug */
                *((const char **) opt->arg) = xstrdup(con->os->nextArg);
                break;

              case POPT_ARG_INT:
              case POPT_ARG_LONG:
                aLong = strtol(con->os->nextArg, &end, 0);
                if (!(end && *end == '\0'))
                  return POPT_ERROR_BADNUMBER;

                if (aLong == LONG_MIN || aLong == LONG_MAX)
                  return POPT_ERROR_OVERFLOW;
                if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_LONG) {
                  *((long *) opt->arg) = aLong;
                } else {
                  if (aLong > INT_MAX || aLong < INT_MIN)
                      return POPT_ERROR_OVERFLOW;
                  *((int *) opt->arg) = aLong;
                }
                break;

              default:
                fprintf(stdout, POPT_("option type (%d) not implemented in popt\n"),
                  opt->argInfo & POPT_ARG_MASK);
                exit(EXIT_FAILURE);
            }
          }
      }

      if (cb)
          cb(con, POPT_CALLBACK_REASON_OPTION, opt, con->os->nextArg, cbData);
      else if (opt->val && ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_VAL))
          done = 1;

      if ((con->finalArgvCount + 2) >= (con->finalArgvAlloced)) {
          con->finalArgvAlloced += 10;
          con->finalArgv = (const char **)realloc(con->finalArgv,
                      sizeof(*con->finalArgv) * con->finalArgvAlloced);
      }

      {    char *s = malloc((opt->longName ? strlen(opt->longName) : 0) + 3);
          if (opt->longName)
            sprintf(s, "--%s", opt->longName);
          else
            sprintf(s, "-%c", opt->shortName);
          con->finalArgv[con->finalArgvCount++] = s;
      }

      if (opt->arg && (opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE
                 && (opt->argInfo & POPT_ARG_MASK) != POPT_ARG_VAL) {
          con->finalArgv[con->finalArgvCount++] = xstrdup(con->os->nextArg);
      }
    }

    return opt->val;
}

const char * poptGetOptArg(poptContext con) {
    const char * ret = con->os->nextArg;
    con->os->nextArg = NULL;
    return ret;
}

const char * poptGetArg(poptContext con) {
    if (con->numLeftovers == con->nextLeftover) return NULL;
    return con->leftovers[con->nextLeftover++];
}

const char * poptPeekArg(poptContext con) {
    if (con->numLeftovers == con->nextLeftover) return NULL;
    return con->leftovers[con->nextLeftover];
}

const char ** poptGetArgs(poptContext con) {
    if (con->numLeftovers == con->nextLeftover) return NULL;

    /* some apps like [like RPM ;-) ] need this NULL terminated */
    con->leftovers[con->numLeftovers] = NULL;

    return (con->leftovers + con->nextLeftover);
}

void poptFreeContext(poptContext con) {
    int i;

    poptResetContext(con);
    if (con->os->argb) free(con->os->argb);

    for (i = 0; i < con->numAliases; i++) {
      if (con->aliases[i].longName) xfree(con->aliases[i].longName);
      free(con->aliases[i].argv);
    }

    for (i = 0; i < con->numExecs; i++) {
      if (con->execs[i].longName) xfree(con->execs[i].longName);
      xfree(con->execs[i].script);
    }
    if (con->execs) xfree(con->execs);

    free(con->leftovers);
    free(con->finalArgv);
    if (con->appName) xfree(con->appName);
    if (con->aliases) free(con->aliases);
    if (con->otherHelp) xfree(con->otherHelp);
    if (con->execPath) xfree(con->execPath);
    if (con->arg_strip) PBM_FREE(con->arg_strip);
    
    free(con);
}

int poptAddAlias(poptContext con, struct poptAlias newAlias,
            /*@unused@*/ int flags)
{
    int aliasNum = con->numAliases++;
    struct poptAlias * alias;

    /* SunOS won't realloc(NULL, ...) */
    if (!con->aliases)
      con->aliases = (struct poptAlias *)malloc(sizeof(newAlias) * con->numAliases);
    else
      con->aliases = (struct poptAlias *)realloc(con->aliases,
                         sizeof(newAlias) * con->numAliases);
    alias = con->aliases + aliasNum;

    alias->longName = (newAlias.longName)
      ? strcpy(malloc(strlen(newAlias.longName) + 1), newAlias.longName)
      : NULL;
    alias->shortName = newAlias.shortName;
    alias->argc = newAlias.argc;
    alias->argv = newAlias.argv;

    return 0;
}

const char * poptBadOption(poptContext con, int flags) {
    struct optionStackEntry * os;

    if (flags & POPT_BADOPTION_NOALIAS)
      os = con->optionStack;
    else
      os = con->os;

    return os->argv[os->next - 1];
}

#define POPT_ERROR_NOARG      -10
#define POPT_ERROR_BADOPT     -11
#define POPT_ERROR_OPTSTOODEEP      -13
#define POPT_ERROR_BADQUOTE   -15   /* only from poptParseArgString() */
#define POPT_ERROR_ERRNO      -16   /* only from poptParseArgString() */

const char *poptStrerror(const int error) {
    switch (error) {
      case POPT_ERROR_NOARG:
      return POPT_("missing argument");
      case POPT_ERROR_BADOPT:
      return POPT_("unknown option");
      case POPT_ERROR_OPTSTOODEEP:
      return POPT_("aliases nested too deeply");
      case POPT_ERROR_BADQUOTE:
      return POPT_("error in paramter quoting");
      case POPT_ERROR_BADNUMBER:
      return POPT_("invalid numeric value");
      case POPT_ERROR_OVERFLOW:
      return POPT_("number too large or too small");
      case POPT_ERROR_ERRNO:
      return strerror(errno);
      default:
      return POPT_("unknown error");
    }
}

int poptStuffArgs(poptContext con, const char ** argv) {
    int argc;

    if ((con->os - con->optionStack) == POPT_OPTION_DEPTH)
      return POPT_ERROR_OPTSTOODEEP;

    for (argc = 0; argv[argc]; argc++)
      ;

    con->os++;
    con->os->next = 0;
    con->os->nextArg = NULL;
    con->os->nextCharArg = NULL;
    con->os->currAlias = NULL;
    poptDupArgv(argc, argv, &con->os->argc, &con->os->argv);
    con->os->argb = NULL;
    con->os->stuffed = 1;

    return 0;
}

const char * poptGetInvocationName(poptContext con) {
    return con->os->argv[0];
}

int poptStrippedArgv(poptContext con, int argc, char **argv)
{
    int i,j=1, numargs=argc;
    
    for(i=1; i<argc; i++) {
      if(PBM_ISSET(i, con->arg_strip)) {
          numargs--;
      }
    }
    
    for(i=1; i<argc; i++) {
      if(PBM_ISSET(i, con->arg_strip)) {
          continue;
      } else {
          if(j<numargs) {
            argv[j++]=argv[i];
          } else {
            argv[j++]='\0';
          }
      }
    }
    
    return(numargs);
}

Generated by  Doxygen 1.6.0   Back to index