root/trunk/src/renetcol.c @ 59

/*
 * 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 routers_mgmt.h */

struct SHMForAgg *shmForAgg;

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 */

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 */

key_t myKey = 0; 
int myQueue = 0;

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

int reInitConf = 0;

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;
  int i,j;
  int k;

#ifdef IPV4AGGIDR
  fprintf(stderr, "renetcol compilation and execution with IPv4 Aggregation feature enable based on routers ID in %s file.\n", ROUTERS_LIST);
#endif

#ifdef IPV4AGGIDSNMP
  fprintf(stderr, "renetcol compilation and execution with IPv4 Aggregation feature enable based on SNMP ID in %s file.\n", INTERFACES_TYPE_LIST);
#endif
  
  openlog(argv[0], LOG_PID, LOG_USER);

  initCache();
  /* GET the list of routers who are available to send NDE to the collector */
  if ( (routerNb = getRegisteredRouters(ROUTERS_LIST, 
                                        &sortedRouterList[0], 
                                        &indexedRouterList[0])) == -1) {
    fprintf(stderr, 
            "ERROR in getRegisteredRouters from file %s\n", 
            ROUTERS_LIST);
    exit(-1);
  }
  /* Create the list of routers */
  for (i=0; i<routerNb; i++){
    fprintf(stderr, "add router : %lu\n", sortedRouterList[i]);
    routersListPtr = addRouter(routersListPtr, sortedRouterList[i]);
  }
  
  /* Shared memory */
  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(SUBNETS_LIST, &(shmForAgg->prefixV4Tab[0][0]))) < 1){
    fprintf(stderr, "renetcol: Error in %s\n", SUBNETS_LIST);
    exit(1);
  } else {
    fprintf(stderr, "%hu prefix are readed from %s\n", 
            shmForAgg->v4PrefixNb,
            SUBNETS_LIST);
  }
  if ( (shmForAgg->v4PrefixNb = getPrefixV4(SUBNETS_LIST, &(shmForAgg->prefixV4Tab[1][0]))) < 1){
    fprintf(stderr, "renetcol: Error in %s\n", SUBNETS_LIST);
    exit(1);
  }

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

  /* get the rules */
  myPtrs.rulesListPtr = NULL;
  myPtrs.rulesListPtr = getRules(myPtrs.rulesListPtr, RULES_FILE);
  tmp = myPtrs.rulesListPtr;
  for ( ; tmp->next; tmp=tmp->next) {
    if (tmp->type != 2) {
      myPtrs.rulesListPtr = delRule(tmp, myPtrs.rulesListPtr);
    }
  }
  tmp = NULL;
#ifdef DEBUG
  printRule(rulesListPtr);
#endif

  /* the fork */
  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);

  /* Cache for fast rules access */
  setCache(myPtrs.rulesListPtr);
  myPtrs.rulesAddressPtr = (RuleDefPtr *)rulesAddress;

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

  /* get SNMP index information */
  k = getSNMPIndexList(INTERFACES_TYPE_LIST, routersListPtr);

  /* 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;
#ifdef IPV4AGGIDR
  myPtrs.routersID = &indexedRouterList;
#endif
  myPtrs.currentV4Tab = shmForAgg->prefixV4Tab[shmForAgg->currentTable];
  myPtrs.secondV4Tab = shmForAgg->prefixV4Tab[shmForAgg->secondTable];
#ifdef MATRIX
  myPtrs.matrixPOP = &(shmForAgg->matrixPOP[shmForAgg->currentTable][0][0]);
#endif

  /* INIT MATRIX TABLES */
#ifdef MATRIX
  for (i=0; i<ROUTER_INDEX_MAX; i++){
    for (j=0; j<ROUTER_INDEX_MAX; j++) {
      shmForAgg->matrixPOP[0][i][j].bytesNb = 0;
      shmForAgg->matrixPOP[0][i][j].pktsNb = 0;
      shmForAgg->matrixPOP[0][i][j].flowNb = 0;
      shmForAgg->matrixPOP[1][i][j].bytesNb = 0;
      shmForAgg->matrixPOP[1][i][j].pktsNb = 0;
      shmForAgg->matrixPOP[1][i][j].flowNb = 0;
    }
  }
#endif

  /* Checkup */
  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 = getRules(myPtrs.rulesListPtr, RULES_FILE);
  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);
#ifdef DEBUG
  printRule(myPtrs.rulesListPtr);
#endif
}

/*
 * 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;

#ifdef DEBUG
  fprintf(stderr,"Cache for Rules\n");
#endif 
  while (tmp) {
    def = tmp->def;
    while (def) {
      i = 0;
      while (rulesAddress[def->fieldType][i] != NULL){
        i++;
      }
      rulesAddress[def->fieldType][i] = def;
      def = def->next;
#ifdef DEBUG
      fprintf(stderr,"%d: %d ", def->fieldType, i);
#endif     
    }
#ifdef DEBUG
    fprintf(stderr,"\n");
#endif      
    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 loopNb = 0;
  int gardeFou = 0;
  time_t lastIPOutput, lastMPLSOutput;

  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;
#ifdef MATRIX
      myPtrs.matrixPOP = &(shmForAgg->matrixPOP[shmForAgg->currentTable][0][0]);
#endif
    }
    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) {
        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++;

    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);
}