lparser.c

Linux内核监控工具。 Linux内核监控工具。 Linux内核监控工具。

/***************************************************************************
                          lparser.c  -  description
                             -------------------
    begin                : Thu Nov 15 08:08:03 EET 2001
    copyright            : (C) 2001-2002 by Petri Turunen
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include<stdio.h>

#include "lparser.h"

int server(char *FFILE);
int find_string(char *x, int m, char *y, int n);

#define REHASH(a, b, h) ((((h) - (a)*d) << 1) + (b))  //for find_string

void sigterm();
void sigpipe();

//You may want to change these
#ifdef HAVE_REGEX
 char *errors[] = {".*[fF][aA][iI][lL].*",  ".*[eE][rR][rR][oO][rR].*", ".*[rR][eE][fF][uU][sS][eE][dD].*", ".*[dD][eE][nN][yY].*", ".*[dD][eE][nN][iI][eE][dD].*", ".*[iI][lL][lL][eE][gG][aA][lL].*"};
 int nerrors=6;
 char *warnings[] = {".*[wW][aA][rR][nN][iI][nN][gG].*"};
 int nwarnings=1;
 char *infos[] = {".*new group:.*", ".*SSH_Version_Mapper\..*"};
 int ninfos=2;
#else
 char *errors[] = {"fail","Fail", "FAIL",  "error", "Error", "ERROR", "refused", "Refused", "REFUSED","deny","DENY","denied","illegal","Illegal"};
 int nerrors=14;
 char *warnings[] = {"Warning", "warning", "WARNING"};
 int nwarnings=3;
 char *infos[] = {"new group:", "SSH_Version_Mapper."};
 int ninfos=2;
#endif

char *ignore_msg[] = {"lparser","linux_mond","DEBUG"};
int nignore_msg = 3;


//global variables
unsigned char CRYPTIV[9];
char CRYPTKEY[17];
char SERVER_IP[30];
char LOCALHOSTN[21];
char SERVER_PORT[6]="8881";
char PIDDIR[20]="/var/run";
char *TIEDOSTO; //Config file name
FILE *fp;

void sigterm()
{
char error_msg2[80]="\0";

    if(fp!=NULL)
	fclose(fp);
    
    slog(2,"Received SIGTERM. Shutting down.\n");
    sprintf(error_msg2,"lparser: Received SIGTERM. Shutting down.");
    if(client(SERVER_IP, SERVER_PORT, LOCALHOSTN, "INFO", error_msg2, LOCALHOSTN, "NONE", "NONE", "INTERNAL") < 0)
        slog(2, "client.c: error while sending to server.");
    sleep(1);
    exit(0);
}

void sigpipe()
{
    slog(1,"Received SIGPIPE.");
}

void sighup()
{

 if(read_confd(TIEDOSTO)!=0)
 {
  slog(1,"lparsec.c: Error while reading config file");
 }
 slog(1,"Received SIGHUP.\n");

}

int main(int argc, char *argv[])
{
 int cc;
 char *FFIFO='\0';
 int nicenro=0,setnice=0;

 if (argv[1] == NULL)
 {
  show_menu(2);
  exit(1);
 }

 //Process the signals
 signal(SIGHUP, &sighup);
 signal(SIGPIPE, &sigpipe);
 signal(SIGTERM, &sigterm);

 while((cc = getopt(argc, argv, "n:f:hV")) != EOF)
 {
  switch(cc)
  {
   case 'n':
    nicenro = atoi(optarg);
    setnice = 1;
    break;
   case 'f':
    FFIFO=optarg;
    break;           
   case 'V':
    show_menu(1); exit(0); break;

   case 'h':
    show_menu(2); exit(0); break;
   default :
     show_menu(2); exit(0);
  }
 }

 TIEDOSTO = argv[optind];

 if(read_confd(TIEDOSTO)!=0)
 {
  printf("lparsec.c: Error while reading config file\n");
  slog(1,"lparsec.c: Error while reading config file");
  exit(1);
 }

 //Lets make us deamon
 make_deamon();

 if(setnice==1)   //Lets set the nice value
  if(nice(nicenro)!=0) //but value in here(-20 to 19) -20 is highest 19 is lowest
  {
   if(errno==EPERM)
    slog(2,"ERROR: A non-super user attempt to do a priority increase.");
   else
    slog(2,"ERROR while setting nice.");
  }


 //start parsing FIFO
 if(server(FFIFO)!=0)
 {
  slog(1,"Error while loading server");
  exit(1);
 }

 return(0);
}

int server(char *FFILE)
{
char bufer[301];
int len=0;

fp = fopen(FFILE,"r");
if(fp==NULL)
{
 slog(2,"lparser.c: Could not open FIFO file. %s",strerror(errno));
 exit(1);
}

for(;;)
{
 while(fgets(bufer,300,fp)!=NULL)
 {
  len = strlen(bufer);
  bufer[len]='\0';
  parse_entry(bufer);
 }
 sleep(1); //If fgets received EOF we sleep and start reading again.
}
fclose(fp);
return(0);
}



void *parse_entry(char *buf)
{
int n=0;
unsigned char error_msg[301]="\0";
char *back;
unsigned char *new_buf;
int len=0, ret=0;

#ifdef HAVE_REGEX
regex_t re;  //here is the "combiled" regex
int status;
char regerr[129];
#endif

len=strlen(buf);
len++;
if((new_buf=malloc(len))==NULL){
     slog(2,"lparser.c: Error Out of memory.");
     return(NULL);
}
memset(new_buf,'\0',len);
back = memcpy(new_buf,buf,len);
if(back==NULL)
{
 slog(2,"lparser.c: Error memcpy.");
 return(NULL);
}
len=0;

n=0;
while(n!=nignore_msg) //check loop begins
{
 ret = find_string(ignore_msg[n], strlen(ignore_msg[n]), buf, strlen(buf));
 if(ret >= 0)
 {
  if(new_buf!=NULL)
   free(new_buf);
  return(0);
 }
 n++;
} 
n=0;

   while(n!=nerrors) //check loop starts
   {
#ifdef HAVE_REGEX
    status = regcomp(&re, errors[n], REG_EXTENDED|REG_NOSUB);
    if(status>1)  {
     regerror(status, &re, regerr, 129);
     slog(2, "Error in regcomp: %s in %s", regerr,errors[n]);
     regfree(&re);
     return(0);
    } else {
     status = regexec(&re, new_buf, (size_t) 0, NULL, 0);
     regfree(&re);
    }
    if(status==0)
#else
    ret = find_string(errors[n], strlen(errors[n]), new_buf, strlen(new_buf));
    if(ret >= 0)
#endif    
    {
       len=3;
       new_buf+=len;
       len=0;
       while(!isalpha(*(new_buf+len)))
       {
        len++;
       }

       new_buf+=len;
       sprintf(error_msg,new_buf);
       if(client(SERVER_IP, SERVER_PORT, LOCALHOSTN, "ERROR", error_msg, LOCALHOSTN, "NONE", "NONE", "SYSLOG") < 0)
       {
        slog(2, "lparser.c: Error while sending to server.");
       }

      return(0);
     } // if back!=NULL ends
    n++;
   } //check loop ends
   n=0;

   while(n!=nwarnings) //check loop starts
   {
#ifdef HAVE_REGEX
    status = regcomp(&re, warnings[n], REG_EXTENDED|REG_NOSUB);
    if(status>1)  {
     regerror(status, &re, regerr, 129);
     slog(2, "Error in regcomp: %s in %s", regerr, warnings[n]);
     regfree(&re);
     return(0);
    } else {
     status = regexec(&re, new_buf, (size_t) 0, NULL, 0);
     regfree(&re);
    }
    if(status==0)
#else
    ret = find_string(warnings[n], strlen(warnings[n]), new_buf, strlen(new_buf));
    if(ret >= 0)
#endif

    {
       len=3;
       new_buf+=len;
       len=0;
       while(!isalpha(*(new_buf+len)))
       {
        len++;
       }

       new_buf+=len;

       sprintf(error_msg,new_buf);
	if(client(SERVER_IP, SERVER_PORT, LOCALHOSTN, "WARNING", error_msg, LOCALHOSTN, "NONE", "NONE", "SYSLOG") < 0)
        {
                 slog(2, "lparser.c: Error while sending to server.");
        }

      return(0);
     } // if back!=NULL ends
    n++;
   } //check loop ends
   n=0;

   while(n!=ninfos) //check loop starts
   {
#ifdef HAVE_REGEX
    status = regcomp(&re, infos[n], REG_EXTENDED|REG_NOSUB);
    if(status>1)  {
     regerror(status, &re, regerr, 129);
     slog(2, "Error in regcomp: %s in %s", regerr, infos[n]);
     regfree(&re);
     return(0);
    } else {
     status = regexec(&re, new_buf, (size_t) 0, NULL, 0);
     regfree(&re);
    }
    if(status==0)
#else
    ret = find_string(infos[n], strlen(infos[n]), new_buf, strlen(new_buf));
    if(ret >= 0)
#endif
    {
       len=3;
       new_buf+=len;
       len=0;
       while(!isalpha(*(new_buf+len)))
       {
        len++;
       }

       new_buf+=len;

       sprintf(error_msg,new_buf);
        if(client(SERVER_IP, SERVER_PORT, LOCALHOSTN, "INFO", error_msg, LOCALHOSTN, "NONE", "NONE", "SYSLOG") < 0)
        {
         slog(2, "lparser.c: Error while sending to server.");
        }

      return(0);
     } // if back!=NULL ends
    n++;
   } //check loop ends

if(new_buf!=NULL)
 free(new_buf);

return(NULL);
}

int find_string(char *fstring, int m, char *string, int n) {
   int d, hx, hy, i, j;

   /* Preprocessing */
   /* computes d = 2^(m-1) with
      the left-shift operator */
   for (d = i = 1; i < m; ++i)
    d = (d<<1);

   for (hy = hx = i = 0; i < m; ++i) {
    hx = ((hx<<1) + fstring[i]);
    hy = ((hy<<1) + string[i]);
   }

   /* Searching */
   j = 0;
   while (j <= n-m) {
    if (hx == hy && memcmp(fstring, string + j, m) == 0)
     return j;
    hy = REHASH(string[j], string[j + m], hy);
    ++j;
   }

 return -1;
}