Changeset 74

Show
Ignore:
Timestamp:
09/26/08 16:17:28 (14 years ago)
Author:
andreu
Message:

new checkpoint on flowset length value in dataFlowSet.c and template.c

Location:
trunk/src
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • trunk/src/dataFlowSet.c

    r73 r74  
    9191  (*myPtrs->offsetV9Ptr)++; 
    9292  data_length = *((unsigned short*)&buffer2); 
     93  if (data_length == 0) { 
     94      syslog(LOG_INFO, "data flowset length null; all next informations of this data flowset are not considered! flowset ID: %hu, from router: %lu.%lu.%lu.%lu", 
     95             (*myPtrs->currentFlowsetIdPtr), 
     96             (myPtrs->pcktPtr->ipH->srcAdd>>24), 
     97             (myPtrs->pcktPtr->ipH->srcAdd<<8>>24), 
     98             (myPtrs->pcktPtr->ipH->srcAdd<<16>>24), 
     99             (myPtrs->pcktPtr->ipH->srcAdd<<24>>24)); 
     100      return (-1); 
     101 
     102  } 
    93103 
    94104  if ( (tmp=existTplId(myPtrs->currentRouterPtr,  
  • trunk/src/template.c

    r34 r74  
    8181  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    8282  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    83   flowsetId = *((unsigned short*)&buffer2); 
    84   buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    85   buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    86   length = *((unsigned short*)&buffer2); 
    87   do { 
    88 #ifdef DEBUG     
    89     fprintf (stderr, "{"); 
    90 #endif 
    91     badFieldNumber = 0; 
    92     badFieldLength = 0; 
    93     badFieldCount = 0; 
    94     buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    95     buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    96     if ((cTFSPtr= 
    97          existTplId(cr, v9Ptr->sourceId, 
    98                     *((unsigned short*)&buffer2)))==NULL) { 
    99       cTFSPtr = newRouterTplList(); 
    100       cTFSPtr->next = cr->tplList; 
    101       if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
    102       cr->tplList = cTFSPtr; 
    103       cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
    104       cTFSPtr->sourceId = v9Ptr->sourceId; 
    105       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    106       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    107       if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
    108         badFieldCount = 1; 
    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       } 
    125       cpt_fields = 0; 
    126       for ( i=0; i<cTFSPtr->fieldCount; i++) { 
    127         FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
     83        flowsetId = *((unsigned short*)&buffer2); 
     84        /* checkpoint on FLOWSET ID*/ 
     85        if ( flowsetId > 1024 ) /* FIXME CONST */  
     86        { 
     87#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);  
     98#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 
    128126        buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    129127        buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    130         if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    131           badFieldNumber = 1; 
    132         } 
    133         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    134         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    135         if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    136           badFieldLength = 1; 
    137         } 
    138         fldPtr->next = cTFSPtr->fieldSet; 
    139         fldPtr->prev = NULL; 
    140         if ( cTFSPtr->fieldSet ) {cTFSPtr->fieldSet->prev = fldPtr;} 
    141         cTFSPtr->fieldSet = fldPtr; 
    142         if (i==0) { 
    143           cTFSPtr->lastField = fldPtr; 
    144         } 
    145         cpt_fields++; 
    146         if ( (cTFSPtr->templateFlowSetId < 256 )  
    147              || (cpt_fields > 40)  
    148              || (badFieldNumber == 1)  
    149              || badFieldLength == 1  
    150              || (badFieldCount == 1)) { 
    151 /*        fprintf(stderr,"\n IP: %lu.%lu.%lu.%lu, %d,%d\n", */ 
    152 /*                cr->IpAddress>>24, */ 
    153 /*                cr->IpAddress<<8>>24, */ 
    154 /*                cr->IpAddress<<16>>24, */ 
    155 /*                cr->IpAddress<<24>>24, */ 
    156 /*                badFieldNumber, */ 
    157 /*                badFieldLength */ 
    158 /*                ); */ 
    159 /*        fprintf (stderr, "\n cTFSPtr->templateFlowSetId: %hu\n",  */ 
    160 /*                 cTFSPtr->templateFlowSetId); */ 
    161           while ( ((*offV9))> (index)){ 
    162             buffer2[1]= *(buf+index); index++; 
    163             buffer2[0]= *(buf+index); index++; 
    164             tmp = *((unsigned short*)&buffer2); 
    165 /*          fprintf (stderr, " %hu ", tmp); */ 
    166           } 
    167           syslog (LOG_INFO,  
    168                   "in new template: field nb gt 89, field lg gt 16 or too many fields, bad template definition possibility"); 
    169 /*        fprintf(stderr,  */ 
    170 /*                "\n in new template function: too many fields, bug collector or wrong template def \n");  */ 
    171           ptpltmp = cTFSPtr; 
    172           if (ptpltmp->prev == NULL) { 
    173             cr->tplList = ptpltmp->next; 
    174             if (cr->tplList) { 
    175               cr->tplList->prev = NULL; 
    176             } 
    177           } else { 
    178             ptpltmp->prev->next = ptpltmp->next; 
    179             if (ptpltmp->next) { 
    180               ptpltmp->next->prev = ptpltmp->prev; 
    181             } 
    182           } 
    183           deleteTplFlSet(ptpltmp); 
    184           cTFSPtr = NULL; 
    185           return (-1); 
    186         } 
    187       } 
    188     } else { /*update*/ 
    189       ptpltmp = cTFSPtr; 
    190       if (ptpltmp->prev == NULL) { 
    191         cr->tplList = ptpltmp->next; 
    192         if (cr->tplList) { 
    193           cr->tplList->prev = NULL; 
    194         } 
    195       } else { 
    196         ptpltmp->prev->next = ptpltmp->next; 
    197         if (ptpltmp->next) { 
    198           ptpltmp->next->prev = ptpltmp->prev; 
    199         } 
    200       } 
    201       deleteTplFlSet(ptpltmp); 
    202       ptpltmp = NULL; 
    203       cTFSPtr = NULL; 
    204       cTFSPtr = newRouterTplList(); 
    205       cTFSPtr->next = cr->tplList; 
    206       if (cr->tplList!=NULL) {cr->tplList->prev = cTFSPtr;} 
    207       cr->tplList = cTFSPtr; 
    208       cTFSPtr->templateFlowSetId = *((unsigned short*)&buffer2); 
    209       cTFSPtr->sourceId = v9Ptr->sourceId; 
    210       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    211       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    212       if ( (cTFSPtr->fieldCount = *((unsigned short*)&buffer2) ) == 0 ) { 
    213         badFieldCount = 1; 
    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       } 
    230       cpt_fields = 0; 
    231       for ( i=0; i<cTFSPtr->fieldCount; i++) { 
    232         FieldPtr fldPtr = (FieldPtr) malloc(sizeof(struct Field)); 
    233         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    234         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    235         if ( (fldPtr->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    236           badFieldNumber = 1; 
    237         } 
    238         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    239         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    240         if ( (fldPtr->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    241           badFieldLength = 1; 
    242         } 
    243         fldPtr->next = cTFSPtr->fieldSet; 
    244         fldPtr->prev = NULL; 
    245         if ( cTFSPtr->fieldSet ) { 
    246           cTFSPtr->fieldSet->prev = fldPtr; 
    247         } 
    248         cTFSPtr->fieldSet = fldPtr; 
    249         if (i==0) { 
    250           cTFSPtr->lastField = fldPtr; 
    251         } 
    252         cpt_fields++; 
    253         if ( (cTFSPtr->templateFlowSetId < 256 )  
    254              || (cpt_fields > 40)  
    255              || (badFieldNumber == 1)  
    256              || badFieldLength == 1  
    257              || (badFieldCount == 1)) { 
    258           while ( ((*offV9))> (index)){ 
    259             buffer2[1]= *(buf+index); index++; 
    260             buffer2[0]= *(buf+index); index++; 
    261             tmp = *((unsigned short*)&buffer2); 
    262 /*          fprintf (stderr, " %hu ", tmp); */ 
    263           } 
    264           syslog (LOG_INFO,  
    265                   "in update template function: too many fields, bug collector or wrong template def in template update"); 
    266 /*        fprintf(stderr, */ 
    267 /*                "\nin update template function: too many fields, bug collector or wrong template def in template update\n"); */ 
    268           ptpltmp = cTFSPtr; 
    269           if (ptpltmp->prev == NULL) { 
    270             cr->tplList = ptpltmp->next; 
    271             if (cr->tplList) { 
    272               cr->tplList->prev = NULL; 
    273             } 
    274           } else { 
    275             ptpltmp->prev->next = ptpltmp->next; 
    276             if (ptpltmp->next) { 
    277               ptpltmp->next->prev = ptpltmp->prev; 
    278             } 
    279           } 
    280           deleteTplFlSet(ptpltmp); 
    281           cTFSPtr = NULL; 
    282           return (-1);     
    283         } 
    284       } 
    285     } /* end if template creation or update */ 
    286     /* send to queue the template definition */ 
    287 /*     fprintf(stderr,"%hu %d\n", tplMsgType, sizeof(tplMsgType)); */ 
    288 /*     fprintf(stderr,"%lu %d\n", cr->IpAddress, sizeof(cr->IpAddress)); */ 
    289 /*     fprintf(stderr, "%lu.%lu.%lu.%lu ", */ 
    290 /*          ( cr->IpAddress)>>24, */ 
    291 /*          ( cr->IpAddress)<<8>>24, */ 
    292 /*          ( cr->IpAddress)<<16>>24, */ 
    293 /*          ( cr->IpAddress)<<24>>24); */ 
    294 /*     fprintf(stderr,"%lu %d\n", cTFSPtr->sourceId, sizeof(cTFSPtr->sourceId)); */ 
    295     /* FIXME HERE don't send an wrong def if error detected */ 
    296     msgTextIndex = mempcpy(mempcpy(mempcpy(mempcpy(mempcpy(myMsg.text,  
    297                                                            &tplMsgType,  
    298                                                            sizeof(unsigned short)  
    299                                                            ),  
    300                                                    &cr->IpAddress,  
    301                                                    sizeof(unsigned long)  
    302                                                    ),  
    303                                            &cTFSPtr->sourceId,  
    304                                            sizeof(unsigned long)  
    305                                            ),  
    306                                    &cTFSPtr->templateFlowSetId,  
    307                                    sizeof(cTFSPtr->templateFlowSetId)  
    308                                    ),  
    309                            &cTFSPtr->fieldCount,  
    310                            sizeof(cTFSPtr->fieldCount)  
    311                            );  
    312     /* add the fields list */ 
    313     tmpField = cTFSPtr->lastField; 
    314     for (; tmpField; tmpField=tmpField->prev) { 
    315       msgTextIndex = mempcpy(mempcpy(msgTextIndex, 
    316                                      &tmpField->fieldType, 
    317                                      sizeof(tmpField->fieldType)), 
    318                              &tmpField->fieldLength, 
    319                              sizeof(tmpField->fieldLength)); 
    320     } 
    321     myMsg.type = 1; 
    322     msgSend( myQueue, myMsg); 
    323     /* end send */ 
    324     (*cFNPtr)++;     
    325   } while ( (cpt) < (length-2) ); /*length-2*/ 
     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*/ 
    326369#ifdef DEBUG 
    327   fprintf (stderr, "}"); 
    328 #endif 
    329   return length; 
     370        fprintf (stderr, "}"); 
     371#endif 
     372        return length; 
    330373} 
    331374 
     
    334377 * 
    335378 */ 
    336 short  
     379                                short  
    337380checkTemplateOption(RouterPtr cr, unsigned short *offV9,  
    338                     unsigned char *buf, NetFlowV9HeaderPtr v9Ptr, 
    339                     TplOptionPtr cTOPtr, 
    340                     short *cFNPtr) 
     381                                                                unsigned char *buf, NetFlowV9HeaderPtr v9Ptr, 
     382                                                                TplOptionPtr cTOPtr, 
     383                                                                short *cFNPtr) 
    341384{ 
    342   int i; 
    343   int cpt = 0;  
    344   unsigned short getFlowsetId = 0; 
    345   unsigned short length = 0; 
    346   unsigned char buffer2[2]; 
    347   TplOptionPtr ptplotmp; 
    348   unsigned short badFieldNumber = 0; 
    349   unsigned short badFieldLength = 0; 
    350   int cpt_fields = 0; 
    351  
    352   buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    353   buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    354   getFlowsetId = *((unsigned short*)&buffer2); 
    355   buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    356   buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    357   length = *((unsigned short*)&buffer2); 
    358   do { 
     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 { 
    359402#ifdef DEBUG     
    360     fprintf (stderr, "<"); 
    361 #endif 
    362     badFieldNumber = 0; 
    363     badFieldLength = 0; 
    364     buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    365     buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    366     if ((cTOPtr= 
    367          existTplOptId(cr, v9Ptr->sourceId,  
    368                        *((unsigned short*)&buffer2)))==NULL) { 
    369       cTOPtr = newRouterTplOptList(); 
    370       cTOPtr->next = cr->tplOptList; 
    371       if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
    372       cr->tplOptList = cTOPtr; 
    373       cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
    374       cTOPtr->sourceId = v9Ptr->sourceId; 
    375       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    376       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    377       cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
    378       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    379       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    380       cTOPtr->optionLg = *((unsigned short*)&buffer2); 
    381       cpt_fields = 0; 
    382       for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
    383         FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
    384         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    385         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    386         if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    387           badFieldNumber = 1; 
    388         } 
    389         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    390         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    391         if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    392           badFieldLength = 1; 
    393         } 
    394         tmp->next = cTOPtr->fieldSet; 
    395         tmp->prev = NULL; 
    396         if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
    397         cTOPtr->fieldSet = tmp; 
    398         if (i==0) { 
    399           cTOPtr->lastField = tmp; 
    400         } 
    401         cpt_fields++; 
    402         if ( (cTOPtr->templateOptionId < 256) || (cpt_fields > 40) || (badFieldNumber == 1) || badFieldLength == 1) { 
    403           syslog (LOG_INFO,  
    404                   "in option template function: too many fields, bug collector or wrong template def in template update"); 
     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"); 
    405451#ifdef DEBUG 
    406           fprintf(stderr, 
    407                   "\nin option template function: too many fields, bug collector or wrong template def in template update\n"); 
    408 #endif 
    409           ptplotmp = cTOPtr; 
    410           if (ptplotmp->prev == NULL) { 
    411             cr->tplOptList = ptplotmp->next; 
    412             if (cr->tplOptList) { 
    413               cr->tplOptList->prev = NULL; 
    414             } 
    415           } else { 
    416             ptplotmp->prev->next = ptplotmp->next; 
    417             if (ptplotmp->next) { 
    418               ptplotmp->next->prev = ptplotmp->prev; 
    419             } 
    420           } 
    421           deleteTplOption(ptplotmp); 
    422           cTOPtr = NULL; 
    423           return (-1); 
    424         } 
    425       } 
    426       while ((*offV9)%4 != 0) { 
    427         (*offV9)++; cpt++; 
    428       } /*padding case*/ 
    429     } else { /*update */ 
    430       ptplotmp = cTOPtr; 
    431       if (ptplotmp->prev == NULL) { 
    432         cr->tplOptList = ptplotmp->next; 
    433         if (cr->tplOptList) { 
    434           cr->tplOptList->prev = NULL; 
    435         } 
    436       } else { 
    437         ptplotmp->prev->next = ptplotmp->next; 
    438         if (ptplotmp->next) { 
    439           ptplotmp->next->prev = ptplotmp->prev; 
    440         } 
    441       } 
    442       deleteTplOption(ptplotmp); 
    443       cTOPtr = NULL; 
    444       cTOPtr = newRouterTplOptList(); 
    445       cTOPtr->next = cr->tplOptList; 
    446       if (cr->tplOptList!=NULL) {cr->tplOptList->prev = cTOPtr;} 
    447       cr->tplOptList = cTOPtr; 
    448       cTOPtr->templateOptionId = *((unsigned short*)&buffer2); 
    449       cTOPtr->sourceId = v9Ptr->sourceId; 
    450       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    451       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    452       cTOPtr->optionScopeLg = *((unsigned short*)&buffer2); 
    453       buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    454       buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    455       cTOPtr->optionLg = *((unsigned short*)&buffer2); 
    456       cpt_fields = 0; 
    457       for ( i=0; i<(((cTOPtr->optionScopeLg)+(cTOPtr->optionLg))/4); i++) { 
    458         FieldPtr tmp = (FieldPtr) malloc(sizeof(struct Field)); 
    459         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    460         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    461         if ( (tmp->fieldType = *((unsigned short*)&buffer2) ) > 89) { 
    462           badFieldNumber = 1; 
    463         } 
    464         buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    465         buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++; 
    466         if ( (tmp->fieldLength = *((unsigned short*)&buffer2) ) > 16) { 
    467           badFieldLength = 1; 
    468         } 
    469         tmp->next = cTOPtr->fieldSet; 
    470         tmp->prev = NULL; 
    471         if ( cTOPtr->fieldSet ) {cTOPtr->fieldSet->prev = tmp;} 
    472         cTOPtr->fieldSet = tmp; 
    473         if (i==0) { 
    474           cTOPtr->lastField = tmp; 
    475         } 
    476         cpt_fields++; 
    477         if ( (cTOPtr->templateOptionId < 256) || (cpt_fields > 40) || (badFieldNumber == 1) || badFieldLength == 1) { 
    478           syslog (LOG_INFO,  
    479                   "in update option tpl function: too many fields, bug collector or wrong template def in template update"); 
     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"); 
    480529#ifdef DEBUG 
    481           fprintf(stderr, 
    482                   "\nin update option tpl function: too many fields, bug collector or wrong template def in template update\n"); 
    483 #endif 
    484           ptplotmp = cTOPtr; 
    485           if (ptplotmp->prev == NULL) { 
    486             cr->tplOptList = ptplotmp->next; 
    487             if (cr->tplOptList) { 
    488               cr->tplOptList->prev = NULL; 
    489             } 
    490           } else { 
    491             ptplotmp->prev->next = ptplotmp->next; 
    492             if (ptplotmp->next) { 
    493               ptplotmp->next->prev = ptplotmp->prev; 
    494             } 
    495           } 
    496           deleteTplOption(ptplotmp); 
    497           cTOPtr = NULL; 
    498           return (-1); 
    499         } 
    500       } 
    501       while ((*offV9)%4 != 0) { 
    502         (*offV9)++; cpt++; 
    503       } /*padding case*/ 
    504     } 
    505     (*cFNPtr)++; 
    506   } while ((cpt) < (length-2)); 
    507 /*   show_all_tplFlSet(); */ 
     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(); */ 
    508557#ifdef DEBUG 
    509   fprintf (stderr, ">"); 
    510 #endif 
    511   return length; 
     558                                fprintf (stderr, ">"); 
     559#endif 
     560                                return length; 
    512561} 
    513562 
     
    521570 *    - a pointer on the template flowset or NULL 
    522571 */ 
    523 TplFlowSetPtr  
     572                                TplFlowSetPtr  
    524573existId(RouterPtr cr, unsigned long idh, short idfs) 
    525574{ 
    526   TplFlowSetPtr tmp=cr->tplList; 
    527   for (; tmp; tmp=tmp->next) { 
    528     if ((tmp->sourceId==idh)) { 
    529       return tmp; 
    530     } 
    531   } 
    532   return NULL; 
     575                                TplFlowSetPtr tmp=cr->tplList; 
     576                                for (; tmp; tmp=tmp->next) { 
     577                                                                if ((tmp->sourceId==idh)) { 
     578                                                                                                return tmp; 
     579                                                                } 
     580                                } 
     581                                return NULL; 
    533582} 
    534583 
     
    539588 *    - a pointer on the correct template flowset definition 
    540589 */ 
    541 TplFlowSetPtr  
     590                                TplFlowSetPtr  
    542591existTplId(RouterPtr cr, unsigned long sid, short idfs) 
    543592{ 
    544   TplFlowSetPtr tmp=cr->tplList; 
    545   for (; tmp; tmp=tmp->next) { 
    546     if ((tmp->sourceId==sid)&&(tmp->templateFlowSetId == idfs)) { 
    547       return tmp; 
    548     } 
    549   } 
    550   return NULL; 
     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; 
    551600} 
    552601 
     
    557606 *    - a pointer on the correct template option definition 
    558607 */ 
    559 TplOptionPtr  
     608                                TplOptionPtr  
    560609existTplOptId(RouterPtr cr, unsigned long sid, short idfs) 
    561610{ 
    562   TplOptionPtr tmp=cr->tplOptList; 
    563   for (; tmp; tmp=tmp->next) { 
    564     if ((tmp->sourceId==sid)&&(tmp->templateOptionId == idfs)) { 
    565       return tmp; 
    566     } 
    567   } 
    568   return NULL; 
     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; 
    569618}