/*
 *  Name: find_gateways(char *rulesC, char *gateway)
 *
 * Description:
 *    This routine breaks up the rules into individual objects, and sends
 *    each install object to process_install() to be parsed into proper
 *    install fields.
 *
 *  *rulesC - file to find rules in
 *  *gateway - gateway string we are searching for
 */

#include "rules.h"
char *get_line(int *i, char *buf);

void find_gateways(char *rulesC, char *gateway)
{

  /* Array to hold a line */
  char buf[LNSIZE];

  /* counter for main loop and object or services */
  int stack=0;

  /* contains one full object for parsing -- 4096 should be plenty
   * big enough, as the average object is 500 bytes
   */
  char object[BUFSIZE];

  /* output filename */
  char ofname[LNSIZE];

  /* loop counter */
  int i;

  /* return value from process_install() function */
  int install=0;

  int rulenum=0;

  /* defines whether we have found at least a single rule after reading
   * the entire file  */
  int atleast1=0;

  /* tmp pointer used to find rulename/filename in a string */
  char *ruleptr;

  /* file pointer to objects.C file */
  FILE *fp;
  
  /* output file descriptor */
  FILE *ofp;

  sprintf(ofname,"/tmp/%s.%d",gateway,getpid());

  /* Open objects.C file for parsing */
  if((fp = fopen(rulesC,"r+")) == NULL) {
    fprintf(stderr,"find_gateways: cannot open %s\n",rulesC);
    exit(1);
  }

  /* Open a temporary file for writing our output */
  if((ofp = fopen(ofname,"w+")) == NULL) {
    fprintf(stderr,"find_gateways(): cannot open output file%s\n",ofname);
    exit(1);
  }

  object[0] = '\0';
  i=0;
  /* main loop */
  while((stack >= 0) && (fp != NULL)) {
    fgets(buf,LNSIZE,fp);
    for(i=0;i<strlen(buf);i++) {
      if((buf[i] != '\0') && (buf[i] == '('))
	stack++;
      if((buf[i] != '\0') && (buf[i] == ')'))
	stack--;
    }
    /* hopefully now buf will contain ':rulename (gateway)' */
    if(strstr(buf,":rulename (")) {
      ruleptr = strchr(buf,'(');
      sprintf(&buf[strlen(ruleptr)]," (%s)\n",gateway);
    }
    /* And hopefully now buf will contain ':filename (gateway) */
    if(strstr(buf,":filename (")) {
      ruleptr = strchr(buf,'(');
      sprintf(&buf[strlen(ruleptr)],"%s.W)\n",gateway);
    }
    strcat(object,buf);
    /* stack is 1 when we have a full rule */
    if(stack == 1) {
      install = process_install(object,gateway);
      /*  -1   - Not a valid rule
       *   0   - Rule does not contain gateway as a match
       *   1   - Found a 'gateway' as a match
       *   2   - Found a valid hostname as a match */
      if((install == 2) || (install == 1)) {
	atleast1 = 1;
	/* we have a whole valid object, it is safe to print it */
	rulenum++;
	fprintf(ofp,"%s",object);
      }
      /* This else covers the case where the criteria we were looking
	 for was not found, but it also was not a negative match.  This
	 may be either beginning or ending paren from an object, or the code
	 at the end of the file */
      if(install == -1) {
	/* need to edit the name to reflect the output file */
	fprintf(ofp,"%s",buf);
      }
      /* Need to delete previous buffer for next strcat() */
      object[0] = '\0';
    }
    /* represents end of processing, which is typically end of file.
     * can't forget to write the last buffer to the file.
     */
    if(stack == -1) {
      fprintf(ofp,"%s",buf);
    }
  }

  if(atleast1 == 1) {
    printf("Splitting rules for: %s\n",gateway);
    printf("Storing rules in: %s\n",ofname);
    printf("Done..\n");
  }

  if(atleast1 != 1) {
    fprintf(stderr,"Sorry, no match found for %s\n",gateway);
    fclose(ofp);
    unlink(ofname);
  }
  /* close our files, and delete our tmp file */
  fclose(ofp);
  fclose(fp);
}

/*
 * Name: process_install(char object[], char gateway[])
 *
 * Description:
 *   object - contains a full rule from objects.C
 *   gateway - contains the name of the gateway host we are
 *    searching for, provided on the command-line with -g
 *
 * Currently we are searching for the gateway in two ways:
 *  - ':type (gateway)' pattern
 *  - ':install
 *        : hostname'
 * This seems to catch all cases currently.
 *
 * Returns:
 *  -1   - Not a valid rule
 *   0   - Rule does not contain gateway as a match
 *   1   - Found a 'gateway' as a match
 *   2   - Found a valid hostname as a match
 */
