root/trunk/src/renetcol.c @ 12

/*
 * File: renetcol.c
 * 
 * Authors: ANDREU François-Xavier 
 *
 * Copyright (C) 2005 GIP RENATER 
 */

/*  This file is part of renetcol. 
 *
 *  renetcol 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.
 *
 *  renetcol 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 renetcol; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "renetcol.h"

char *rulesFileName;
char *configFileName; 
char *prefixV4FileName; 
struct sigaction myAction;
sigjmp_buf contextSigalrm;
/* struct sigaction myAction;  for timer */ 
volatile sig_atomic_t sigusr1Up = 0;
/* V9 */
unsigned short offsetV9 = 0;
unsigned short *offsetV9Ptr = &offsetV9;
unsigned char buffer1;
unsigned char buffer2[2];
unsigned char buffer4[4];
unsigned char buffer6[6];
short currentFlowsetNumber;
short *currentFlowsetNumberPtr = &currentFlowsetNumber;
short currentFlowsetId;
short *currentFlowsetIdPtr = &currentFlowsetId;
TplFlowSetPtr curTplFlSetPtr;
TplOptionPtr curTplOptionPtr;
RouterPtr routersListPtr;
RouterPtr currentRouterPtr;
DatagramPtr pcktPtr;
unsigned long sortedRouterList[ROUTER_INDEX_MAX];
unsigned long indexedRouterList[ROUTER_INDEX_MAX];
int routerNb = 0;
struct PrefixV4 prefixV4Tab[PREFIX_V4_MAX];
RulesPtr rulesListPtr;
NetFlowV9HeaderPtr currentHeaderV9Ptr;
key_t myKey = 0;
int myQueue = 0;
RuleDefPtr rulesAddress[FIELD_TYPE_NUMBER+1][MAX_RULES_PER_FIELD];
RuleDefPtr *rulesAddressPtr;
int reInitConf = 0;
/* ENDV9 */
static unsigned long datagramNumber;
static time_t now;
static unsigned long myHost; /* FIXME to erase */
static struct tm *tmPtr;
extern int errno;
static int inputSock;
static int sockNamelg;
static int sockNameFromlg;
static int rcv;
static int sockBufSize = SOCKET_BUFFER_SIZE;            
/* static unsigned short flowNumber; */
static unsigned short receptPort = RECEPTION_PORT;
static unsigned char *ptr_buffer;
static char *receptAddress = RECEPTION_ADDRESS;
static struct sockaddr_in name;
static struct sockaddr_in fromName;

/* 
 * Main
 * ----
 */
