root/trunk/src/renetcol.c @ 32

/*
 * File: renetcol.c
 * 
 * Authors: ANDREU Francois-Xavier 
 *
 * Copyright (C) 2005 2006 2007 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"

struct MyPtrs myPtrs; /* defined in dataflowset.h */

struct SHMForAgg *shmForAgg;

struct IPFLowCache tabIP[MAX_IP_FLOW];
struct MPLSFlowCache tabMPLS[MAX_MPLS_FLOW];
unsigned long ipNb = 0;                     /* counter of IP flows number */
unsigned long mplsNb = 0;                   /* counter of MPLS flow number */

unsigned short currentIPOutputFile = 0;    /* index on the current IP file */
unsigned short currentMPLSOutputFile = 0;  /* index on the current MPLS file */
char outputName[256];
char cof_str[20];                          /* current ouput file name */
FILE *fIP;                                 /* pointer on the IP output file */
FILE *fMPLS;                              /* pointer on the MPLS output file */

char *rulesFileName;                    /* file name of the rules (like acl) */
char *configFileName;                   /* file name where routers list is */
char *prefixV4FileName;                 /* IPv4 prefix list */

struct sigaction myAction; /* handler for renetcolSender communication */
sigjmp_buf contextSigalrm; /* '' */
volatile sig_atomic_t sigusr1Up = 0;
/* struct sigaction myAction;  for timer not used in this version */

unsigned short currentIntervalle = 0;        /* based on 5 min intervalles */ 

unsigned short offsetV9 = 0;                 /* index in a neflow v9 packet */

unsigned char buffer1;
unsigned char buffer2[2];
unsigned char buffer4[4];
unsigned char buffer6[6];

short currentFlowsetNumber;
short currentFlowsetId;
TplFlowSetPtr curTplFlSetPtr; /* current template flowset pointer */
TplOptionPtr curTplOptionPtr;
RouterPtr routersListPtr; 

unsigned long sortedRouterList[ROUTER_INDEX_MAX];
unsigned long indexedRouterList[ROUTER_INDEX_MAX];
int routerNb = 0;                                  /* routers number */
/* unsigned short v4PrefixNb = 0;                    IPv4 prefix number */ 
/* struct PrefixV4 prefixV4Tab[2][MAX_IPV4_PREFIX];  IPv4 prefix structure */


key_t myKey = 0; /* FIXME to delete in futur */
int myQueue = 0; /* FIXME to delete in futur */

/* Next structure used as cache in rules reading */
RuleDefPtr rulesAddress[FIELD_TYPE_NUMBER+1][MAX_RULES_PER_FIELD]; 

int reInitConf = 0;

static time_t lastRock;
static struct tm *tmPtr;

extern int errno;
static int inputSock;
static int sockNamelg;
static int inputSock2;
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 name2;
static struct sockaddr_in fromName;

/* 
 * Main
 * ----
 */
int 
main (int argc, char *argv[])
{
  RulesPtr tmp = NULL;
  int shmid;
  key_t key;
  
  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);
  }

#ifdef CRIHAN
  fprintf(stderr, "renetcol compilation with CRIHAN feature enable\n");
#endif
#ifdef IPV4AGG
  fprintf(stderr, "renetcol compilation and execution with IPv4 Aggregation feature enable\n");
#endif
  
  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();
  routerNb = getRegisteredRouters(configFileName, &sortedRouterList[0], 
                                  &indexedRouterList[0]);
  key = 8765;
  if ((shmid = shmget(key, SHMSIZE, IPC_CREAT | 0666)) < 0) {
    perror("shmget");
    exit(1);
  }
  if ((shmForAgg = (struct SHMForAgg *)shmat(shmid, (void *)0, 0)) == (void *) -1) {
    perror("shmat");
    exit(1);
  }

  if ( (shmForAgg->v4PrefixNb = getPrefixV4(prefixV4FileName, &(shmForAgg->prefixV4Tab[0][0]))) < 1){
    fprintf(stderr, "renetcol: Error \n");
    exit(1);
  }
  if ( (shmForAgg->v4PrefixNb = getPrefixV4(prefixV4FileName, &(shmForAgg->prefixV4Tab[1][0]))) < 1){
    fprintf(stderr, "renetcol:  Error \n");
    exit(1);
  }

  shmForAgg->currentTable = 0;
  shmForAgg->secondTable = 1;

  myPtrs.rulesListPtr = NULL;
  myPtrs.rulesListPtr = getLightRules(myPtrs.rulesListPtr, rulesFileName);
  tmp = myPtrs.rulesListPtr;
  for ( ; tmp->next; tmp=tmp->next) {
    if (tmp->type != 2) {
      myPtrs.rulesListPtr = delRule(tmp, myPtrs.rulesListPtr);
    }
  }
