New source file added to acquire environmental noise and add it to the

[become] / src / class.c

/* -*-c-*-
 *
 * $Id: class.c,v 1.2 1997/08/04 10:24:21 mdw Exp $
 *
 * Handling classes of things nicely
 *
 * (c) 1997 EBI
 */

/*----- Licensing 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: class.c,v $
 * Revision 1.2  1997/08/04 10:24:21  mdw
 * Sources placed under CVS control.
 *
 * Revision 1.1  1997/07/21  13:47:52  mdw
 * Initial revision
 *
 */

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

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

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

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

#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

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

#include "become.h"
#include "class.h"
#include "set.h"
#include "sym.h"
#include "utils.h"

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

static classdef class__all = { clType_all, -1, 0 };
classdef *class_all = &class__all;

/*----- Wildcard matching -------------------------------------------------*/

/* --- @class__wildMatch@ --- *
 *
 * Arguments:	@const char *pat@ = pointer to pattern string
 *		@const char *p@ = pointer to target string
 *
 * Returns:	Zero if no match, nonzero if match.
 *
 * Use:		Wildcard-matches the pattern against the target string.
 */

static int class__wildMatch(const char *pat, const char *p)
{
  for (;;) {
    if (*pat == 0 && *p == 0)
      return (42); /* For sadism's sake */
    else if (*pat == '*') {
      while (*pat == '*')
	pat++;
      do {
	if (class__wildMatch(pat, p))
	  return (27); /* Nyahaha */
	p++;
      } while (*p);
      return (0);
    } else if (*pat == '?' || *pat == *p)
      p++, pat++;
    else
      return (0);
  }
}

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

/* --- @class_create@ --- *
 *
 * Arguments:	@unsigned type@ = type of the class to create
 *		@sym_table *t@ = pointer to symbol table which stores info
 *
 * Returns:	Pointer to a @classdef@ which maintains the class's info.
 *
 * Use:		Creates a new class definition.  The new definition has one
 *		reference attached to it (which is the one you get returned).
 */

classdef *class_create(unsigned type, sym_table *t)
{
  classdef *c = xmalloc(sizeof(*c));
  c->type = type;
  c->ref = 1;
  c->t = t;
  return (c);
}

/* --- @class_inc@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to a class block
 *
 * Returns:	---
 *
 * Use:		Adds a reference to the class definition.
 */

void class_inc(classdef *c)
{
  if (c != class_all)
    c->ref++;
}

/* --- @class_dec@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to a class block
 *
 * Returns:	---
 *
 * Use:		Removes a reference to a class block.
 */

void class_dec(classdef *c)
{
  if (c != class_all && !--c->ref) {
    sym_destroyTable(c->t);
    free(c);
  }
}

/* --- @class_userMatch@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to a class block
 *		@int u@ = uid number to check against
 *
 * Returns:	Zero if no match, nonzero if it matched.
 *
 * Use:		Looks to see if a user is in a group.
 */

int class_userMatch(classdef *c, int u)
{
  if (~c->type & clType_user)
    return (0);
  else if (c == class_all) {
    T( trace(TRACE_CHECK, "check: user %i matched by all", u); )
    return (1);
  } else {
    sym_base *s = sym_find(c->t, (char *)&u, sizeof(u), 0, 0);
    T( trace(TRACE_CHECK,
	     s ? "check: user %i matched" : "check: user %i not matched",
	     u); )
    return (s != 0);
  }
}

/* --- @class_commandMatch@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to a class block
 *		@const char *p@ = pointer to command string to match
 *
 * Returns:	Zero for no match, nonzero if it matched.
 *
 * Use:		Tries to match a string against the wildcard patterns in the
 *		given class.  Note that this involves examining all the
 *		items, so it's not too quick.  Then again, you don't have
 *		big command classes, do you...?
 */

int class_commandMatch(classdef *c, const char *p)
{
  sym_iter i;
  sym_base *s;

  if (~c->type & clType_command)
    return (0);
  else if (c == class_all) {
    T( trace(TRACE_CHECK, "check: command `%s' matched by all", p); )
    return (1);
  } else {
    for (sym_createIter(&i, c->t); (s = sym_next(&i)) != 0; ) {
      if (class__wildMatch(s->name, p)) {
	T( trace(TRACE_CHECK, "check: command `%s' matched by `%s'",
		 p, s->name); )
	return (1);
      }
    }
    T( trace(TRACE_CHECK, "check: command `%s' not matched", p); )
    return (0);
  }
}

/* --- @class_hostMatch@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to class block
 *		@struct in_addr addr@ = IP address to match
 *
 * Returns:	Zero for no match, nonzero if it matched.
 *
 * Use:		Tries to match an IP address against the patterns and masks
 *		in the given class.
 */

int class_hostMatch(classdef *c, struct in_addr addr)
{
  sym_iter i;
  sym_base *s;
  const char *a;
  struct hostent *he;
  char **p;

  if (~c->type & clType_host)
    return (0);
  else if (c == class_all) {
    T( trace(TRACE_CHECK, "check: host %s matched by all",
	     inet_ntoa(addr)); )
    return (1);
  } else {

    /* --- Get the dotted-quad and other names for the address --- */

    if ((a = inet_ntoa(addr)) == 0) {
      T( trace(TRACE_CHECK, "check: couldn't translate address (erk!)"); )
      return (0);
    }
    if ((he = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET)) == 0) {
      T( trace(TRACE_CHECK, "check: couldn't resolve hostname for %s", a); )
      return (0);
    }

    /* --- Now search the list for a match --- *
     *
     * This is almost infinitely slow, I'm afraid.
     */

    for (sym_createIter(&i, c->t); (s = sym_next(&i)) != 0; ) {

      /* --- Check the dotted-quad name first --- */

      if (class__wildMatch(s->name, a)) {
	T( trace(TRACE_CHECK, "check: host address `%s' matched by `%s'",
		 a, s->name); )
	return (1);
      }

      /* --- Now try the host's main name --- */

      if (class__wildMatch(s->name, he->h_name)) {
	T( trace(TRACE_CHECK, "check: host name `%s' matched by `%s'",
		 he->h_name, s->name); )
	return (1);
      }

      /* --- Now go through all the names --- */

      for (p = he->h_aliases; *p; p++) {
	if (class__wildMatch(s->name, *p)) {
	  T( trace(TRACE_CHECK, "check: host alias `%s' matched by `%s'",
		   *p, s->name); )
	  return (1);
	}
      }
    }

    T( trace(TRACE_CHECK, "check: couldn't match hostname `%s'",
	     he->h_name); )
    return (0);
  }
}

/* --- @class_dump@ --- *
 *
 * Arguments:	@classdef *c@ = pointer to a class block
 *
 * Returns:	---
 *
 * Use:		Dumps the contents of a class to a stream.
 */

void class_dump(classdef *c)
{
  sym_iter i;
  sym_base *s;

  /* --- Dump the table --- */

  if (c->type != clType_all) {
    for (sym_createIter(&i, c->t); (s = sym_next(&i)) != 0; ) {
      switch (c->type) {
	case clType_user:
	  trace(TRACE_RULE, "    %i", *(int *)s->name);
	  break;
	case clType_command:
	case clType_host:
	  trace(TRACE_RULE, "    `%s'", s->name);
	  break;
      }
    }
  }
  else
    trace(TRACE_RULE, "    ALL");
}

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