int 
main (int argc, char *argv[])
{
  RulesPtr tmp = NULL;

  if ( argc != 4) {
    fprintf (stderr,
             "%s: Usage: %s <routers file> <prefix IPv4 file> <rules file>\n exp: %s routers.txt IPv4_prefix.txt rules.txt\n", 
             argv[0], argv[0], argv[0]);
    exit(1);
  }

  openlog(argv[0], LOG_PID, LOG_USER);

  configFileName = (char *) malloc((strlen(argv[1])+1) * sizeof(char));
  strcpy (configFileName, argv[1]);
  prefixV4FileName = (char *) malloc((strlen(argv[2])+1) * sizeof(char));
  strcpy (prefixV4FileName, argv[2]);
  rulesFileName = (char *) malloc((strlen(argv[3])+1) * sizeof(char));
  strcpy (rulesFileName, argv[3]);

  initCache();
  fprintf(stderr, "reading the routers list\n");
  routerNb = getRegisteredRouters(configFileName, &sortedRouterList[0], 
                                  &indexedRouterList[0]);
  fprintf(stderr, "reading the IPv4 prefix\n");
  if ( getPrefixV4(prefixV4FileName, &prefixV4Tab[0]) < 1){
    fprintf(stderr, "Error during prefix v4 reading\n");
    exit(1);
  }
  rulesListPtr = NULL;
  fprintf(stderr, "reading the rules\n");
  rulesListPtr = getLightRules(rulesListPtr, rulesFileName);
  tmp = rulesListPtr;
  for ( ; tmp->next; tmp=tmp->next) {
    if (tmp->type != 2) {
      rulesListPtr = delRule(tmp, rulesListPtr);
    }
  }

  fprintf(stderr, "I become a deamon, next messages via syslogd.\n");
  if (fork () != 0)
    exit (0);
  if (setsid() == -1){
    exit(4);
  }

  myAction.sa_handler = sigusr1Mgmt;
  myAction.sa_flags = SA_RESTART;
  sigemptyset (&(myAction.sa_mask));
  sigaddset (&(myAction.sa_mask), SIGALRM);
  sigaction (SIGUSR1, &myAction, NULL);

  setCache(rulesListPtr);
  rulesAddressPtr = (RuleDefPtr *)rulesAddress;

  /* init IPC messages queue */
  myKey = createKey(argv[0]);
  myQueue = createQueue(myKey);
  sendMyPid(myQueue);

  /* INIT THE CURRENTS VARIABLES*/
  currentRouterPtr = routersListPtr;
  currentHeaderV9Ptr = (NetFlowV9HeaderPtr)
    malloc(sizeof(struct NetFlowV9Header));
  pcktPtr = (DatagramPtr) malloc(sizeof(struct Datagram));
  if (pcktPtr==NULL) {
    fprintf(stderr, "ERROR in struct Datagram allocation\n");
    exit(1);
  } else {
    pcktPtr->ipH = (IpHeaderPtr) malloc(sizeof(struct IpHeader));
    pcktPtr->udp_header = (UdpHeaderPtr) malloc(sizeof(struct UdpHeader));
  }

  if (! (ptr_buffer = malloc(sockBufSize)))  
    {
      printf("ERROR during socket buffer allocation\n");
      exit(2);
    }

  /* INIT INPUT STREAM*/
  initStream();

  datagramNumber =0;

  /* TIME */
  now = time((time_t *)NULL);
  tmPtr = localtime(&now);
  socketLoop();
  closelog();
  fprintf(stderr, "END\n");
  return (0);
}

/*
 *
 */
void sendMyPid(int queueID)
{
  msgType myMsg;
  char *msgTextIndex;
  unsigned short tplMsgType = 12;
  pid_t myPID;
  
  myPID = getpid();
  msgTextIndex = mempcpy(mempcpy(myMsg.text,
                                 &tplMsgType,
                                 sizeof (unsigned short)
                                 ),
                         &myPID,
                         sizeof(pid_t)
                         );
  myMsg.type = 1;
  msgSend(queueID, myMsg);
}

/*
 *
 */
void sendReadRulesSignal(int queueID)
{
  msgType myMsg;
  char *msgTextIndex;
  unsigned short tplMsgType = 13;
  
  msgTextIndex = mempcpy(myMsg.text,
                         &tplMsgType,
                         sizeof (unsigned short)
                         );
  myMsg.type = 1;
  msgSend(queueID, myMsg);
}

/*
 *
 */
void sigusr1Mgmt(int num)
{
  sigusr1Up = 1;
}

/*
 *
 */
void 
initRule()
{
  RulesPtr tmp = NULL;
  initCache();
  tmp = rulesListPtr;
  for ( ; tmp; tmp=tmp->next) {
    rulesListPtr = delRule(tmp, rulesListPtr);
  }
  rulesListPtr = NULL;
  rulesListPtr = getLightRules(rulesListPtr, rulesFileName);
  tmp = rulesListPtr;
  for ( ; tmp; tmp=tmp->next) {
    if (tmp->type != 2) {
      rulesListPtr = delRule(tmp, rulesListPtr);
    }
  }
  tmp = NULL;
  initCache();
  setCache(rulesListPtr);
  sendReadRulesSignal(myQueue);
}

/*
 *
 */
void
initCache()
{
  int i,j;
  for (i=0; i<FIELD_TYPE_NUMBER+1; i++){
    for (j=0; j<MAX_RULES_PER_FIELD; j++){
      rulesAddress[i][j] = NULL;
    }
  }
}

/*
 *
 */
void
setCache(RulesPtr rPtr)
{
  int i=0;
  RulesPtr tmp = rPtr;
  RuleDefPtr def = NULL;

  while (tmp) {
    def = tmp->def;
    while (def) {
      i = 0;
      while (rulesAddress[def->fieldType][i] != NULL){
        i++;
      }
      rulesAddress[def->fieldType][i] = def;
      def = def->next;
    }
    tmp = tmp->next;
  }
}