/*   printRule(rulesListPtr); */
/*   exit(1); */

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

  /* handler, SIGUSR1 from renetcolSender */
  myAction.sa_handler = sigusr1Mgmt;
  myAction.sa_flags = SA_RESTART;
  sigemptyset (&(myAction.sa_mask));
  sigaddset (&(myAction.sa_mask), SIGALRM);
  sigaction (SIGUSR1, &myAction, NULL);

  /* Pointer on rules Table */
  setCache(myPtrs.rulesListPtr);
  myPtrs.rulesAddressPtr = (RuleDefPtr *)rulesAddress;

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

  /* INIT THE CURRENTS VARIABLES*/
  myPtrs.currentRouterPtr = routersListPtr;
  myPtrs.currentHeaderV9Ptr = (NetFlowV9HeaderPtr)
    malloc(sizeof(struct NetFlowV9Header));
  myPtrs.offsetV9Ptr = &offsetV9;
  myPtrs.currentFlowsetIdPtr = &currentFlowsetId;
  myPtrs.pcktPtr = (DatagramPtr) malloc(sizeof(struct Datagram));
  myPtrs.currentFlowsetNumberPtr = &currentFlowsetNumber;
  myPtrs.ipNbPtr =  &ipNb;
  myPtrs.mplsNbPtr =  &mplsNb;
  myPtrs.routersID = &indexedRouterList;
  myPtrs.currentV4Tab = shmForAgg->prefixV4Tab[shmForAgg->currentTable];
  myPtrs.secondV4Tab = shmForAgg->prefixV4Tab[shmForAgg->secondTable];  
 
  if (myPtrs.pcktPtr==NULL) {
    fprintf(stderr, "ERROR in struct Datagram allocation\n");
    exit(1);
  } else {
    myPtrs.pcktPtr->ipH = (IpHeaderPtr) malloc(sizeof(struct IpHeader));
    myPtrs.pcktPtr->udp_header = (UdpHeaderPtr) malloc(sizeof(struct UdpHeader));
  }

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

  /* INIT INPUT STREAM*/
  initStream();

  socketLoop(); /* all work on datagram is made here */

  closelog();

  fprintf(stderr, "END\n");

  return (0);
}

/*
 * send his PID to another program via IPC message queue
 *
 * @param queueID the IPC queue ident
 *
 */
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);
}

/*
 * Send the "read rules list" message to another program
 *
 * @param queueID the IPC queue ident
 *
 */
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;
}

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

/*
 * init cache table
 */
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;
    }
  }
}

/*
 * setCache()
 */
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;
}

/*
 * socketLoop()
 */
