tc_path.c

Go to the documentation of this file.

/*
** Copyright (C) 2004, 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can 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 of the License, or
** (at your option) any later version.
**
** This program 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 this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: tc_path.c,v 1.7 2005/06/08 13:17:36 klmitch Exp $
*/
#include <errno.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#include "treeconf_int.h"

RCSTAG("@(#)$Id: tc_path.c,v 1.7 2005/06/08 13:17:36 klmitch Exp $");

struct buf {
  char             *str;      
  int       len;  
  int       size; 
};

#define BUF_CHUNK       256

static unsigned int
_get_pwd(struct passwd **pwd_p, const char *uname, int len)
{
  struct passwd *pwd = 0;
  char ubuf[512];

  if (uname) {
    strncpy(ubuf, uname, len); /* copy the name so we can nul-terminate... */
    ubuf[len] = '\0';
    pwd = getpwnam(ubuf); /* Get password entry by name */
  } else
    pwd = getpwuid(geteuid()); /* Get password entry by effective uid */

  if (!pwd) /* couldn't find the entry, it seems... */
    return !errno ? ENOENT : errno; /* errno can sometimes be 0 :/ */

  *pwd_p = pwd; /* return the entry... */

  return 0;
}

static unsigned int
_add_str(struct buf *buf, const char *str, int len)
{
  char *tmp = 0;

  if (!str) { /* empty str means insert user name */
    struct passwd *pwd = 0;
    unsigned int err;

    if ((err = _get_pwd(&pwd, 0, 0))) /* get password entry... */
      return err;

    str = pwd->pw_name; /* string is the password entry... */
    len = strlen(str);
  }

  if (len < 0) /* get length... */
    len = strlen(str);

  if (buf->size < buf->len + len + 1) {
    while (buf->size < buf->len + len) /* how much space do we need? */
      buf->size += BUF_CHUNK;

    /* Allocate the necessary memory... */
    if (!(tmp = (char *)realloc(buf->str, buf->size)))
      return ENOMEM;
    else
      buf->str = tmp;
  }

  strncpy(buf->str + buf->len, str, len); /* copy the string... */
  buf->len += len; /* update the buffer length... */
  buf->str[buf->len] = '\0'; /* and terminate the string */

  return 0;
}

static unsigned int
_tilde(struct buf *buf, const char *uname, int len)
{
  struct passwd *pwd = 0;
  unsigned int err;

  return (err = _get_pwd(&pwd, uname, len)) ? err :
    _add_str(buf, pwd->pw_dir, -1);
}

#define STOP                  0

#define CONTINUE        1

#define stop(e)               do { *err = (e); return STOP; } while (0)

#define cont()                do { *err = 0; return CONTINUE; } while (0)

#define _TC_PATH_DEFAULT      0x04

#define _TC_PATH_PERCENT      0x08

