root/trunk/config.c

/* ======================================================================
 * Copyright (c) 2000 Theo Schlossnagle
 * All rights reserved.
 * The following code was written by Theo Schlossnagle <jesus@omniti.com>
 * This code was written to facilitate clustered logging via Spread.
 * More information on Spread can be found at http://www.spread.org/
 * Please refer to the LICENSE file before using this software.
 * ======================================================================
*/

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/file.h>
#include <unistd.h>

#include "config.h"
#include "skiplist.h"

extern FILE *yyin;
int yyparse (void);

int line_num, semantic_errors;
static Skiplist logfiles;
static Skiplist spreaddaemons;

extern int verbose;
extern int skiplocking;

int logfile_compare(void *a, void *b) {
  LogFile *ar = (LogFile *)a;
  LogFile *br = (LogFile *)b;
  return strcmp(ar->filename, br->filename);
}
int logfile_compare_key(void *a, void *b) {
  LogFile *br = (LogFile *)b;
  return strcmp(a, br->filename);
}

int spreadd_compare(void *a, void *b) {
  SpreadConfiguration *ar = (SpreadConfiguration *)a;
  SpreadConfiguration *br = (SpreadConfiguration *)b;
  int temp;
  if((temp = strcmp(ar->port, br->port))!=0)
    return temp;
  if((!ar->host) && (!br->host)) return 0;
  if(!ar->host) return -1;
  if(!br->host) return 1;
  return strcmp(ar->host, br->host);
}
int spreadd_compare_key(void *a, void *b) {
  SpreadConfiguration *br = (SpreadConfiguration *)b;
  int temp;
  if((temp = strcmp(a, br->port))!=0)
    return temp;
  if((!a) && (!br->host)) return 0;
  if(!a) return -1;
  if(!br->host) return 1;
  return strcmp(a, br->host);
}

int facility_compare(void *a, void *b) {
  LogFacility *ar = (LogFacility *)a;
  LogFacility *br = (LogFacility *)b;
  return strcmp(ar->groupname, br->groupname);
}
int facility_compare_key(void *a, void *b) {
  LogFacility *br = (LogFacility *)b;
  return strcmp(a, br->groupname);
}

int config_init(char *filename) {
  int ret;

  sl_init(&logfiles);
  sl_set_compare(&logfiles, logfile_compare, logfile_compare_key);
  sl_init(&spreaddaemons);
  sl_set_compare(&spreaddaemons, spreadd_compare, spreadd_compare_key);
  
  /*
    sl_init(&logfacilities);
    sl_set_compare(&logfacilities, facility_compare, facility_compare_key);
  */
  
  yyin = fopen(filename, "r");
  if (!yyin) {
    fprintf(stderr, "Couldn't open input file: %s\n", filename);
    return -1;
  }
  ret = yyparse();
  fclose(yyin);
  return ret;
}

char *config_get_spreaddaemon(SpreadConfiguration *sc) {
  static char buffer[1024];
  if(sc->host) {
    snprintf(buffer, 1024, "%s@%s", sc->port, sc->host);
  } else {
    strncpy(buffer, sc->port, 1024);
  }
  return buffer;
}
void config_set_spread_port(SpreadConfiguration *sc, char *newport) {
  if(sc->port) free(sc->port);
  sc->port = newport;
}
void config_set_spread_host(SpreadConfiguration *sc, char *newhost) {
  if(sc->host) free(sc->host);
  sc->host = newhost;
}
void config_add_spreadconf(SpreadConfiguration *sc) {
  sl_insert(&spreaddaemons, sc);
}
SpreadConfiguration *config_new_spread_conf(void) {
  SpreadConfiguration *newsc;
  newsc = (SpreadConfiguration *)malloc(sizeof(SpreadConfiguration));
  newsc->host=NULL;
  newsc->port=strdup("4803");
  newsc->connected = 0;
  newsc->logfacilities = (Skiplist *)malloc(sizeof(Skiplist));
  sl_init(newsc->logfacilities);
  sl_set_compare(newsc->logfacilities,
                 facility_compare, facility_compare_key);  
  return newsc;
}