/* 
 * initStream()
 */
void 
initStream()
{
  static unsigned short n0, n1, n2, n3;
  
  initSocket();
  if (sscanf(receptAddress,"%hu.%hu.%hu.%hu",&n0,&n1,&n2,&n3)==0) {
    perror("sscanf");
  }             
  buffer4[0] = (unsigned char)n3;
  buffer4[1] = (unsigned char)n2;
  buffer4[2] = (unsigned char)n1;
  buffer4[3] = (unsigned char)n0;
  myHost = *((unsigned long*)&buffer4[0]);
}

/*
 * socketLoop()
 */
int 
socketLoop()
{
  unsigned short shift;
  short version = 0;
  int regRouter = 0;
  
  do {
    if (sigusr1Up == 1){
      sigusr1Up = 0;
      initRule();
    } 
    socketReading();
    getIpHeader(pcktPtr, ptr_buffer);
    regRouter = checkIpHeader(pcktPtr, &sortedRouterList[0], routerNb);
    getUdpHeader(pcktPtr, ptr_buffer);
    checkUdpHeader(pcktPtr, regRouter, receptPort);
    
    switch( version = 
            getNetFlowHeader(pcktPtr, ptr_buffer, 
                             currentHeaderV9Ptr, offsetV9Ptr)){
    case 1:
      checkNetFlowHeader(pcktPtr);
      break;
    case 5:
/*       if ((currentRouterPtr=notExistRouter(routersListPtr,  */
/*                                         pcktPtr->ipH->srcAdd))==NULL) { */
/*      routersListPtr = addRouter(routersListPtr,  */
/*                                 pcktPtr->ipH->srcAdd,  */
/*                                 (unsigned long) 0); */
/*      currentRouterPtr = routersListPtr; */
/*       } */
/*       currentFlowsetNumber = 0; */
/*       shift = 0; */
/*       while ((currentFlowsetNumber < currentHeaderV9Ptr->count)) { */
/*      curTplFlSetPtr = NULL; */
/*      currentFlowsetId=getFlowsetId(currentFlowsetNumber,  */
/*                                    offsetV9Ptr, ptr_buffer); */
        /* remplacer par creation du template v5 si pas deja fait */
/*      shift = checkTemplateFlowSet(currentRouterPtr, offsetV9Ptr,  */
/*                                   ptr_buffer, currentHeaderV9Ptr, */
/*                                   curTplFlSetPtr, */
/*                                   currentFlowsetNumberPtr, */
/*                                   myQueue); */
        /*        showAllTplFlSet();  */
/*      shift = checkDataFlowSet(shift, currentRouterPtr, */
/*                               currentHeaderV9Ptr, offsetV9Ptr, */
/*                               ptr_buffer, currentFlowsetNumberPtr, */
/*                               currentFlowsetIdPtr, pcktPtr, */
/*                               rulesAddressPtr, rulesListPtr, */
/*                               myQueue); */
/*       } */
      break;
    case 9:
      if ((currentRouterPtr=notExistRouter(routersListPtr, 
                                           pcktPtr->ipH->srcAdd))==NULL) {
        routersListPtr = addRouter(routersListPtr, 
                                   pcktPtr->ipH->srcAdd, 
                                   (unsigned long) 0);
        currentRouterPtr = routersListPtr;
      }
      currentFlowsetNumber = 0;
      shift = 0;
      while ((currentFlowsetNumber < currentHeaderV9Ptr->count)) {
        curTplFlSetPtr = NULL;
        currentFlowsetId=getFlowsetId(currentFlowsetNumber, 
                                      offsetV9Ptr, ptr_buffer);
        if ( currentFlowsetId == 0 ) {
          shift = checkTemplateFlowSet(currentRouterPtr, offsetV9Ptr, 
                                       ptr_buffer, currentHeaderV9Ptr,
                                       curTplFlSetPtr,
                                       currentFlowsetNumberPtr,
                                       myQueue);
/*        showAllTplFlSet();  */
        } else if (currentFlowsetId == 1) {
          shift = checkTemplateOption(currentRouterPtr, offsetV9Ptr, 
                                      ptr_buffer, currentHeaderV9Ptr,
                                      curTplOptionPtr,
                                      currentFlowsetNumberPtr);
        } else {
          shift = checkDataFlowSet(shift, currentRouterPtr,
                                   currentHeaderV9Ptr, offsetV9Ptr,
                                   ptr_buffer, currentFlowsetNumberPtr,
                                   currentFlowsetIdPtr, pcktPtr,
                                   rulesAddressPtr, rulesListPtr,
                                   myQueue);
        }
      }
      break;
    default:
      syslog(LOG_INFO, 
             "NetFlow exp. version unknown: %hu, from router: %lu.%lu.%lu.%lu",
             (unsigned short) version,
             (pcktPtr->ipH->srcAdd>>24),
             (pcktPtr->ipH->srcAdd<<8>>24),
             (pcktPtr->ipH->srcAdd<<16>>24),
             (pcktPtr->ipH->srcAdd<<24>>24));
      break;
    }
  } while (1);
}