static int
_subst(struct buf *buf, treeconf_str_t *element,
       treeconf_subst_t substs[], int s_cnt, unsigned int flags,
       treeconf_file_t call, void *call_data, unsigned int *err)
{
  const char *str = 0, *tmp = 0;
  unsigned int _e = 0;
  int i, j, len = 0;

  if (!element->ts_length) /* skip empty components--shouldn't happen */
    cont();

  if (*element->ts_string == '~') /* Now, check for ~ expansion... */
    switch (element->ts_length > 1 ? element->ts_string[1] : '\0') {
    case '/': case '\0':
      if (flags & TC_PATH_SECURE)
      cont(); /* ~ is insecure in path string... */
      if ((_e = _tilde(buf, 0, 0))) /* tilde-expand for current uid */
      stop(_e);
      /* get the remainder of the string... */
      str = element->ts_length > 1 ? element->ts_string + 1 : 0;
      len = element->ts_length > 1 ? element->ts_length - 1 : 0;
      break;
    default:
      /* ~name is secure assuming that the path is trusted */
      for (i = 1; i < element->ts_length; i++) /* Find end of user name */
      if (element->ts_string[i] == '/')
        break;
      /* Now tilde-expand for that user */
      if ((_e = _tilde(buf, element->ts_string + 1, i - 2)))
      stop(_e);
      /* Get the remainder of the string... */
      str = i < element->ts_length ? element->ts_string + i : 0;
      len = i < element->ts_length ? element->ts_length - i : 0;
      break;
    }
  else {
    str = element->ts_string; /* Get the string */
    len = element->ts_length;
  }

  /* Now process the rest of the substitutions... */
  for (i = 0, tmp = str; i < len; i++)
    if (flags & _TC_PATH_PERCENT) {
      flags &= ~_TC_PATH_PERCENT; /* character following %... */
      if (str[i] == '%') /* it's an escaped % */
      tmp = str + i; /* Start constant string from here */
      else /* Search the substitutions... */
      for (j = 0; j < s_cnt; j++)
        if (str[i] == substs[j].tu_char) {
          if ((substs[j].tu_flags & TC_SUBST_IGNORE) ||
            (flags & (substs[j].tu_flags & TC_SUBST_INSECURE)))
            cont(); /* if it's insecure, skip it... */
          else if ((_e = _add_str(buf, substs[j].tu_value, -1)))
            stop(_e); /* Add the string... */
          break; /* get out of inner loop... */
        }
      /* If it's an undefined substitution, just skip it */
    } else if (str[i] == '%') {
      if ((_e = _add_str(buf, tmp, (str + i) - tmp))) /* Add constant string */
      stop(_e);
      flags |= _TC_PATH_PERCENT; /* Remember we found a % */
      tmp = 0;
    } else if (!tmp)
      tmp = str + i; /* Start constant string from here */

  if (flags & _TC_PATH_PERCENT) /* trailing %? */
    stop(EINVAL); /* error out... */
  else if (tmp && (_e = _add_str(buf, tmp, (str + i) - tmp)))
    stop(_e); /* Add trailing text... */

  /* Not safe (nor even intended to be safe!) against symlink attacks!  Do
   * not include files in /tmp or similar user-writable directories in the
   * path.
   */
  if (access(buf->str, R_OK)) { /* can we read file? */
    *err = 0; /* clear error... */
    buf->str[0] = '\0';
    buf->len = 0; /* and buffer... */
    cont();
  }

  if ((_e = (call)(buf->str, call_data))) /* call callback */
    stop(_e);

  *err = 0; /* clear error... */
  buf->str[0] = '\0';
  buf->len = 0; /* and buffer... */

  return flags & TC_PATH_ALL ? CONTINUE : STOP;
}

unsigned int
tc_path(const char *path, const char *def,
      treeconf_subst_t substs[], int s_cnt, unsigned int flags,
      treeconf_file_t call, void *call_data)
{
  treeconf_str_t *p_str = 0, *d_str = 0;
  struct buf buf = { 0, 0, 0 };
  int p_cnt, d_cnt, i, j;
  unsigned int err = 0;

  initialize_trcf_error_table();

  /* Sanity-check the arguments */
  if (!def || (s_cnt && !substs) || !call)
    return EINVAL;

  flags &= TC_PATH_SECURE | TC_PATH_ALL; /* set up flags... */

  /* If the path isn't specified, fall back to the default */
  if (!path) {
    path = def;
    flags |= _TC_PATH_DEFAULT;
  }

  /* Break up the path... */
  if ((err = tc_break(&p_str, &p_cnt, path, ":")))
    goto error;

  /* Search the path... */
  for (i = 0; i < p_cnt; i++)
    if (!p_str[i].ts_length) { /* Empty field...hmmm... */
      if (flags & _TC_PATH_DEFAULT)
      continue; /* skip empty fields after default searched */
      flags |= _TC_PATH_DEFAULT;
      if ((err = tc_break(&d_str, &d_cnt, def, ":"))) /* break up default... */
      goto error;
      /* Now search the default path... */
      for (j = 0; j < d_cnt; j++)
      if (!d_str[j].ts_length) /* skip empty fields in default */
        continue;
      else if (_subst(&buf, d_str + j, substs, s_cnt, flags, call,
                  call_data, &err) != CONTINUE)
        goto error; /* have to break out of nested for loop in this case */
    } else if (_subst(&buf, p_str + i, substs, s_cnt, flags, call,
                  call_data, &err) != CONTINUE)
      break; /* Only have to break out of enclosing for loop here... */

 error:
  if (p_str) /* Free allocated memory... */
    free(p_str);
  if (d_str)
    free(d_str);
  if (buf.str)
    free(buf.str);

  return err; /* And return! */
}

---