Initial revision

[become] / src / check.c

/* -*-c-*-
 *
 * $Id: check.c,v 1.1 1997/07/21 13:47:53 mdw Exp $
 *
 * Check validity of requests
 *
 * (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: check.c,v $
 * Revision 1.1  1997/07/21 13:47:53  mdw
 * Initial revision
 *
 */

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

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

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

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

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

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>
#include <unistd.h>

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

#include "become.h"
#include "config.h"
#include "crypt.h"
#include "idea.h"
#include "lexer.h"
#include "name.h"
#include "rule.h"
#include "parser.h"
#include "tx.h"
#include "utils.h"

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

/* --- @check__client@ --- *
 *
 * Arguments:	@request *rq@ = pointer to request buffer
 *		@const char *serv@ = pointer to the server
 *		@int port@ = port number to use
 *
 * Returns:	Nonzero if OK, zero if forbidden
 *
 * Use:		Contacts a server to decide whether the request is OK.
 */

static int check__client(request *rq, const char *serv, int port)
{
  int fd;
  struct sockaddr_in ssin;
  unsigned char crq[crq_size];
  unsigned char k[IDEA_KEYSIZE];
  unsigned char sk[IDEA_KEYSIZE];
  time_t t;
  pid_t pid;

  /* --- Create my socket --- */

  if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
    die("couldn't create socket: %s", strerror(errno));

  /* --- Bind myself to some address --- */

  {
    struct sockaddr_in sin;

    sin.sin_family = AF_INET;
    sin.sin_port = 0;
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
      die("couldn't bind socket to address: %s", strerror(errno));
  }

  /* --- Find the server's address --- */

  {
    struct hostent *he;

    /* --- Resolve the server's name --- */

    if ((he = gethostbyname(serv)) == 0)
      die("couldn't find server host `%s'", serv);

    /* --- Build the address block --- */

    ssin.sin_family = AF_INET;
    ssin.sin_port = htons(port);
    memcpy(&ssin.sin_addr, he->h_addr, sizeof(struct in_addr));
  }

  /* --- Read in the encryption key --- */

  {
    FILE *fp;

    if ((fp = fopen(file_KEY, "r")) == 0) {
      die("couldn't open key file `%s': %s", file_KEY,
	  strerror(errno));
    }
    tx_getBits(k, 128, fp);
  }

  /* --- Now build a request packet --- */

  t = time(0);
  pid = getpid();
  crypt_packRequest(rq, crq, t, pid, k, sk);

  /* --- Send the packet to the server --- */

  if (sendto(fd, (char *)crq, sizeof(crq), 0,
	     (struct sockaddr *)&ssin, sizeof(ssin)) < 0) {
    burn(k);
    die("couldn't send request to server: %s", strerror(errno));
  }
  burn(k);

  /* --- Now wait for a reply --- */

  {
    fd_set fds;
    struct timeval when, now, tv;

    gettimeofday(&when, 0);
    when.tv_sec += 10;

    for (;;) {
      int i;

      /* --- Sort out when to return --- */

      gettimeofday(&now, 0);
      if (now.tv_usec > when.tv_usec) {
	now.tv_usec -= 1000000;
	now.tv_sec += 1;
      }
      tv.tv_sec = when.tv_sec - now.tv_sec;
      tv.tv_usec = when.tv_usec - now.tv_usec;

      /* --- Sort out file descriptors to watch --- */

      FD_ZERO(&fds);
      FD_SET(fd, &fds);

      /* --- Wait for them --- */

      i = select(FD_SETSIZE, &fds, 0, 0, &tv);
      if (i == 0)
	die("no answer from server");
      if (i < 0)
	die("error waiting for reply: %s", strerror(errno));

      /* --- A reply should be waiting now --- */

      {
	struct sockaddr_in sin;
	int slen = sizeof(sin);
	unsigned char buff[256];
	int answer;

	/* --- Read the reply data --- */

	if (recvfrom(fd, (char *)buff, sizeof(buff), 0,
		     (struct sockaddr *)&sin, &slen) < 0)
	  die("error reading server's reply: %s", strerror(errno));

	/* --- Verify the sender --- */

	if (sin.sin_addr.s_addr != ssin.sin_addr.s_addr ||
	    sin.sin_port != ssin.sin_port)
	  continue;
    
	/* --- Unpack and verify the response --- */

	answer = crypt_unpackReply(buff, sk, t, pid);
	if (answer < 0)
	  continue;
	return (answer);
      }
    }
  }

  die("internal error: can't get here in check_client");
  return (0);
}

/* --- @check@ --- *
 *
 * Arguments:	@request *rq@ = pointer to request buffer
 *
 * Returns:	Nonzero if OK, zero if forbidden
 *
 * Use:		Checks to see if the request is acceptable.
 */

int check(request *rq)
{
  FILE *fp;

  /* --- Check if we need to talk to a server --- */

  if ((fp = fopen(file_SERVER, "r")) != 0) {
    char buff[64];
    int port;
    int ch;

    if (fscanf(fp, " %63[^: \t] ", buff) < 1)
      die("error in `%s'", file_SERVER);
    ch = getc(fp);
    if (ch == ':') {
      char b[64];
      struct servent *se;

      fscanf(fp, "%s", b);
      if ((se = getservbyname(b, 0)) != 0)
	port = ntohs(se->s_port);
      else if ((port = atoi(b)) == 0)
	die("error in `%s'", file_SERVER);
    } else {
      struct servent *se;

      if ((se = getservbyname(quis(), "udp")) == 0)
	die("no idea which port to use");
      port = ntohs(se->s_port);
    }
    fclose(fp);
    return (check__client(rq, buff, port));
  }

  /* --- Read the configuration in and go --- */

  if ((fp = fopen(file_RULES, "r")) == 0) {
    die("couldn't read configuration file `%s': %s",
	file_RULES, strerror(errno));
  }

  name_init();
  rule_init();
  lexer_scan(fp);
  yyparse();

  return (rule_check(rq));
}

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