Fix whitespace throughout.

[fwd] / fattr.c

/* -*-c-*-
 *
 * Handling of file attributes
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the `fw' port forwarder.
 *
 * `fw' 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.
 *
 * `fw' 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 `fw'; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <pwd.h>
#include <grp.h>

#include "conf.h"
#include "fattr.h"
#include "scan.h"

/*----- Global variables --------------------------------------------------*/

fattr fattr_global;

/*----- Main code ---------------------------------------------------------*/

/* --- @fattr_init@ --- *
 *
 * Arguments:   @fattr *f@ = pointer to file attributes
 *
 * Returns:     ---
 *
 * Use:         Initializes a set of file attributes to default values.
 */

void fattr_init(fattr *f)
{
  unsigned um = umask(0);
  umask(um);
  f->mode = 0666 & ~um;
  f->uid = -1;
  f->gid = -1;
}

/* --- @fattr_option@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to scanner to read
 *              @fattr *f@ = pointer to file attributes to set
 *
 * Returns:     Whether the option was claimed.
 *
 * Use:         Reads file attributes from a scanner.
 */

int fattr_option(scanner *sc, fattr *f)
{
  CONF_BEGIN(sc, "fattr", "file attribute")

  /* --- Read a file mode specification --- */

  if (strcmp(sc->d.buf, "mode") == 0) {
    unsigned mode = 0;

    /* --- Gobble an optional `=' sign --- */

    conf_undelim(sc, 0, ",=+-");
    token(sc);
    if (sc->t == '=')
      token(sc);

    if (sc->t != CTOK_WORD)
      error(sc, "parse error, expected file mode");
    conf_undelim(sc, 0, 0);

    /* --- If it looks digitlike, read as octal --- */

    if (isdigit((unsigned char)*sc->d.buf))
      mode = strtoul(sc->d.buf, 0, 8) & 07777;

    /* --- Otherise read as chmod-like characters --- */

    else {
      const char *p;
      unsigned mask = 04700;
      unsigned state = 0;
      unsigned or = 1;

      /* --- Set the default from the umask --- */

      {
        unsigned um = umask(0);
        umask(um);
        mode = 0666 & ~um;
      }

      /* --- Parse the characters --- *
       *
       * This is a particularly lenient implementation of the usual chmod-
       * style mode language.
       */

      for (p = sc->d.buf; *p; p++) {
        switch (*p) {
          case ',': break;

          case 'a': mask = (mask & state) | 07777; state = 07777; break;
          case 'u': mask = (mask & state) | 04700; state = 07777; break;
          case 'g': mask = (mask & state) | 02070; state = 07777; break;
          case 'o': mask = (mask & state) | 01007; state = 07777; break;

          case '=': mode &= ~mask; /* Drop through */
          case '+': state = 0; or = 1; break;
          case '-': state = 0; or = 0; break;

#define APPLY(m) if (or) mode |= ((m) & mask); else mode &= ~((m) & mask);
          case 'r': state = 0; APPLY(00444); break;
          case 'w': state = 0; APPLY(00222); break;
          case 'x': state = 0; APPLY(00111); break;
          case 's': state = 0; APPLY(06000); break;
          case 't': state = 0; APPLY(01000); break;
#undef APPLY

          default: error(sc, "unknown mode character `%c'", *p);
        }
      }
    }

    token(sc);
    f->mode = mode;
    CONF_ACCEPT;
  }

  /* --- Read a file uid specification --- */

  if (strcmp(sc->d.buf, "uid") == 0 ||
      strcmp(sc->d.buf, "user") == 0 ||
      strcmp(sc->d.buf, "owner") == 0) {
    token(sc);
    if (sc->t == '=')
      token(sc);
    if (sc->t != CTOK_WORD)
      error(sc, "parse error, expected user name or uid");
    if (isdigit((unsigned char)*sc->d.buf))
      f->uid = atoi(sc->d.buf);
    else {
      struct passwd *pw = getpwnam(sc->d.buf);
      if (!pw)
        error(sc, "unknown user name `%s'", sc->d.buf);
      f->uid = pw->pw_uid;
    }
    token(sc);
    CONF_ACCEPT;
  }

  /* --- Read a file gid specification --- */

  if (strcmp(sc->d.buf, "gid") == 0 ||
      strcmp(sc->d.buf, "group") == 0) {
    token(sc);
    if (sc->t == '=')
      token(sc);
    if (sc->t != CTOK_WORD)
      error(sc, "parse error, expected group name or gid");
    if (isdigit((unsigned char)*sc->d.buf))
      f->gid = atoi(sc->d.buf);
    else {
      struct group *gr = getgrnam(sc->d.buf);
      if (!gr)
        error(sc, "unknown user name `%s'", sc->d.buf);
      f->gid = gr->gr_gid;
    }
    token(sc);
    CONF_ACCEPT;
  }

  /* --- Nothing here for me --- */

  CONF_END;
}

/* --- @fattr_apply@ --- *
 *
 * Arguments:   @const char *file@ = pointer to filename
 *              @fattr *f@ = pointer to attribute set
 *
 * Returns:     @-1@ if it failed.
 *
 * Use:         Applies file attributes to a file.  For best results, try to
 *              create the file with the right permissions and so on.  This
 *              call will fix everything up, but there are potential races
 *              which might catch you out if you're not careful.
 */

int fattr_apply(const char *file, fattr *f)
{
  if (chown(file, f->uid, f->gid) == -1 ||
      chmod(file, f->mode) == -1)
    return (-1);
  return (0);
}

/*----- That's all, folks -------------------------------------------------*/