LogFacility *config_new_logfacility(void) {
  LogFacility *newlf;
  newlf = malloc(sizeof(LogFacility));
  newlf->groupname=NULL;
  newlf->logfile=NULL;
  newlf->nmatches=0;
  return newlf;
}
void config_add_logfacility(SpreadConfiguration *sc, LogFacility *lf) {
  sl_insert(sc->logfacilities, lf);
}
void config_set_logfacility_group(LogFacility *lf, char *ng) {
  if(lf->groupname) free(lf->groupname);
  lf->groupname = ng;
}
void config_set_logfacility_filename(LogFacility *lf, char *nf) {
  LogFile *logf;
  logf = sl_find(&logfiles, nf, NULL);
  lf->logfile = logf;
  if(!lf->logfile) {
    logf = (LogFile *)malloc(sizeof(LogFile));
    logf->filename = nf;
    logf->fd = -1;
    sl_insert(&logfiles, logf);
    lf->logfile = logf;
  } else {
    free(nf);
  }
}
void config_add_logfacility_match(LogFacility *lf, char *nm) {
#ifdef RE_SYNTAX_EGREP
  const char *ret;
#else
  int ret;
#endif
  if(lf->nmatches>=10) {
    fprintf(stderr, "Already 10 regex's on group\n");
    return;
  }
#ifdef RE_SYNTAX_EGREP
  re_set_syntax(RE_SYNTAX_EGREP);
  if((ret = re_compile_pattern(nm, strlen(nm),
                              &lf->match_expression[lf->nmatches]))!=0) {
    fprintf(stderr, ret);
#else
 if((ret = regcomp(&lf->match_expression[lf->nmatches], nm, REG_EGREP))!=0) {
   char errbuf[120];
   regerror(ret, &lf->match_expression[lf->nmatches], errbuf, sizeof errbuf);
   fprintf(stderr, errbuf);
#endif
  } else {
    lf->nmatches++;
  }
}
int config_foreach_spreadconf(int (*func)(SpreadConfiguration *, void *),
                              void *closure) {
  int i=0;
  struct skiplistnode *iter;
  SpreadConfiguration *sc;

  iter = sl_getlist(&spreaddaemons);
  if(!iter) return i;

  sc = iter->data;
  do {
    if(func(sc, closure)==0) i++;
  } while((sc = sl_next(&spreaddaemons, &iter))!=NULL);
  return i;  
}
int config_foreach_logfacility(SpreadConfiguration *sc, 
                               int (*func)(LogFacility *, void *),
                               void *closure) {
  int i=0;
  struct skiplistnode *iter;
  LogFacility *lf;

  iter = sl_getlist(sc->logfacilities);
  if(!iter) return i;

  lf = iter->data;
  do {
    if(func(lf, closure)==0) i++;
  } while((lf = sl_next(sc->logfacilities, &iter))!=NULL);
  return i;  
}
void config_hup(void) {
  config_close();
  config_start();
}

int config_close(void) {
  struct skiplistnode *sciter, *lfiter;
  SpreadConfiguration *sc;
  LogFacility *lf;

  sciter = sl_getlist(&spreaddaemons);
  if(!sciter) return 0;
  
  sc = (SpreadConfiguration *)sciter->data;
  /* For each spread configuration: */
  do {
    lfiter = sl_getlist(sc->logfacilities);
    if(!lfiter) return 0;
    
    lf = (LogFacility *)lfiter->data;
    /* For each log facility in that spread configuration: */
    do {
      if(lf->logfile->fd>0) {
        if(!skiplocking) flock(lf->logfile->fd, LOCK_UN);
        close(lf->logfile->fd);
        lf->logfile->fd = -1;
      }
    } while((lf = sl_next(sc->logfacilities, &lfiter))!=NULL);
  } while((sc = sl_next(&spreaddaemons, &sciter))!=NULL);
  return 0;
}

int config_start(void) {
  struct skiplistnode *sciter, *lfiter;
  SpreadConfiguration *sc;
  LogFacility *lf;

  sciter = sl_getlist(&spreaddaemons);
  if(!sciter) return 0;
  
  sc = (SpreadConfiguration *)sciter->data;
  /* For each spread configuration: */
  do {
    lfiter = sl_getlist(sc->logfacilities);
    if(!lfiter) return 0;

    lf = (LogFacility *)lfiter->data;
    /* For each log facility in that spread configuration: */
    do {
      if(lf->logfile->fd<0)
        lf->logfile->fd = open(lf->logfile->filename,
#ifdef __USE_LARGEFILE64
                               O_CREAT|O_APPEND|O_WRONLY|O_LARGEFILE,
#else
                               O_CREAT|O_APPEND|O_WRONLY,
#endif
                               00644);
      if(!skiplocking) {
        if(flock(lf->logfile->fd, LOCK_NB|LOCK_EX)==-1) {
          fprintf(stderr, "Cannot lock %s, is another spreadlogd running?\n",
                  lf->logfile->filename);
          exit(1);
        }
      }
      if(verbose) {
        fprintf(stderr, "LogFacility: %s\n\tFile: %s\n\tFD: %d\n\t%d regexs\n",
                lf->groupname, lf->logfile->filename,
                lf->logfile->fd, lf->nmatches);
      }
    } while((lf = sl_next(sc->logfacilities, &lfiter))!=NULL);
  } while((sc = sl_next(&spreaddaemons, &sciter))!=NULL);
  return 0;
}

int config_get_fd(SpreadConfiguration *sc, char *group, char *message) {
  LogFacility *lf;
  int i, ret, slen;
  lf = sl_find(sc->logfacilities, group, NULL);
  if(!lf) return -1;
  if(!lf->nmatches) return lf->logfile->fd;
  slen = strlen(message);
  for(i=0; i<lf->nmatches; i++) {
#ifdef RE_SYNTAX_EGREP
    if((ret = re_search(&lf->match_expression[i],
                        message, slen, 0, slen, NULL)) >= 0)
      return lf->logfile->fd;
    else if(ret==-2 && verbose)
      fprintf(stderr, "Internal error in re_search.\n");
    else if(ret==-1 && verbose)
      fprintf(stderr, "Failed match!\n");
#else
    if(!regexec(&lf->match_expression[i], message, 0, NULL, 0))
      return lf->logfile->fd;
#endif
  }
  return -1;
}