int 
socketLoop()
{
  short shift;
  short version = 0;
  int regRouter = 0;
  time_t now = time((time_t *)NULL);
  int iIP, iMPLS, i;
  int loopNb = 0;
  int gardeFou = 0;
  time_t lastIPOutput, lastMPLSOutput;
  time_t receptionTime;

  now = time((time_t *)NULL);
  tmPtr = localtime(&now);
  currentIntervalle = tmPtr->tm_min;
  lastMPLSOutput = now;
  lastIPOutput = now;
  do {
#ifdef DEBUG    
    fprintf (stderr, "[");
#endif
    if ( ((tmPtr->tm_min)%STEP == 0) && (currentIntervalle != tmPtr->tm_min)){
      currentIntervalle = tmPtr->tm_min;
      if (shmForAgg->currentTable == 0) {
        shmForAgg->currentTable = 1;
        shmForAgg->secondTable = 0;
      }else{
        shmForAgg->currentTable = 0;
        shmForAgg->secondTable = 1;
      }
      shmForAgg->readed = 1;
    }
    if (sigusr1Up == 1){
      sigusr1Up = 0;
      initRule();
    } 
    socketReading();
    getIpHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer);
    regRouter = checkIpHeader(myPtrs.pcktPtr, &sortedRouterList[0], routerNb);
    getUdpHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer);
    if ( checkUdpHeader(myPtrs.pcktPtr, regRouter, receptPort) == 1 ){
      continue;
    }
    
    switch( version = 
            getNetFlowHeader(myPtrs.pcktPtr, myPtrs.ptr_buffer, 
                             myPtrs.currentHeaderV9Ptr, myPtrs.offsetV9Ptr)){
    case 9:
      if ((myPtrs.currentRouterPtr=notExistRouter(routersListPtr, 
                                                  myPtrs.pcktPtr->ipH->srcAdd))==NULL) {
        routersListPtr = addRouter(routersListPtr, 
                                   myPtrs.pcktPtr->ipH->srcAdd, 
                                   (unsigned long) 0,
                                   shmForAgg->prefixV4Tab[shmForAgg->currentTable],
                                   (size_t) shmForAgg->v4PrefixNb,
                                   &myPtrs
                                   );
        myPtrs.currentRouterPtr = routersListPtr;
      }
      currentFlowsetNumber = 0;
      shift = 0;
      gardeFou=0;
      while ((currentFlowsetNumber < myPtrs.currentHeaderV9Ptr->count)) {
        gardeFou++;
        curTplFlSetPtr = NULL;
        currentFlowsetId=getFlowsetId(currentFlowsetNumber, 
                                      myPtrs.offsetV9Ptr, myPtrs.ptr_buffer);
        if ( currentFlowsetId == 0 ) {
          if ( (shift = checkTemplateFlowSet(myPtrs.currentRouterPtr, myPtrs.offsetV9Ptr, 
                                             myPtrs.ptr_buffer, myPtrs.currentHeaderV9Ptr,
                                             curTplFlSetPtr,
                                             myPtrs.currentFlowsetNumberPtr,
                                             myQueue)) < 0 ) {
#ifdef DEBUG
            fprintf (stderr, "w>\n");
#endif
            currentFlowsetNumber = myPtrs.currentHeaderV9Ptr->count + 1;
          };
          writeAllTplFlSet();
        } else if (currentFlowsetId == 1) {
          if ( (shift = checkTemplateOption(myPtrs.currentRouterPtr, myPtrs.offsetV9Ptr, 
                                      myPtrs.ptr_buffer, myPtrs.currentHeaderV9Ptr,
                                      curTplOptionPtr,
                                            myPtrs.currentFlowsetNumberPtr) ) < 0 ) {
#ifdef DEBUG
            fprintf (stderr, "wo>\n");
#endif 
            currentFlowsetNumber = myPtrs.currentHeaderV9Ptr->count + 1;
          }
        } else if (currentFlowsetId > 255) {
          if ( (shift = checkDataFlowSet(shift,
                                         &myPtrs,
                                         myQueue, 
                                         shmForAgg->prefixV4Tab[shmForAgg->currentTable],
                                         (size_t) shmForAgg->v4PrefixNb
                                         ) ) < 0 ) {
#ifdef DEBUG    
            fprintf (stderr, "wd>\n");
#endif
            currentFlowsetNumber = myPtrs.currentHeaderV9Ptr->count + 1;
          }
        } else {
#ifdef DEBUG    
          fprintf (stderr, "1<<255\n");
#endif
          currentFlowsetNumber = myPtrs.currentHeaderV9Ptr->count + 1;
        }
        if ( gardeFou > 200) { exit(-1); }
      } /* end while flowset exist */
      break;
    default:
      syslog(LOG_INFO, 
             "NetFlow exp. version unknown: %hu, from router: %lu.%lu.%lu.%lu",
             (unsigned short) version,
             (myPtrs.pcktPtr->ipH->srcAdd>>24),
             (myPtrs.pcktPtr->ipH->srcAdd<<8>>24),
             (myPtrs.pcktPtr->ipH->srcAdd<<16>>24),
             (myPtrs.pcktPtr->ipH->srcAdd<<24>>24)); 
      break;
    }
    if (loopNb  > 1000 ){
      /* FIXME perhaps call this function via the compilation options */
      writeAllTplFlSet();
#ifdef DEBUG    
      fprintf(stderr, "W"); 
#endif
      loopNb = 0;
    }
    loopNb++;

