Changeset 76 for trunk/src/template.c

Show
Ignore:
Timestamp:
10/28/08 10:06:47 (14 years ago)
Author:
andreu
Message:

error in configure.in, more checkpoints in template.c, few correction in others files

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/src/template.c

    r74 r76  
    7878  unsigned short badFieldLength = 0; 
    7979  unsigned short badFieldCount = 0; 
    80  
     80   
    8181  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    8282  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    83         flowsetId = *((unsigned short*)&buffer2); 
    84         /* checkpoint on FLOWSET ID*/ 
    85         if ( flowsetId > 1024 ) /* FIXME CONST */  
    86         { 
     83  flowsetId = *((unsigned short*)&buffer2); 
     84  /* checkpoint on FLOWSET ID*/ 
     85  if ( flowsetId > 1024 ) /* FIXME CONST */  
     86    { 
     87      fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu, %d,%d\n",  
     88              cr->IpAddress>>24,  
     89              cr->IpAddress<<8>>24,  
     90              cr->IpAddress<<16>>24,  
     91              cr->IpAddress<<24>>24,  
     92              badFieldNumber,  
     93              badFieldLength  
     94              );  
     95      fprintf (stderr, "\n cTFSPtr->templateFlowSetId >1024: %hu\n",   
     96               cTFSPtr->templateFlowSetId);  
     97      while ( ((*offV9))> (index)){ 
     98        buffer2[1]= *(buf+index); index++; 
     99        buffer2[0]= *(buf+index); index++; 
     100        tmp = *((unsigned short*)&buffer2); 
     101        fprintf (stderr, " %hu ", tmp);  
     102      } 
     103      syslog (LOG_INFO,  
     104              "in new template: flowset id too big !"); 
     105      ptpltmp = cTFSPtr; 
     106      if (ptpltmp->prev == NULL) { 
     107        cr->tplList = ptpltmp->next; 
     108        if (cr->tplList) { 
     109          cr->tplList->prev = NULL; 
     110        } 
     111      } else { 
     112        ptpltmp->prev->next = ptpltmp->next; 
     113        if (ptpltmp->next) { 
     114          ptpltmp->next->prev = ptpltmp->prev; 
     115        } 
     116      } 
     117      deleteTplFlSet(ptpltmp); 
     118      cTFSPtr = NULL; 
     119      return (-1); 
     120    } /* checkpoint end */   
     121 
     122  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     123  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     124  length = *((unsigned short*)&buffer2); 
     125  do { 
     126#ifdef DEBUG     
     127    fprintf (stderr, "{"); 
     128#endif 
     129    badFieldNumber = 0; 
     130    badFieldLength = 0; 
     131    badFieldCount = 0; 
     132    buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     133    buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     134    if ((cTFSPtr= 
     135         existTplId(cr, v9Ptr->sourceId, 
     136                    *((unsigned short*)&buffer2)))==NULL) { 
     137      cTFSPtr = newRouterTplList(); 
     138      cTFSPtr->next = cr->tplList; 
     139      if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
     140      cr->tplList = cTFSPtr; 
     141      cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
     142      cTFSPtr->sourceId = v9Ptr->sourceId; 
     143      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     144      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     145      if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
     146        badFieldCount = 1; 
     147        ptpltmp = cTFSPtr; 
     148        if (ptpltmp->prev == NULL) { 
     149          cr->tplList = ptpltmp->next; 
     150          if (cr->tplList) { 
     151            cr->tplList->prev = NULL; 
     152          } 
     153        } else { 
     154          ptpltmp->prev->next = ptpltmp->next; 
     155          if (ptpltmp->next) { 
     156            ptpltmp->next->prev = ptpltmp->prev; 
     157          } 
     158        } 
     159        deleteTplFlSet(ptpltmp); 
     160        cTFSPtr = NULL; 
     161        return (-1); 
     162      } 
     163      cpt_fields = 0; 
     164      for ( i=0; i<cTFSPtr->fieldCount; i++) { 
     165        FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
     166        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     167        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     168        if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
     169          badFieldNumber = 1; 
     170        } 
     171        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     172        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     173        if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
     174          badFieldLength = 1; 
     175        } 
     176        fldPtr->next = cTFSPtr->fieldSet; 
     177        fldPtr->prev = NULL; 
     178        if ( cTFSPtr->fieldSet ) {cTFSPtr->fieldSet->prev = fldPtr;} 
     179        cTFSPtr->fieldSet = fldPtr; 
     180        if (i==0) { 
     181          cTFSPtr->lastField = fldPtr; 
     182        } 
     183        cpt_fields++; 
     184        /* checkpoint */ 
     185        if ( (cTFSPtr->templateFlowSetId < 256 )  
     186             || (cpt_fields > 25)  
     187             || (badFieldNumber == 1)  
     188             || badFieldLength == 1  
     189             || (badFieldCount == 1)) { 
     190          fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu, %d,%d\n",  
     191                  cr->IpAddress>>24,  
     192                  cr->IpAddress<<8>>24,  
     193                  cr->IpAddress<<16>>24,  
     194                  cr->IpAddress<<24>>24,  
     195                  badFieldNumber,  
     196                  badFieldLength  
     197                  );  
     198          fprintf (stderr, "\n cTFSPtr->templateFlowSetId: %hu\n",   
     199                   cTFSPtr->templateFlowSetId);  
     200          while ( ((*offV9))> (index)){ 
     201            buffer2[1]= *(buf+index); index++; 
     202            buffer2[0]= *(buf+index); index++; 
     203            tmp = *((unsigned short*)&buffer2); 
     204            fprintf (stderr, " %hu ", tmp);  
     205          } 
     206          syslog (LOG_INFO,  
     207                  "in new template: field nb gt 89, field lg gt 16 or too many fields, bad template definition possibility"); 
     208          fprintf(stderr,   
     209                  "\n in new template function: too many fields, bug collector or wrong template def \n");   
     210          ptpltmp = cTFSPtr; 
     211          if (ptpltmp->prev == NULL) { 
     212            cr->tplList = ptpltmp->next; 
     213            if (cr->tplList) { 
     214              cr->tplList->prev = NULL; 
     215            } 
     216          } else { 
     217            ptpltmp->prev->next = ptpltmp->next; 
     218            if (ptpltmp->next) { 
     219              ptpltmp->next->prev = ptpltmp->prev; 
     220            } 
     221          } 
     222          deleteTplFlSet(ptpltmp); 
     223          cTFSPtr = NULL; 
     224          return (-1); 
     225        } /* checkpoint end */ 
     226      } 
     227    } else { /*update*/ 
     228      ptpltmp = cTFSPtr; 
     229      if (ptpltmp->prev == NULL) { 
     230        cr->tplList = ptpltmp->next; 
     231        if (cr->tplList) { 
     232          cr->tplList->prev = NULL; 
     233        } 
     234      } else { 
     235        ptpltmp->prev->next = ptpltmp->next; 
     236        if (ptpltmp->next) { 
     237          ptpltmp->next->prev = ptpltmp->prev; 
     238        } 
     239      } 
     240      deleteTplFlSet(ptpltmp); 
     241      ptpltmp = NULL; 
     242      cTFSPtr = NULL; 
     243      cTFSPtr = newRouterTplList(); 
     244      cTFSPtr->next = cr->tplList; 
     245      if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
     246      cr->tplList = cTFSPtr; 
     247      cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
     248      cTFSPtr->sourceId = v9Ptr->sourceId; 
     249      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     250      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     251      if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
     252        badFieldCount = 1; 
     253        ptpltmp = cTFSPtr; 
     254        if (ptpltmp->prev == NULL) { 
     255          cr->tplList = ptpltmp->next; 
     256          if (cr->tplList) { 
     257            cr->tplList->prev = NULL; 
     258          } 
     259        } else { 
     260          ptpltmp->prev->next = ptpltmp->next; 
     261          if (ptpltmp->next) { 
     262            ptpltmp->next->prev = ptpltmp->prev; 
     263          } 
     264        } 
     265        deleteTplFlSet(ptpltmp); 
     266        cTFSPtr = NULL; 
     267        return (-1); 
     268      } 
     269      cpt_fields = 0; 
     270      for ( i=0; i<cTFSPtr->fieldCount; i++) { 
     271        FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
     272        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     273        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     274        if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
     275          badFieldNumber = 1; 
     276        } 
     277        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     278        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     279        if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
     280          badFieldLength = 1; 
     281        } 
     282        fldPtr->next = cTFSPtr->fieldSet; 
     283        fldPtr->prev = NULL; 
     284        if ( cTFSPtr->fieldSet ) { 
     285          cTFSPtr->fieldSet->prev = fldPtr; 
     286        } 
     287        cTFSPtr->fieldSet = fldPtr; 
     288        if (i==0) { 
     289          cTFSPtr->lastField = fldPtr; 
     290        } 
     291        cpt_fields++; 
     292        if ( (cTFSPtr->templateFlowSetId < 256 )  
     293             || (cpt_fields > 25)  
     294             || (badFieldNumber == 1)  
     295             || badFieldLength == 1  
     296             || (badFieldCount == 1)) { 
     297          while ( ((*offV9))> (index)){ 
     298            buffer2[1]= *(buf+index); index++; 
     299            buffer2[0]= *(buf+index); index++; 
     300            tmp = *((unsigned short*)&buffer2); 
     301            fprintf (stderr, " %hu ", tmp);  
     302          } 
     303          syslog (LOG_INFO,  
     304                  "in update template function: too many fields, bug collector or wrong template def in template update"); 
     305          fprintf(stderr,  
     306                  "\nin update template function: too many fields, bug collector or wrong template def in template update\n");  
     307          ptpltmp = cTFSPtr; 
     308          if (ptpltmp->prev == NULL) { 
     309            cr->tplList = ptpltmp->next; 
     310            if (cr->tplList) { 
     311              cr->tplList->prev = NULL; 
     312            } 
     313          } else { 
     314            ptpltmp->prev->next = ptpltmp->next; 
     315            if (ptpltmp->next) { 
     316              ptpltmp->next->prev = ptpltmp->prev; 
     317            } 
     318          } 
     319          deleteTplFlSet(ptpltmp); 
     320          cTFSPtr = NULL; 
     321          return (-1);     
     322        } 
     323      } 
     324    } /* end if template creation or update */ 
     325    /* send to queue the template definition */ 
     326    /*     fprintf(stderr,"%hu %d\n", tplMsgType, sizeof(tplMsgType)); */ 
     327    /*     fprintf(stderr,"%lu %d\n", cr->IpAddress, sizeof(cr->IpAddress)); */ 
     328    /*     fprintf(stderr, "%lu.%lu.%lu.%lu ", */ 
     329    /*      ( cr->IpAddress)>>24, */ 
     330    /*      ( cr->IpAddress)<<8>>24, */ 
     331    /*      ( cr->IpAddress)<<16>>24, */ 
     332    /*      ( cr->IpAddress)<<24>>24); */ 
     333    /*     fprintf(stderr,"%lu %d\n", cTFSPtr->sourceId, sizeof(cTFSPtr->sourceId)); */ 
     334    /* FIXME HERE don't send an wrong def if error detected */ 
     335    msgTextIndex = mempcpy(mempcpy(mempcpy(mempcpy(mempcpy(myMsg.text,  
     336                                                           &tplMsgType,  
     337                                                           sizeof(unsigned short)  
     338                                                           ),  
     339                                                   &cr->IpAddress,  
     340                                                   sizeof(unsigned long)  
     341                                                   ),  
     342                                           &cTFSPtr->sourceId,  
     343                                           sizeof(unsigned long)  
     344                                           ),  
     345                                   &cTFSPtr->templateFlowSetId,  
     346                                   sizeof(cTFSPtr->templateFlowSetId)  
     347                                   ),  
     348                           &cTFSPtr->fieldCount,  
     349                           sizeof(cTFSPtr->fieldCount)  
     350                           );  
     351    /* add the fields list */ 
     352    tmpField = cTFSPtr->lastField; 
     353    for (; tmpField; tmpField=tmpField->prev) { 
     354      msgTextIndex = mempcpy(mempcpy(msgTextIndex, 
     355                                     &tmpField->fieldType, 
     356                                     sizeof(tmpField->fieldType)), 
     357                             &tmpField->fieldLength, 
     358                             sizeof(tmpField->fieldLength)); 
     359    } 
     360    myMsg.type = 1; 
     361    msgSend( myQueue, myMsg); 
     362    /* end send */ 
     363    (*cFNPtr)++;     
     364  } while ( (cpt) < (length-2) ); /*length-2*/ 
    87365#ifdef DEBUG 
    88                                         fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu, %d,%d\n",  
    89                                                                                                         cr->IpAddress>>24,  
    90                                                                                                         cr->IpAddress<<8>>24,  
    91                                                                                                         cr->IpAddress<<16>>24,  
    92                                                                                                         cr->IpAddress<<24>>24,  
    93                                                                                                         badFieldNumber,  
    94                                                                                                         badFieldLength  
    95                                                                  );  
    96                                         fprintf (stderr, "\n cTFSPtr->templateFlowSetId: %hu\n",   
    97                                                                                                         cTFSPtr->templateFlowSetId);  
     366  fprintf (stderr, "}"); 
    98367#endif 
    99                                         while ( ((*offV9))> (index)){ 
    100                                                                         buffer2[1]= *(buf+index); index++; 
    101                                                                         buffer2[0]= *(buf+index); index++; 
    102                                                                         tmp = *((unsigned short*)&buffer2); 
    103 #ifdef DEBUG 
    104                                                                         fprintf (stderr, " %hu ", tmp);  
    105 #endif 
    106                                         } 
    107                                         syslog (LOG_INFO,  
    108                                                                                                         "in new template: flowset id too big !"); 
    109                                         ptpltmp = cTFSPtr; 
    110                                         if (ptpltmp->prev == NULL) { 
    111                                                                         cr->tplList = ptpltmp->next; 
    112                                                                         if (cr->tplList) { 
    113                                                                                                         cr->tplList->prev = NULL; 
    114                                                                         } 
    115                                         } else { 
    116                                                                         ptpltmp->prev->next = ptpltmp->next; 
    117                                                                         if (ptpltmp->next) { 
    118                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    119                                                                         } 
    120                                         } 
    121                                         deleteTplFlSet(ptpltmp); 
    122                                         cTFSPtr = NULL; 
    123                                         return (-1); 
    124         } /* checkpoint end */   
    125  
    126         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    127         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    128         length = *((unsigned short*)&buffer2); 
    129         do { 
    130 #ifdef DEBUG     
    131                                         fprintf (stderr, "{"); 
    132 #endif 
    133                                         badFieldNumber = 0; 
    134                                         badFieldLength = 0; 
    135                                         badFieldCount = 0; 
    136                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    137                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    138                                         if ((cTFSPtr= 
    139                                                                                                                                         existTplId(cr, v9Ptr->sourceId, 
    140                                                                                                                                                                         *((unsigned short*)&buffer2)))==NULL) { 
    141                                                                         cTFSPtr = newRouterTplList(); 
    142                                                                         cTFSPtr->next = cr->tplList; 
    143                                                                         if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
    144                                                                         cr->tplList = cTFSPtr; 
    145                                                                         cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
    146                                                                         cTFSPtr->sourceId = v9Ptr->sourceId; 
    147                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    148                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    149                                                                         if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
    150                                                                                                         badFieldCount = 1; 
    151                                                                                                         ptpltmp = cTFSPtr; 
    152                                                                                                         if (ptpltmp->prev == NULL) { 
    153                                                                                                                                         cr->tplList = ptpltmp->next; 
    154                                                                                                                                         if (cr->tplList) { 
    155                                                                                                                                                                         cr->tplList->prev = NULL; 
    156                                                                                                                                         } 
    157                                                                                                         } else { 
    158                                                                                                                                         ptpltmp->prev->next = ptpltmp->next; 
    159                                                                                                                                         if (ptpltmp->next) { 
    160                                                                                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    161                                                                                                                                         } 
    162                                                                                                         } 
    163                                                                                                         deleteTplFlSet(ptpltmp); 
    164                                                                                                         cTFSPtr = NULL; 
    165                                                                                                         return (-1); 
    166                                                                         } 
    167                                                                         cpt_fields = 0; 
    168                                                                         for ( i=0; i<cTFSPtr->fieldCount; i++) { 
    169                                                                                                         FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
    170                                                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    171                                                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    172                                                                                                         if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    173                                                                                                                                         badFieldNumber = 1; 
    174                                                                                                         } 
    175                                                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    176                                                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    177                                                                                                         if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    178                                                                                                                                         badFieldLength = 1; 
    179                                                                                                         } 
    180                                                                                                         fldPtr->next = cTFSPtr->fieldSet; 
    181                                                                                                         fldPtr->prev = NULL; 
    182                                                                                                         if ( cTFSPtr->fieldSet ) {cTFSPtr->fieldSet->prev = fldPtr;} 
    183                                                                                                         cTFSPtr->fieldSet = fldPtr; 
    184                                                                                                         if (i==0) { 
    185                                                                                                                                         cTFSPtr->lastField = fldPtr; 
    186                                                                                                         } 
    187                                                                                                         cpt_fields++; 
    188                                                                                                         /* checkpoint */ 
    189                                                                                                         if ( (cTFSPtr->templateFlowSetId < 256 )  
    190                                                                                                                                                                         || (cpt_fields > 25)  
    191                                                                                                                                                                         || (badFieldNumber == 1)  
    192                                                                                                                                                                         || badFieldLength == 1  
    193                                                                                                                                                                         || (badFieldCount == 1)) { 
    194                                                                                                                                                   fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu, %d,%d\n",  
    195                                                                                                                                                           cr->IpAddress>>24,  
    196                                                                                                                                                           cr->IpAddress<<8>>24,  
    197                                                                                                                                                           cr->IpAddress<<16>>24,  
    198                                                                                                                                                           cr->IpAddress<<24>>24,  
    199                                                                                                                                                           badFieldNumber,  
    200                                                                                                                                                           badFieldLength  
    201                                                                                                                                                           );  
    202                                                                                                                                                   fprintf (stderr, "\n cTFSPtr->templateFlowSetId: %hu\n",   
    203                                                                                                                                            cTFSPtr->templateFlowSetId);  
    204                                                                                                                                         while ( ((*offV9))> (index)){ 
    205                                                                                                                                                                         buffer2[1]= *(buf+index); index++; 
    206                                                                                                                                                                         buffer2[0]= *(buf+index); index++; 
    207                                                                                                                                                                         tmp = *((unsigned short*)&buffer2); 
    208                                                                                                                                                                                     fprintf (stderr, " %hu ", tmp);  
    209                                                                                                                                         } 
    210                                                                                                                                         syslog (LOG_INFO,  
    211                                                                                                                                                                                                         "in new template: field nb gt 89, field lg gt 16 or too many fields, bad template definition possibility"); 
    212                                                                                                                                                   fprintf(stderr,   
    213                                                                                                                                                           "\n in new template function: too many fields, bug collector or wrong template def \n");   
    214                                                                                                                                         ptpltmp = cTFSPtr; 
    215                                                                                                                                         if (ptpltmp->prev == NULL) { 
    216                                                                                                                                                                         cr->tplList = ptpltmp->next; 
    217                                                                                                                                                                         if (cr->tplList) { 
    218                                                                                                                                                                                                         cr->tplList->prev = NULL; 
    219                                                                                                                                                                         } 
    220                                                                                                                                         } else { 
    221                                                                                                                                                                         ptpltmp->prev->next = ptpltmp->next; 
    222                                                                                                                                                                         if (ptpltmp->next) { 
    223                                                                                                                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    224                                                                                                                                                                         } 
    225                                                                                                                                         } 
    226                                                                                                                                         deleteTplFlSet(ptpltmp); 
    227                                                                                                                                         cTFSPtr = NULL; 
    228                                                                                                                                         return (-1); 
    229                                                                                                         } /* checkpoint end */ 
    230                                                                         } 
    231                                         } else { /*update*/ 
    232                                                                         ptpltmp = cTFSPtr; 
    233                                                                         if (ptpltmp->prev == NULL) { 
    234                                                                                                         cr->tplList = ptpltmp->next; 
    235                                                                                                         if (cr->tplList) { 
    236                                                                                                                                         cr->tplList->prev = NULL; 
    237                                                                                                         } 
    238                                                                         } else { 
    239                                                                                                         ptpltmp->prev->next = ptpltmp->next; 
    240                                                                                                         if (ptpltmp->next) { 
    241                                                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    242                                                                                                         } 
    243                                                                         } 
    244                                                                         deleteTplFlSet(ptpltmp); 
    245                                                                         ptpltmp = NULL; 
    246                                                                         cTFSPtr = NULL; 
    247                                                                         cTFSPtr = newRouterTplList(); 
    248                                                                         cTFSPtr->next = cr->tplList; 
    249                                                                         if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
    250                                                                         cr->tplList = cTFSPtr; 
    251                                                                         cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
    252                                                                         cTFSPtr->sourceId = v9Ptr->sourceId; 
    253                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    254                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    255                                                                         if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
    256                                                                                                         badFieldCount = 1; 
    257                                                                                                         ptpltmp = cTFSPtr; 
    258                                                                                                         if (ptpltmp->prev == NULL) { 
    259                                                                                                                                         cr->tplList = ptpltmp->next; 
    260                                                                                                                                         if (cr->tplList) { 
    261                                                                                                                                                                         cr->tplList->prev = NULL; 
    262                                                                                                                                         } 
    263                                                                                                         } else { 
    264                                                                                                                                         ptpltmp->prev->next = ptpltmp->next; 
    265                                                                                                                                         if (ptpltmp->next) { 
    266                                                                                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    267                                                                                                                                         } 
    268                                                                                                         } 
    269                                                                                                         deleteTplFlSet(ptpltmp); 
    270                                                                                                         cTFSPtr = NULL; 
    271                                                                                                         return (-1); 
    272                                                                         } 
    273                                                                         cpt_fields = 0; 
    274                                                                         for ( i=0; i<cTFSPtr->fieldCount; i++) { 
    275                                                                                                         FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
    276                                                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    277                                                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    278                                                                                                         if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    279                                                                                                                                         badFieldNumber = 1; 
    280                                                                                                         } 
    281                                                                                                         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    282                                                                                                         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    283                                                                                                         if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    284                                                                                                                                         badFieldLength = 1; 
    285                                                                                                         } 
    286                                                                                                         fldPtr->next = cTFSPtr->fieldSet; 
    287                                                                                                         fldPtr->prev = NULL; 
    288                                                                                                         if ( cTFSPtr->fieldSet ) { 
    289                                                                                                                                         cTFSPtr->fieldSet->prev = fldPtr; 
    290                                                                                                         } 
    291                                                                                                         cTFSPtr->fieldSet = fldPtr; 
    292                                                                                                         if (i==0) { 
    293                                                                                                                                         cTFSPtr->lastField = fldPtr; 
    294                                                                                                         } 
    295                                                                                                         cpt_fields++; 
    296                                                                                                         if ( (cTFSPtr->templateFlowSetId < 256 )  
    297                                                                                                                                                                         || (cpt_fields > 25)  
    298                                                                                                                                                                         || (badFieldNumber == 1)  
    299                                                                                                                                                                         || badFieldLength == 1  
    300                                                                                                                                                                         || (badFieldCount == 1)) { 
    301                                                                                                                                         while ( ((*offV9))> (index)){ 
    302                                                                                                                                                                         buffer2[1]= *(buf+index); index++; 
    303                                                                                                                                                                         buffer2[0]= *(buf+index); index++; 
    304                                                                                                                                                                         tmp = *((unsigned short*)&buffer2); 
    305                                                                                                                                                                                     fprintf (stderr, " %hu ", tmp);  
    306                                                                                                                                         } 
    307                                                                                                                                         syslog (LOG_INFO,  
    308                                                                                                                                                                                                         "in update template function: too many fields, bug collector or wrong template def in template update"); 
    309                                                                                                                                                   fprintf(stderr,  
    310                                                                                                                                                           "\nin update template function: too many fields, bug collector or wrong template def in template update\n");  
    311                                                                                                                                         ptpltmp = cTFSPtr; 
    312                                                                                                                                         if (ptpltmp->prev == NULL) { 
    313                                                                                                                                                                         cr->tplList = ptpltmp->next; 
    314                                                                                                                                                                         if (cr->tplList) { 
    315                                                                                                                                                                                                         cr->tplList->prev = NULL; 
    316                                                                                                                                                                         } 
    317                                                                                                                                         } else { 
    318                                                                                                                                                                         ptpltmp->prev->next = ptpltmp->next; 
    319                                                                                                                                                                         if (ptpltmp->next) { 
    320                                                                                                                                                                                                         ptpltmp->next->prev = ptpltmp->prev; 
    321                                                                                                                                                                         } 
    322                                                                                                                                         } 
    323                                                                                                                                         deleteTplFlSet(ptpltmp); 
    324                                                                                                                                         cTFSPtr = NULL; 
    325                                                                                                                                         return (-1);       
    326                                                                                                         } 
    327                                                                         } 
    328                                         } /* end if template creation or update */ 
    329                                         /* send to queue the template definition */ 
    330                                         /*     fprintf(stderr,"%hu %d\n", tplMsgType, sizeof(tplMsgType)); */ 
    331                                         /*     fprintf(stderr,"%lu %d\n", cr->IpAddress, sizeof(cr->IpAddress)); */ 
    332                                         /*     fprintf(stderr, "%lu.%lu.%lu.%lu ", */ 
    333                                         /*          ( cr->IpAddress)>>24, */ 
    334                                         /*          ( cr->IpAddress)<<8>>24, */ 
    335                                         /*          ( cr->IpAddress)<<16>>24, */ 
    336                                         /*          ( cr->IpAddress)<<24>>24); */ 
    337                                         /*     fprintf(stderr,"%lu %d\n", cTFSPtr->sourceId, sizeof(cTFSPtr->sourceId)); */ 
    338                                         /* FIXME HERE don't send an wrong def if error detected */ 
    339                                         msgTextIndex = mempcpy(mempcpy(mempcpy(mempcpy(mempcpy(myMsg.text,  
    340                                                                                                                                                                                                                                         &tplMsgType,  
    341                                                                                                                                                                                                                                         sizeof(unsigned short)  
    342                                                                                                                                                                                                                                         ),  
    343                                                                                                                                                                                                         &cr->IpAddress,  
    344                                                                                                                                                                                                         sizeof(unsigned long)  
    345                                                                                                                                                                                                         ),  
    346                                                                                                                                                                         &cTFSPtr->sourceId,  
    347                                                                                                                                                                         sizeof(unsigned long)  
    348                                                                                                                                                                         ),  
    349                                                                                                                                         &cTFSPtr->templateFlowSetId,  
    350                                                                                                                                         sizeof(cTFSPtr->templateFlowSetId)  
    351                                                                                                                                         ),  
    352                                                                                                         &cTFSPtr->fieldCount,  
    353                                                                                                         sizeof(cTFSPtr->fieldCount)  
    354                                                                                                         );  
    355                                         /* add the fields list */ 
    356                                         tmpField = cTFSPtr->lastField; 
    357                                         for (; tmpField; tmpField=tmpField->prev) { 
    358                                                                         msgTextIndex = mempcpy(mempcpy(msgTextIndex, 
    359                                                                                                                                                                         &tmpField->fieldType, 
    360                                                                                                                                                                         sizeof(tmpField->fieldType)), 
    361                                                                                                                                         &tmpField->fieldLength, 
    362                                                                                                                                         sizeof(tmpField->fieldLength)); 
    363                                         } 
    364                                         myMsg.type = 1; 
    365                                         msgSend( myQueue, myMsg); 
    366                                         /* end send */ 
    367                                         (*cFNPtr)++;     
    368         } while ( (cpt) < (length-2) ); /*length-2*/ 
    369 #ifdef DEBUG 
    370         fprintf (stderr, "}"); 
    371 #endif 
    372         return length; 
     368  return length; 
    373369} 
    374370 
     
    377373 * 
    378374 */ 
    379                                 short  
     375short  
    380376checkTemplateOption(RouterPtr cr, unsigned short *offV9,  
    381                                                                 unsigned char *buf, NetFlowV9HeaderPtr v9Ptr, 
    382                                                                 TplOptionPtr cTOPtr, 
    383                                                                 short *cFNPtr) 
     377                    unsigned char *buf, NetFlowV9HeaderPtr v9Ptr, 
     378                    TplOptionPtr cTOPtr, 
     379                    short *cFNPtr) 
    384380{ 
    385                                 int i; 
    386                                 int cpt = 0;  
    387                                 unsigned short getFlowsetId = 0; 
    388                                 unsigned short length = 0; 
    389                                 unsigned char buffer2[2]; 
    390                                 TplOptionPtr ptplotmp; 
    391                                 unsigned short badFieldNumber = 0; 
    392                                 unsigned short badFieldLength = 0; 
    393                                 int cpt_fields = 0; 
    394  
    395                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    396                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    397                                 getFlowsetId = *((unsigned short*)&buffer2); 
    398                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    399                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    400                                 length = *((unsigned short*)&buffer2); 
    401                                 do { 
    402 #ifdef DEBUG     
    403                                                                 fprintf (stderr, "<"); 
    404 #endif 
    405                                                                 badFieldNumber = 0; 
    406                                                                 badFieldLength = 0; 
    407                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    408                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    409                                                                 if ((cTOPtr= 
    410                                                                                                                                                                 existTplOptId(cr, v9Ptr->sourceId,  
    411                                                                                                                                                                                                 *((unsigned short*)&buffer2)))==NULL) { 
    412                                                                                                 cTOPtr = newRouterTplOptList(); 
    413                                                                                                 cTOPtr->next = cr->tplOptList; 
    414                                                                                                 if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
    415                                                                                                 cr->tplOptList = cTOPtr; 
    416                                                                                                 cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
    417                                                                                                 cTOPtr->sourceId = v9Ptr->sourceId; 
    418                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    419                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    420                                                                                                 cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
    421                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    422                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    423                                                                                                 cTOPtr->optionLg = *((unsigned short*)&buffer2); 
    424                                                                                                 cpt_fields = 0; 
    425                                                                                                 for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
    426                                                                                                                                 FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
    427                                                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    428                                                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    429                                                                                                                                 if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    430                                                                                                                                                                 badFieldNumber = 1; 
    431                                                                                                                                 } 
    432                                                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    433                                                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    434                                                                                                                                 if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    435                                                                                                                                                                 badFieldLength = 1; 
    436                                                                                                                                 } 
    437                                                                                                                                 tmp->next = cTOPtr->fieldSet; 
    438                                                                                                                                 tmp->prev = NULL; 
    439                                                                                                                                 if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
    440                                                                                                                                 cTOPtr->fieldSet = tmp; 
    441                                                                                                                                 if (i==0) { 
    442                                                                                                                                                                 cTOPtr->lastField = tmp; 
    443                                                                                                                                 } 
    444                                                                                                                                 cpt_fields++; 
    445                                                                                                                                 if ( (cTOPtr->templateOptionId < 256)  
    446                                                                                                                                                                                 || (cpt_fields > 25)  
    447                                                                                                                                                                                 || (badFieldNumber == 1)  
    448                                                                                                                                                                                 || badFieldLength == 1) { 
    449                                                                                                                                                                 syslog (LOG_INFO,  
    450                                                                                                                                                                                                                                 "in option template function: too many fields, bug collector or wrong template def in template update"); 
    451 #ifdef DEBUG 
    452                                                                                                                                                                 fprintf(stderr, 
    453                                                                                                                                                                                                                                 "\nin option template function: too many fields, bug collector or wrong template def in template update\n"); 
    454 #endif 
    455                                                                                                                                                                 ptplotmp = cTOPtr; 
    456                                                                                                                                                                 if (ptplotmp->prev == NULL) { 
    457                                                                                                                                                                                                 cr->tplOptList = ptplotmp->next; 
    458                                                                                                                                                                                                 if (cr->tplOptList) { 
    459                                                                                                                                                                                                                                 cr->tplOptList->prev = NULL; 
    460                                                                                                                                                                                                 } 
    461                                                                                                                                                                 } else { 
    462                                                                                                                                                                                                 ptplotmp->prev->next = ptplotmp->next; 
    463                                                                                                                                                                                                 if (ptplotmp->next) { 
    464                                                                                                                                                                                                                                 ptplotmp->next->prev = ptplotmp->prev; 
    465                                                                                                                                                                                                 } 
    466                                                                                                                                                                 } 
    467                                                                                                                                                                 deleteTplOption(ptplotmp); 
    468                                                                                                                                                                 cTOPtr = NULL; 
    469                                                                                                                                                                 return (-1); 
    470                                                                                                                                 } 
    471                                                                                                 } 
    472                                                                                                 while ((*offV9)%4 != 0) { 
    473                                                                                                                                 (*offV9)++; cpt++; 
    474                                                                                                 } /*padding case*/ 
    475                                                                 } else { /*update */ 
    476                                                                                                 ptplotmp = cTOPtr; 
    477                                                                                                 if (ptplotmp->prev == NULL) { 
    478                                                                                                                                 cr->tplOptList = ptplotmp->next; 
    479                                                                                                                                 if (cr->tplOptList) { 
    480                                                                                                                                                                 cr->tplOptList->prev = NULL; 
    481                                                                                                                                 } 
    482                                                                                                 } else { 
    483                                                                                                                                 ptplotmp->prev->next = ptplotmp->next; 
    484                                                                                                                                 if (ptplotmp->next) { 
    485                                                                                                                                                                 ptplotmp->next->prev = ptplotmp->prev; 
    486                                                                                                                                 } 
    487                                                                                                 } 
    488                                                                                                 deleteTplOption(ptplotmp); 
    489                                                                                                 cTOPtr = NULL; 
    490                                                                                                 cTOPtr = newRouterTplOptList(); 
    491                                                                                                 cTOPtr->next = cr->tplOptList; 
    492                                                                                                 if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
    493                                                                                                 cr->tplOptList = cTOPtr; 
    494                                                                                                 cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
    495                                                                                                 cTOPtr->sourceId = v9Ptr->sourceId; 
    496                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    497                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    498                                                                                                 cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
    499                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    500                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    501                                                                                                 cTOPtr->optionLg = *((unsigned short*)&buffer2); 
    502                                                                                                 cpt_fields = 0; 
    503                                                                                                 for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
    504                                                                                                                                 FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
    505                                                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    506                                                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    507                                                                                                                                 if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    508                                                                                                                                                                 badFieldNumber = 1; 
    509                                                                                                                                 } 
    510                                                                                                                                 buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    511                                                                                                                                 buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    512                                                                                                                                 if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    513                                                                                                                                                                 badFieldLength = 1; 
    514                                                                                                                                 } 
    515                                                                                                                                 tmp->next = cTOPtr->fieldSet; 
    516                                                                                                                                 tmp->prev = NULL; 
    517                                                                                                                                 if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
    518                                                                                                                                 cTOPtr->fieldSet = tmp; 
    519                                                                                                                                 if (i==0) { 
    520                                                                                                                                                                 cTOPtr->lastField = tmp; 
    521                                                                                                                                 } 
    522                                                                                                                                 cpt_fields++; 
    523                                                                                                                                 if ( (cTOPtr->templateOptionId < 256)  
    524                                                                                                                                                                                 || (cpt_fields > 25)  
    525                                                                                                                                                                                 || (badFieldNumber == 1)  
    526                                                                                                                                                                                 || badFieldLength == 1) { 
    527                                                                                                                                                                 syslog (LOG_INFO,  
    528                                                                                                                                                                                                                                 "in update option tpl function: too many fields, bug collector or wrong template def in template update"); 
    529 #ifdef DEBUG 
    530                                                                                                                                                                 fprintf(stderr, 
    531                                                                                                                                                                                                                                 "\nin update option tpl function: too many fields, bug collector or wrong template def in template update\n"); 
    532 #endif 
    533                                                                                                                                                                 ptplotmp = cTOPtr; 
    534                                                                                                                                                                 if (ptplotmp->prev == NULL) { 
    535                                                                                                                                                                                                 cr->tplOptList = ptplotmp->next; 
    536                                                                                                                                                                                                 if (cr->tplOptList) { 
    537                                                                                                                                                                                                                                 cr->tplOptList->prev = NULL; 
    538                                                                                                                                                                                                 } 
    539                                                                                                                                                                 } else { 
    540                                                                                                                                                                                                 ptplotmp->prev->next = ptplotmp->next; 
    541                                                                                                                                                                                                 if (ptplotmp->next) { 
    542                                                                                                                                                                                                                                 ptplotmp->next->prev = ptplotmp->prev; 
    543                                                                                                                                                                                                 } 
    544                                                                                                                                                                 } 
    545                                                                                                                                                                 deleteTplOption(ptplotmp); 
    546                                                                                                                                                                 cTOPtr = NULL; 
    547                                                                                                                                                                 return (-1); 
    548                                                                                                                                 } 
    549                                                                                                 } 
    550                                                                                                 while ((*offV9)%4 != 0) { 
    551                                                                                                                                 (*offV9)++; cpt++; 
    552                                                                                                 } /*padding case*/ 
    553                                                                 } 
    554                                                                 (*cFNPtr)++; 
    555                                 } while ((cpt) < (length-2)); 
    556                                 /*   show_all_tplFlSet(); */ 
    557 #ifdef DEBUG 
    558                                 fprintf (stderr, ">"); 
    559 #endif 
    560                                 return length; 
     381  int i; 
     382  int cpt = 0;  
     383  unsigned short getFlowsetId = 0; 
     384  unsigned short length = 0; 
     385  unsigned char buffer2[2]; 
     386  TplOptionPtr ptplotmp; 
     387  unsigned short badFieldNumber = 0; 
     388  unsigned short badFieldLength = 0; 
     389  int cpt_fields = 0; 
     390  int index = 0; 
     391 
     392  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     393  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     394  getFlowsetId = *((unsigned short*)&buffer2); 
     395  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     396  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     397  length = *((unsigned short*)&buffer2); 
     398  do { 
     399    /*#ifdef DEBUG    */ 
     400    fprintf (stderr, "< %hu, %hu, ",getFlowsetId, length); 
     401    /*#endif*/ 
     402    badFieldNumber = 0; 
     403    badFieldLength = 0; 
     404    buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     405    buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     406    if ((cTOPtr= 
     407         existTplOptId(cr, v9Ptr->sourceId,  
     408                       *((unsigned short*)&buffer2)))==NULL) { 
     409      cTOPtr = newRouterTplOptList(); 
     410      cTOPtr->next = cr->tplOptList; 
     411      if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
     412      cr->tplOptList = cTOPtr; 
     413      cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
     414      cTOPtr->sourceId = v9Ptr->sourceId; 
     415      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     416      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     417      cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
     418      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     419      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     420      cTOPtr->optionLg = *((unsigned short*)&buffer2); 
     421      fprintf (stderr, " otid %hu, %hu, %hu, ", cTOPtr->templateOptionId, cTOPtr->optionScopeLg, cTOPtr->optionLg); 
     422      cpt_fields = 0; 
     423      for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
     424        FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
     425        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     426        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     427        if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
     428          badFieldNumber = 1; 
     429        } 
     430        fprintf (stderr, " %hu - ", tmp->fieldType); 
     431        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     432        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     433        if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 64) { 
     434          badFieldLength = 1; 
     435        } 
     436        fprintf (stderr, " %hu,", tmp->fieldLength); 
     437        tmp->next = cTOPtr->fieldSet; 
     438        tmp->prev = NULL; 
     439        if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
     440        cTOPtr->fieldSet = tmp; 
     441        if (i==0) { 
     442          cTOPtr->lastField = tmp; 
     443        } 
     444        cpt_fields++; 
     445        if ( (cTOPtr->templateOptionId < 256)  
     446             || (cpt_fields > 25)  
     447             || (badFieldNumber == 1)  
     448             || badFieldLength == 1) { 
     449          fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu\n", 
     450                  cr->IpAddress>>24, 
     451                  cr->IpAddress<<8>>24, 
     452                  cr->IpAddress<<16>>24, 
     453                  cr->IpAddress<<24>>24); 
     454          syslog (LOG_INFO,  
     455                  "in option template function: too many fields, bug collector or wrong template def in template update"); 
     456          /*#ifdef DEBUG*/ 
     457          fprintf(stderr, 
     458                  "\nin option template function: too many fields, bug collector or wrong template def in template update\n"); 
     459          /*#endif*/ 
     460          while ( ((*offV9))> (index)){ 
     461            buffer2[1]= *(buf+index); index++; 
     462            buffer2[0]= *(buf+index); index++; 
     463            tmp = *((unsigned short*)&buffer2); 
     464            fprintf (stderr, " %hu ", tmp); 
     465          } 
     466 
     467          ptplotmp = cTOPtr; 
     468          if (ptplotmp->prev == NULL) { 
     469            cr->tplOptList = ptplotmp->next; 
     470            if (cr->tplOptList) { 
     471              cr->tplOptList->prev = NULL; 
     472            } 
     473          } else { 
     474            ptplotmp->prev->next = ptplotmp->next; 
     475            if (ptplotmp->next) { 
     476              ptplotmp->next->prev = ptplotmp->prev; 
     477            } 
     478          } 
     479          deleteTplOption(ptplotmp); 
     480          cTOPtr = NULL; 
     481          return (-1); 
     482        } 
     483      } 
     484      while ((*offV9)%4 != 0) { 
     485        (*offV9)++; cpt++; 
     486        fprintf(stderr,"p"); 
     487      } /*padding case*/ 
     488    } else { /*update */ 
     489      ptplotmp = cTOPtr; 
     490      if (ptplotmp->prev == NULL) { 
     491        cr->tplOptList = ptplotmp->next; 
     492        if (cr->tplOptList) { 
     493          cr->tplOptList->prev = NULL; 
     494        } 
     495      } else { 
     496        ptplotmp->prev->next = ptplotmp->next; 
     497        if (ptplotmp->next) { 
     498          ptplotmp->next->prev = ptplotmp->prev; 
     499        } 
     500      } 
     501      deleteTplOption(ptplotmp); 
     502      cTOPtr = NULL; 
     503      cTOPtr = newRouterTplOptList(); 
     504      cTOPtr->next = cr->tplOptList; 
     505      if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
     506      cr->tplOptList = cTOPtr; 
     507      cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
     508      cTOPtr->sourceId = v9Ptr->sourceId; 
     509      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     510      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     511      cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
     512      buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     513      buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     514      cTOPtr->optionLg = *((unsigned short*)&buffer2); 
     515      cpt_fields = 0; 
     516      for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
     517        FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
     518        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     519        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     520        if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
     521          badFieldNumber = 1; 
     522        } 
     523        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     524        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
     525        if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 64) { 
     526          badFieldLength = 1; 
     527        } 
     528        tmp->next = cTOPtr->fieldSet; 
     529        tmp->prev = NULL; 
     530        if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
     531        cTOPtr->fieldSet = tmp; 
     532        if (i==0) { 
     533          cTOPtr->lastField = tmp; 
     534        } 
     535        cpt_fields++; 
     536        if ( (cTOPtr->templateOptionId < 256)  
     537             || (cpt_fields > 25)  
     538             || (badFieldNumber == 1)  
     539             || badFieldLength == 1) { 
     540          fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu\n", 
     541                  cr->IpAddress>>24, 
     542                  cr->IpAddress<<8>>24, 
     543                  cr->IpAddress<<16>>24, 
     544                  cr->IpAddress<<24>>24); 
     545          syslog (LOG_INFO,  
     546                  "in update option tpl function: too many fields, bug collector or wrong template def in template update"); 
     547          /*#ifdef DEBUG*/ 
     548          fprintf(stderr, 
     549                  "\nin update option tpl function: too many fields, bug collector or wrong template def in template update\n"); 
     550          /*#endif*/ 
     551          ptplotmp = cTOPtr; 
     552          if (ptplotmp->prev == NULL) { 
     553            cr->tplOptList = ptplotmp->next; 
     554            if (cr->tplOptList) { 
     555              cr->tplOptList->prev = NULL; 
     556            } 
     557          } else { 
     558            ptplotmp->prev->next = ptplotmp->next; 
     559            if (ptplotmp->next) { 
     560              ptplotmp->next->prev = ptplotmp->prev; 
     561            } 
     562          } 
     563          deleteTplOption(ptplotmp); 
     564          cTOPtr = NULL; 
     565          return (-1); 
     566        } 
     567      } 
     568      while ((*offV9)%4 != 0) { 
     569        (*offV9)++; cpt++; 
     570        fprintf(stderr,"p"); 
     571      } /*padding case*/ 
     572    } 
     573    (*cFNPtr)++; 
     574  } while ((cpt) < (length-2)); 
     575  /*   show_all_tplFlSet(); */ 
     576  /*#ifdef DEBUG*/ 
     577  fprintf (stderr, ">"); 
     578  /*#endif*/ 
     579  return length; 
    561580} 
    562581 
     
    570589 *    - a pointer on the template flowset or NULL 
    571590 */ 
    572                                 TplFlowSetPtr  
     591TplFlowSetPtr  
    573592existId(RouterPtr cr, unsigned long idh, short idfs) 
    574593{ 
    575                                 TplFlowSetPtr tmp=cr->tplList; 
    576                                 for (; tmp; tmp=tmp->next) { 
    577                                                                 if ((tmp->sourceId==idh)) { 
    578                                                                                                 return tmp; 
    579                                                                 } 
    580                                 } 
    581                                 return NULL; 
     594  TplFlowSetPtr tmp=cr->tplList; 
     595  for (; tmp; tmp=tmp->next) { 
     596    if ((tmp->sourceId==idh)) { 
     597      return tmp; 
     598    } 
     599  } 
     600  return NULL; 
    582601} 
    583602 
     
    588607 *    - a pointer on the correct template flowset definition 
    589608 */ 
    590                                 TplFlowSetPtr  
     609TplFlowSetPtr  
    591610existTplId(RouterPtr cr, unsigned long sid, short idfs) 
    592611{ 
    593                                 TplFlowSetPtr tmp=cr->tplList; 
    594                                 for (; tmp; tmp=tmp->next) { 
    595                                                                 if ((tmp->sourceId==sid)&&(tmp->templateFlowSetId == idfs)) { 
    596                                                                                                 return tmp; 
    597                                                                 } 
    598                                 } 
    599                                 return NULL; 
     612  TplFlowSetPtr tmp=cr->tplList; 
     613  for (; tmp; tmp=tmp->next) { 
     614    if ((tmp->sourceId==sid)&&(tmp->templateFlowSetId == idfs)) { 
     615      return tmp; 
     616    } 
     617  } 
     618  return NULL; 
    600619} 
    601620 
     
    606625 *    - a pointer on the correct template option definition 
    607626 */ 
    608                                 TplOptionPtr  
     627TplOptionPtr  
    609628existTplOptId(RouterPtr cr, unsigned long sid, short idfs) 
    610629{ 
    611                                 TplOptionPtr tmp=cr->tplOptList; 
    612                                 for (; tmp; tmp=tmp->next) { 
    613                                                                 if ((tmp->sourceId==sid)&&(tmp->templateOptionId == idfs)) { 
    614                                                                                                 return tmp; 
    615                                                                 } 
    616                                 } 
    617                                 return NULL; 
     630  TplOptionPtr tmp=cr->tplOptList; 
     631  for (; tmp; tmp=tmp->next) { 
     632    if ((tmp->sourceId==sid)&&(tmp->templateOptionId == idfs)) { 
     633      return tmp; 
     634    } 
     635  } 
     636  return NULL; 
    618637}