int process_install(char object[], char gateway[])
{

  /* loop counters */
  int i=0;
  int j=0;

  char *line,install[BUFSIZE],obj_backup[BUFSIZE];

  char buf[LNSIZE];

  /* indicates we have a full rule to work with */
  int found_install=0;

  /* simple stack pointer */
  int stack=0;

  /* marks end of install() section of rule */
  char *end_of_install;

  /* simple flag to test for finding gateway or host */
  int atleastone=0;

  /* Start by finding the ':install (' area we are interested in */
  i=0;
  while(i < strlen(object)) {
    line = get_line(&i,object);
    if(strstr(line,":install (")) {
      found_install=1;
      break;
    }
  }

  /* This rule had no 'install' argument.  Perhaps it just wasn't a rule.
   * This somewhat coincides with what happens on the return from 
   * process_install()
   */
  if(found_install == 0) {
    return -1;
  }

  /* strncpy doesn't write the NULL!!!!!! */
  strncpy(obj_backup,object,i);
  obj_backup[i] = '\0';

  /* Find end of install() section of rule */
  j=0;
  stack=1;
  while(i < strlen(object)) {
    if((object[i] != '\0') && (object[i] == '('))
      stack++;
    if((object[i] != '\0') && (object[i] == ')'))
      stack--;
    if(stack == 0) {
      install[j] = '\0';
      break;
    }
    install[j] = object[i];
    i++;  j++;
    install[j] = '\0';
  }

  /* mark the end of install, so we can reference it later.
   * Use -2 to indicate two tabs that get chewed up in stack trace */
  end_of_install = &object[i-2];
  i=0;

  /* we have now seperated install into a seperate buffer, and can parse
   * that until we reach the end. */
  while(i < strlen(install)) {
    line = get_line(&i,install);
    /* look for gateway case */
    if(strstr(line,": (Gateways")) {
      atleastone = 1;
      stack=1;
      j=0;
      /* copy that line to our buffer of valid lines */
      sprintf(&obj_backup[strlen(obj_backup)],"%s\n",line);
      line = get_line(&i,install);
      if(line == NULL) {
	fprintf(stderr,"get_line() returned NULL.  This shouldn't happen!\n");
	return -1;
      }
      /* Gateways contains multiple lines. Use our stack counter to
       * continue until the end, writing the data to our buffer
       * on each pass */
      while(stack > 0) {
	for(j=0;j<strlen(line);j++) {
	  if((line[j] != '\0') && (line[j] == '('))
	    stack++;
	  if((line[j] != '\0') && (line[j] == ')'))
	    stack--;
	}
	sprintf(&obj_backup[strlen(obj_backup)],"%s\n",line);
	line = get_line(&i,install);
	if(line == NULL) {
	  fprintf(stderr,"get_line() returned NULL.  This shouldn't happen!\n");
	  return -1;
	}
      }
    }
    /* check for single hostnames as install host */
    sprintf(buf,": %s",gateway);
    if(strstr(line,buf)) {
      atleastone = 1;
      sprintf(&obj_backup[strlen(obj_backup)],"%s\n",line);
    }
  }
  /* end_of_install contains a pointer from the end of the install section
   * to the end of the end of the rule.  Write it to our buffer of valid
   * strings. */
  sprintf(&obj_backup[strlen(obj_backup)],"%s",end_of_install);
  sprintf(object,"%s",obj_backup);
  /* if at least a Gateway or host was found, return true */
  if(atleastone == 1)
    return 1;
  /* neither a valid gateway or valid host was found.  Don't write this
   * rule to our output file */
  return 0;

}
/*
 * Name: get_line
 *
 * Description:
 *   This function accepts an index, and a buffer, and returns
 *   a pointer to one complete line.
 */
char *get_line(int *i, char *buf)
{

  char *line;
  int j;
  line = (char *)malloc(LNSIZE * sizeof(char));
  j=0;
  line[0] = '\0';
  while((buf[(*i)] != '\0') && (buf[(*i)] != '\n')) {
    line[j] = buf[(*i)];
    (*i)++;
    j++;
    line[j] = '\0';
  }
  (*i)++;
  return(line);
}