root/trunk/src/template.c @ 74

Revision 74, 22.3 KB (checked in by andreu, 14 years ago)

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

  • Property svn:eol-style set to native
Line 
1/*
2 * File: template.c
3 *
4 * Authors: ANDREU Francois-Xavier
5 *
6 * Copyright (C) 2005 2006 2007 GIP RENATER
7 */
8
9/*  This file is part of renetcol.
10 *
11 *  renetcol is free software; you can redistribute it and/or modify
12 *  it under the terms of the GNU General Public License as published by
13 *  the Free Software Foundation; either version 2 of the License, or
14 *  (at your option) any later version.
15 *
16 *  renetcol is distributed in the hope that it will be useful,
17 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *  GNU General Public License for more details.
20 *
21 *  You should have received a copy of the GNU General Public License
22 *  along with renetcol; if not, write to the Free Software
23 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24 */
25
26#include "template.h"
27
28/*
29 * getFlowsetId
30 *
31 * return the flowset id
32 */
33short 
34getFlowsetId(short cfn, unsigned short *offV9, unsigned char *buf)
35{
36  unsigned short os;
37  unsigned char buffer2[2];
38 
39  if ( cfn == 0 ) {
40    os = 20+8+20;
41  } else {
42    os = *offV9;
43  }
44  buffer2[1]= *(buf+os+0);
45  buffer2[0]= *(buf+os+1);
46  return *((unsigned short*)&buffer2);
47}
48
49/*
50 * checkTemplateFlowSet
51 *
52 * check the fields of a template flowset and build the Template Flowset List
53 * it can exist many templates definitions in a template flowset
54 */
55short 
56checkTemplateFlowSet(RouterPtr cr, unsigned short *offV9,
57                     unsigned char *buf,
58                     NetFlowV9HeaderPtr v9Ptr,
59                     TplFlowSetPtr cTFSPtr,
60                     short *cFNPtr,
61                     int myQueue)
62{
63  int i = 0;
64  int cpt = 0;
65  int cpt_fields = 0;
66  int index = 0;
67  unsigned char buffer2[2];
68  unsigned short tmp = 0;
69  unsigned short flowsetId = 0;
70  unsigned short length = 0;
71  TplFlowSetPtr ptpltmp = NULL;
72  /* for msg sending: */
73  msgType myMsg;
74  FieldPtr tmpField;
75  char *msgTextIndex;
76  unsigned short tplMsgType = 1;
77  unsigned short badFieldNumber = 0;
78  unsigned short badFieldLength = 0;
79  unsigned short badFieldCount = 0;
80
81  buffer2[1]= *(buf+(*offV9)); (*offV9)++; cpt++;
82  buffer2[0]= *(buf+(*offV9)); (*offV9)++; cpt++;
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
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;
373}
374
375/*
376 * checkTemplateOption
377 *
378 */
379                                short 
380checkTemplateOption(RouterPtr cr, unsigned short *offV9,
381                                                                unsigned char *buf, NetFlowV9HeaderPtr v9Ptr,
382                                                                TplOptionPtr cTOPtr,
383                                                                short *cFNPtr)
384{
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;
561}
562
563
564/*
565 * exist_id
566 *
567 * used in check a template flowset
568 * the id is the source_id(idh) plus getFlowsetId
569 * return:
570 *    - a pointer on the template flowset or NULL
571 */
572                                TplFlowSetPtr
573existId(RouterPtr cr, unsigned long idh, short idfs)
574{
575                                TplFlowSetPtr tmp=cr->tplList;
576                                for (; tmp; tmp=tmp->next) {
577                                                                if ((tmp->sourceId==idh)) {
578                                                                                                return tmp;
579                                                                }
580                                }
581                                return NULL;
582}
583
584/*
585 * existTplId
586 *
587 * return:
588 *    - a pointer on the correct template flowset definition
589 */
590                                TplFlowSetPtr
591existTplId(RouterPtr cr, unsigned long sid, short idfs)
592{
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;
600}
601
602/*
603 * existTploptId
604 *
605 * return:
606 *    - a pointer on the correct template option definition
607 */
608                                TplOptionPtr
609existTplOptId(RouterPtr cr, unsigned long sid, short idfs)
610{
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;
618}
Note: See TracBrowser for help on using the browser.