#ifdef CRIHAN
    now = time((time_t *)NULL);
    receptionTime = now;
    if ( (ipNb > (MAX_IP_FLOW - 50)) || 
         ( (now-lastIPOutput) > IP_TIME_THRESHOLD) ) {
      outputName[0] = '\0';
      sprintf(cof_str, "%d", currentIPOutputFile);
      strcat(outputName, OUTPUT_IP);
      strcat(outputName, cof_str);
      strcat(outputName, EXTENSION);
      if (fopen(outputName, "x") == NULL) {
        currentIPOutputFile = (currentIPOutputFile + 1)%MAX_IP_OUTPUT_FILES;
        outputName[0] = '\0';
        sprintf(cof_str, "%d", currentIPOutputFile);
        strcat(outputName, OUTPUT_IP);
        strcat(outputName, cof_str);
        strcat(outputName, EXTENSION);
      } 
      if ((fIP = fopen(outputName, "w")) == NULL) {
        syslog(LOG_ERR,"Error in OUTPUT_IP opening : %s", strerror(errno));
      } else {
        for ( iIP = 0; iIP < ipNb; iIP++){
          if ( tabIP[iIP].ipProt == 0 ) {
            fprintf(fIP, "%lu;%lu;%hu;%hu;%lu.%lu.%lu.%lu;%lu.%lu.%lu.%lu;%d;%hu;%hu;%d;%d;%lu.%lu.%lu.%lu;%lu;%d\n",
                    tabIP[iIP].bytes, tabIP[iIP].pkts,
                    tabIP[iIP].inSnmp,  tabIP[iIP].outSnmp,
                    tabIP[iIP].v4AdS>>24, tabIP[iIP].v4AdS<<8>>24,
                    tabIP[iIP].v4AdS<<16>>24, tabIP[iIP].v4AdS<<24>>24,
                    tabIP[iIP].v4AdD>>24, tabIP[iIP].v4AdD<<8>>24,
                    tabIP[iIP].v4AdD<<16>>24, tabIP[iIP].v4AdD<<24>>24,
                    tabIP[iIP].tProt, tabIP[iIP].sPort,
                    tabIP[iIP].dPort, tabIP[iIP].maskD,
                    tabIP[iIP].maskS, tabIP[iIP].routerAd>>24,
                    tabIP[iIP].routerAd<<8>>24, tabIP[iIP].routerAd<<16>>24,
                    tabIP[iIP].routerAd<<24>>24, tabIP[iIP].liveTime,
                    receptionTime
                    );
          }
        }
        fclose(fIP);
      }
      ipNb = 0;
      lastIPOutput = now;
    }
    now = time((time_t *)NULL);
    if ( mplsNb > (MAX_MPLS_FLOW - 50) || 
         ( (now-lastMPLSOutput) > MPLS_TIME_THRESHOLD) ) {
      outputName[0] = '\0';
      sprintf(cof_str, "%d", currentMPLSOutputFile);
      strcat(outputName, OUTPUT_MPLS);
      strcat(outputName, cof_str);
      strcat(outputName, EXTENSION);
      if (fopen(outputName, "x") == NULL) {
        currentMPLSOutputFile = (currentMPLSOutputFile + 1)%MAX_MPLS_OUTPUT_FILES;
        outputName[0] = '\0';
        sprintf(cof_str, "%d", currentMPLSOutputFile);
        strcat(outputName, OUTPUT_MPLS);
        strcat(outputName, cof_str);
        strcat(outputName, EXTENSION);
      }
      if ((fMPLS = fopen(outputName, "w")) == NULL) {
        syslog(LOG_ERR,"Error in OUTPUT_MPLS opening : %s", strerror(errno));
      } else {
        for ( iMPLS = 0; iMPLS < mplsNb; iMPLS++){
          if ( tabMPLS[iMPLS].ipProt == 0 ) {
            fprintf(fMPLS, "%lu.%lu.%lu.%lu;%hu;%lu.%lu.%lu.%lu;%lu.%lu.%lu.%lu\n",
                    tabMPLS[iMPLS].routerAd>>24,tabMPLS[iMPLS].routerAd<<8>>24,
                    tabMPLS[iMPLS].routerAd<<16>>24,
                    tabMPLS[iMPLS].routerAd<<24>>24,
                    tabMPLS[iMPLS].mplsLabel1,tabMPLS[iMPLS].v4AdS>>24,
                    tabMPLS[iMPLS].v4AdS<<8>>24,tabMPLS[iMPLS].v4AdS<<16>>24,
                    tabMPLS[iMPLS].v4AdS<<24>>24,tabMPLS[iMPLS].v4AdD>>24,
                    tabMPLS[iMPLS].v4AdD<<8>>24,tabMPLS[iMPLS].v4AdD<<16>>24,
                    tabMPLS[iMPLS].v4AdD<<24>>24 
                    );
          }
        }
        fclose(fMPLS);
      }
      mplsNb = 0;
      lastMPLSOutput = now;
    }
