Initial revision

[become] / src / name.c

/* -*-c-*-
 *
 * $Id: name.c,v 1.1 1997/07/21 13:47:46 mdw Exp $
 *
 * Looking up of names in symbol tables
 *
 * (c) 1997 EBI
 */

/*----- Licencing notice --------------------------------------------------*
 *
 * This file is part of `become'
 *
 * `Become' 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.
 *
 * `Become' 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 `become'; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: name.c,v $
 * Revision 1.1  1997/07/21 13:47:46  mdw
 * Initial revision
 *
 */

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

/* --- ANSI headers --- */

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

/* --- Unix headers --- */

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

/* --- Local headers --- */

#include "class.h"
#include "name.h"
#include "sym.h"
#include "userdb.h"
#include "utils.h"

/*----- Static variables --------------------------------------------------*/

static sym_table name__table;           /* Symbol table for everything */

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

/* --- @name_init@ --- *
 *
 * Arguments:   ---
 *
 * Returns:     ---
 *
 * Use:         Initialises the name table.  Requires the user database to
 *              be populated (see @userdb_local@ and @userdb_yp@).
 */

void name_init(void)
{
  /* --- Initialise the name table --- */

  sym_createTable(&name__table);

  /* --- Insert all the users and groups into the table --- */

  {
    struct passwd *pw;
    struct group *gr;

    userdb_iterateUsers();
    while ((pw = userdb_nextUser()) != 0) {
      unsigned f;
      name *n;
      int u;

      /* --- First, add the user to the table --- */

      n = sym_find(&name__table, pw->pw_name, -1, sizeof(name), &f);
      if (!f) {
        sym_table *t = xmalloc(sizeof(*t));
        sym_createTable(t);
        n->c = class_create(clType_user, t);
      }
      u = pw->pw_uid;
      sym_find(n->c->t, (char *)&u, sizeof(u), sizeof(sym_base), 0);

      /* --- Now handle the user's default group --- */

      if ((gr = userdb_groupById(pw->pw_gid)) != 0) {
        n = sym_find(&name__table, gr->gr_name, -1, sizeof(name), &f);
        if (!f) {
          sym_table *t = xmalloc(sizeof(*t));
          sym_createTable(t);
          n->c = class_create(clType_user, t);
        }
        sym_find(n->c->t, (char *)&u, sizeof(u), sizeof(sym_base), 0);
      }
    }
  }

  /* --- Now get the subsidiary groups --- */

  {
    struct group *gr;
    struct passwd *pw;
    char **p;

    userdb_iterateGroups();
    while ((gr = userdb_nextGroup()) != 0) {
      unsigned f;
      name *n;
      int u;

      n = sym_find(&name__table, gr->gr_name, -1, sizeof(name), &f);
      if (!f) {
        sym_table *t = xmalloc(sizeof(*t));
        sym_createTable(t);
        n->c = class_create(clType_user, t);
      }

      for (p = gr->gr_mem; *p; p++) {
        if ((pw = userdb_userByName(*p)) != 0) {
          u = pw->pw_uid;
          sym_find(n->c->t, (char *)&u, sizeof(u), sizeof(sym_base), 0);
        }
      }
    }
  }

  /* --- Finally add in the `all' class --- *
   *
   * Do that now, to prevent it being overwritten by the above.
   */

  {
    name *n;
    unsigned f;

    n = sym_find(&name__table, "all", -1, sizeof(name), &f);
    if (f)
      class_dec(n->c);
    n->c = class_all;
  }
}

/* --- @name_reinit@ --- *
 *
 * Arguments:   ---
 *
 * Returns:     ---
 *
 * Use:         Reinitialises the names table.  It's cleared and then
 *              initialised with the current user and group ids as for
 *              @name_init@ above.
 */

void name_reinit(void)
{
  /* --- Empty the symbol table --- */

  {
    sym_iter i;
    name *n;

    for (sym_createIter(&i, &name__table); (n = sym_next(&i)) != 0; ) {
      if (n->c)
        class_dec(n->c);
    }
  }

  /* --- Destroy and recreate the table --- */

  sym_destroyTable(&name__table);
  name_init();
}

/* --- @name_find@ --- *
 *
 * Arguments:   @const char *p@ = pointer to name to look up
 *              @unsigned create@ = whether to create the item
 *              @unsigned *f@ = whether the item was created
 *
 * Returns:     Pointer to a @name@ block containing the symbol, or
 *              zero if it wasn't found and we didn't want to create a
 *              new one.
 *
 * Use:         Looks up a name in the symbol table and returns the
 *              item so located.
 */

name *name_find(const char *p, unsigned create, unsigned *f)
{
  /* --- This is a trivial veneer onto @sym_find@ --- */

  return (sym_find(&name__table, p, -1, create ? sizeof(name) : 0, f));
}

/* --- @name_dump@ --- *
 *
 * Arguments:   @FILE *fp@ = stream to dump on
 *
 * Returns:     ---
 *
 * Use:         Dumps a complete listing of the symbol table.
 */

void name_dump(FILE *fp)
{
  sym_iter i;
  name *n;

  for (sym_createIter(&i, &name__table); (n = sym_next(&i)) != 0; ) {
    fprintf(fp, "\n--- name `%s'\n", n->base.name);
    class_dump(n->c, fp);
  }
}  

/*----- Test driver -------------------------------------------------------*/

#ifdef TEST_RIG

int main(void)
{
  userdb_init();
  userdb_local();
  userdb_yp();
  name_init();
  name_dump(stdout);
  return (0);
}

#endif