/* 
 * initSocket()
 */
short 
initSocket()
{
  inputSock = socket(AF_INET, SOCK_RAW, IPPROTO_UDP); 
  if (inputSock < 0)
    {
      syslog(LOG_ERR,"socket : %s", strerror(errno));
      exit(1);
    }
  memset((void*)&name, 0, sizeof(name));
  name.sin_family = AF_INET;
  name.sin_addr.s_addr = htonl(INADDR_ANY);
  if (name.sin_addr.s_addr == INADDR_NONE){
    syslog(LOG_ERR, " INADDR_NONE ");
    exit(1);
  }
  name.sin_port = htons(receptPort);
  if (bind(inputSock,(struct sockaddr *)(&name), sizeof(name)) < 0) 
    {
      syslog(LOG_ERR, "bind : %s", strerror(errno));
      exit(1);
    }                                                           
  sockNamelg = sizeof(name);
  if (getsockname(inputSock, (struct sockaddr *) (&name), 
                  (socklen_t *)&sockNamelg) < 0)
    {
      syslog(LOG_ERR, "getsockname: %s", strerror(errno)); 
      exit(1);
    }
  return(0);
}


/* 
 * init socket
 */
short 
socketReading()
{
  signed short sockLg;

  sockNameFromlg = sizeof(fromName);
  rcv = recvfrom(inputSock, ptr_buffer, sockBufSize, 0,
                 (struct sockaddr *)(&fromName),
                 (socklen_t *)&sockNameFromlg);   
  sockLg = rcv;
  if (sockLg < 0) {
    syslog(LOG_ERR,"recvfrom : %s", strerror(errno));
    exit(1);
  }
  if (sockLg == 0) {
    syslog(LOG_ERR,"recvfrom : %s", strerror(errno));
    exit(1);
  }
  return(0);
}
 
/* 
 * check up flow datagramme 
 */
short 
checkFlow(short flowNumber)
{
  return(0);
}

/* 
 * showAllTplFlSet
 *
 */
void 
showAllTplFlSet()
{
  RouterPtr tmp = routersListPtr;
  TplFlowSetPtr tmpFS;
  TplOptionPtr tmpOP;
  fprintf(stderr,"All template definitions: (field, size) :\n");
  for (; tmp; tmp=tmp->next) {
    fprintf(stderr,"router %lu.%lu.%lu.%lu : \n",
            (tmp->IpAddress>>24),
            (tmp->IpAddress<<8>>24),
            (tmp->IpAddress<<16>>24),
            (tmp->IpAddress<<24>>24));
    tmpFS =  tmp->tplList;
    for (; tmpFS; tmpFS=tmpFS->next) {
      fprintf(stderr,"ID %hu: ", tmpFS->templateFlowSetId);
      printFieldSet(tmpFS->fieldSet);
      fprintf(stderr,"\n");
    }
    if ((tmpOP = tmp->tplOptList) != NULL){
      fprintf(stderr,"template option: \n");
      for (; tmpOP; tmpOP=tmpOP->next) {
        fprintf(stderr,"ID %hu: ", tmpOP->templateOptionId);
        printFieldSet(tmpOP->fieldSet);
        fprintf(stderr,"\n");
      }
      fprintf(stderr,"\n");
    }
  }
}