#endif /* CRIHAN */
    now = time((time_t *)NULL);
    tmPtr = localtime(&now);
#ifdef DEBUG    
    fprintf (stderr, "]\n");
#endif
  } 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);
    }
  /* Here socket DGRAM creation, only to not have a unreachable service */
  /* message in return */
  inputSock2 = socket(AF_INET, SOCK_DGRAM, 0); 
  if (inputSock2 < 0)
    {
      syslog(LOG_ERR,"socket : %s", strerror(errno));
      exit(1);
    }
  memset((void*)&name, 0, sizeof(name));
  name2.sin_family = AF_INET;
  name2.sin_addr.s_addr = htonl(INADDR_ANY);
  if (name2.sin_addr.s_addr == INADDR_NONE){
    syslog(LOG_ERR, " INADDR_NONE ");
    exit(1);
  }
  name2.sin_port = htons(receptPort);
  if (bind(inputSock2,(struct sockaddr *)(&name2), sizeof(name2)) < 0) 
    {
      syslog(LOG_ERR, "bind : %s", strerror(errno));
      exit(1);
    }                                                           
  sockNamelg = sizeof(name2);
  if (getsockname(inputSock2, (struct sockaddr *) (&name2), 
                  (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, myPtrs.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); /* FIXME : why this function ??? */
}

/* 
 * showAllTplFlSet
 *
 * to use only in debug mode
 */
void 
showAllTplFlSet()
{
  RouterPtr tmp = routersListPtr;
  TplFlowSetPtr tmpFS;
  TplOptionPtr tmpOP;
  fprintf(stderr,"\n*********************************************\n* All template definitions: (field, size) : *\n*********************************************\n");
  for (; tmp; tmp=tmp->next) {
    fprintf(stderr,"----------------------\nrouter %lu.%lu.%lu.%lu : \n----------------------\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,"TId %hu (sourceId: %lu):\n", 
              tmpFS->templateFlowSetId,
              tmpFS->sourceId);
      printFieldSet(stderr, tmpFS->fieldSet);
      fprintf(stderr,"\n");
    }
    if ((tmpOP = tmp->tplOptList) != NULL){
      for (; tmpOP; tmpOP=tmpOP->next) {
        fprintf(stderr,"OpTId %hu (sourceId: %lu) >\n", 
                tmpOP->templateOptionId,
                tmpOP->sourceId);
        printFieldSet(stderr, tmpOP->fieldSet);
        fprintf(stderr,"\n");
      }
      fprintf(stderr,"\n");
    }
  }
}


/* 
 * writeAllTplFlSet
 *
 */
void 
writeAllTplFlSet()
{

  RouterPtr tmp = routersListPtr;
  TplFlowSetPtr tmpFS;
  TplOptionPtr tmpOP;
  FILE *TPLFILE;
  if (!(TPLFILE = fopen("/tmp/TemplateDef.txt", "w"))) {
    syslog (LOG_ERR, "error during %s opening", "/tmp/TemplateDef.txt");
  }
  fprintf(TPLFILE,"\n*********************************************\n* All template definitions: (field, size) : *\n*********************************************\n");
  for (; tmp; tmp=tmp->next) {
    fprintf(TPLFILE,"----------------------\nrouter %lu.%lu.%lu.%lu : \n----------------------\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(TPLFILE,"TId %hu (sourceId: %lu):\n", 
              tmpFS->templateFlowSetId,
              tmpFS->sourceId);
      printFieldSet(TPLFILE, tmpFS->fieldSet);
      fprintf(TPLFILE,"\n");
    }
    if ((tmpOP = tmp->tplOptList) != NULL){
      for (; tmpOP; tmpOP=tmpOP->next) {
        fprintf(TPLFILE,"OpTId %hu (sourceId: %lu) last %d brackets are Scope >\n lg: %hu, opScopeLg: %hu, opLg: %hu\n", 
                tmpOP->templateOptionId,
                tmpOP->sourceId,
                tmpOP->optionScopeLg/4,
                tmpOP->length,
                tmpOP->optionScopeLg,
                tmpOP->optionLg);
        printFieldSet(TPLFILE, tmpOP->fieldSet);
        fprintf(TPLFILE,"\n");
      }
      fprintf(TPLFILE,"\n");
    }
  }
  fclose(TPLFILE);
}