extcap:Replace self-organized lists with glib ones
[metze/wireshark/wip.git] / extcap_parser.c
1 /* extcap_parser.c
2  *
3  * Routines for extcap external capture
4  * Copyright 2013, Mike Ryan <mikeryan@lacklustre.net>
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include <config.h>
26
27 #include <stdio.h>
28 #include <glib.h>
29 #include <string.h>
30
31 #include "extcap.h"
32 #include "extcap_parser.h"
33
34 void extcap_printf_complex(extcap_complex *comp) {
35     gchar *ret = extcap_get_complex_as_string(comp);
36     printf("%s", ret);
37     g_free(ret);
38 }
39
40 gchar *extcap_get_complex_as_string(extcap_complex *comp) {
41     return (comp ? g_strdup(comp->_val) : NULL);
42 }
43
44 extcap_complex *extcap_parse_complex(extcap_arg_type complex_type,
45         const gchar *data) {
46
47     extcap_complex *rc = g_new0(extcap_complex, 1);
48
49     rc->_val = g_strdup(data);
50     rc->complex_type = complex_type;
51
52     return rc;
53 }
54
55 gboolean extcap_compare_is_default(extcap_arg *element, extcap_complex *test) {
56     if ( element == NULL || element->default_complex == NULL || test == NULL )
57         return FALSE;
58
59     if ( g_strcmp0(element->default_complex->_val, test->_val) == 0 )
60         return TRUE;
61
62     return FALSE;
63 }
64
65 void extcap_free_complex(extcap_complex *comp) {
66     if ( comp )
67         g_free(comp->_val);
68     g_free(comp);
69 }
70
71 gint extcap_complex_get_int(extcap_complex *comp) {
72     if ( comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_INTEGER )
73         return (gint)0;
74
75     return (gint) g_ascii_strtoll(comp->_val, NULL, 10);
76 }
77
78 guint extcap_complex_get_uint(extcap_complex *comp) {
79     if ( comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_UNSIGNED )
80         return (guint)0;
81     return (guint) g_ascii_strtoull(comp->_val, NULL, 10);
82 }
83
84 gint64 extcap_complex_get_long(extcap_complex *comp) {
85     if ( comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_LONG )
86         return (gint64)0;
87     return g_ascii_strtoll( comp->_val, NULL, 10 );
88 }
89
90 gdouble extcap_complex_get_double(extcap_complex *comp) {
91     if ( comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_DOUBLE )
92         return (gdouble)0;
93     return g_strtod( comp->_val, NULL );
94 }
95
96 gboolean extcap_complex_get_bool(extcap_complex *comp) {
97     if ( comp == NULL || comp->_val == NULL  )
98         return FALSE;
99
100     if ( comp->complex_type != EXTCAP_ARG_BOOLEAN && comp->complex_type != EXTCAP_ARG_BOOLFLAG )
101         return FALSE;
102
103     return g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, comp->_val, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
104 }
105
106 gchar *extcap_complex_get_string(extcap_complex *comp) {
107     /* Not checking for argument type, to use this method as fallback if only strings are needed */
108     return comp != NULL ? comp->_val : NULL;
109 }
110
111 static extcap_token_sentence *extcap_tokenize_sentence(const gchar *s) {
112     GRegex * regex = NULL;
113     GMatchInfo * match_info = NULL;
114     GError * error = NULL;
115     gchar * param_value = NULL;
116     guint param_type = EXTCAP_PARAM_UNKNOWN;
117
118     extcap_token_sentence *rs = g_new0(extcap_token_sentence, 1);
119
120     rs->sentence = NULL;
121     rs->param_list = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
122
123     /* Regex for catching just the allowed values for sentences */
124     if ( ( regex = g_regex_new ( "^[\\t| ]*(arg|value|interface|extcap|dlt)(?=[\\t| ]+\\{)",
125             (GRegexCompileFlags) G_REGEX_CASELESS, (GRegexMatchFlags) 0, NULL ) ) != NULL ) {
126         g_regex_match ( regex, s, (GRegexMatchFlags) 0, &match_info );
127
128         if ( g_match_info_matches ( match_info ) )
129             rs->sentence = g_match_info_fetch(match_info, 0);
130
131         g_match_info_free ( match_info );
132         g_regex_unref ( regex );
133     }
134     /* No valid sentence found, exiting here */
135     if ( rs->sentence == NULL ) {
136         g_free(rs);
137         return NULL;
138     }
139
140     /* Capture the argument and the value of the list. This will ensure,
141      * that regex patterns given to {validation=} are parsed correctly,
142      * as long as }{ does not occur within the pattern */
143     regex = g_regex_new ( "\\{([a-zA-Z_-]*?)\\=(.*?)\\}(?=\\{|$|\\s)",
144             (GRegexCompileFlags) G_REGEX_CASELESS, (GRegexMatchFlags) 0, NULL );
145     if ( regex != NULL ) {
146         g_regex_match_full(regex, s, -1, 0, (GRegexMatchFlags) 0, &match_info, &error );
147         while(g_match_info_matches(match_info)) {
148             gchar * arg = g_match_info_fetch ( match_info, 1 );
149
150             if ( arg == NULL )
151                 break;
152
153             param_value = g_strdup(g_match_info_fetch ( match_info, 2 ));
154
155             if (g_ascii_strcasecmp(arg, "number") == 0) {
156                 param_type = EXTCAP_PARAM_ARGNUM;
157             } else if (g_ascii_strcasecmp(arg, "call") == 0) {
158                 param_type = EXTCAP_PARAM_CALL;
159             } else if (g_ascii_strcasecmp(arg, "display") == 0) {
160                 param_type = EXTCAP_PARAM_DISPLAY;
161             } else if (g_ascii_strcasecmp(arg, "type") == 0) {
162                 param_type = EXTCAP_PARAM_TYPE;
163             } else if (g_ascii_strcasecmp(arg, "arg") == 0) {
164                 param_type = EXTCAP_PARAM_ARG;
165             } else if (g_ascii_strcasecmp(arg, "default") == 0) {
166                 param_type = EXTCAP_PARAM_DEFAULT;
167             } else if (g_ascii_strcasecmp(arg, "value") == 0) {
168                 param_type = EXTCAP_PARAM_VALUE;
169             } else if (g_ascii_strcasecmp(arg, "range") == 0) {
170                 param_type = EXTCAP_PARAM_RANGE;
171             } else if (g_ascii_strcasecmp(arg, "tooltip") == 0) {
172                 param_type = EXTCAP_PARAM_TOOLTIP;
173             } else if (g_ascii_strcasecmp(arg, "mustexist") == 0) {
174                 param_type = EXTCAP_PARAM_FILE_MUSTEXIST;
175             } else if (g_ascii_strcasecmp(arg, "fileext") == 0) {
176                 param_type = EXTCAP_PARAM_FILE_EXTENSION;
177             } else if (g_ascii_strcasecmp(arg, "name") == 0) {
178                 param_type = EXTCAP_PARAM_NAME;
179             } else if (g_ascii_strcasecmp(arg, "enabled") == 0) {
180                 param_type = EXTCAP_PARAM_ENABLED;
181             } else if (g_ascii_strcasecmp(arg, "parent") == 0) {
182                 param_type = EXTCAP_PARAM_PARENT;
183             } else if (g_ascii_strcasecmp(arg, "required") == 0) {
184                 param_type = EXTCAP_PARAM_REQUIRED;
185             } else if (g_ascii_strcasecmp(arg, "save") == 0) {
186                 param_type = EXTCAP_PARAM_SAVE;
187             } else if (g_ascii_strcasecmp(arg, "validation") == 0) {
188                 param_type = EXTCAP_PARAM_VALIDATION;
189             } else if (g_ascii_strcasecmp(arg, "version") == 0) {
190                 param_type = EXTCAP_PARAM_VERSION;
191             } else {
192                 param_type = EXTCAP_PARAM_UNKNOWN;
193             }
194
195             g_hash_table_insert(rs->param_list, ENUM_KEY(param_type), param_value);
196
197             g_match_info_next(match_info, &error);
198         }
199         g_match_info_free(match_info);
200         g_regex_unref(regex);
201     }
202
203     return rs;
204 }
205
206 static GList *extcap_tokenize_sentences(const gchar *s) {
207
208     GList * sentences = NULL;
209     extcap_token_sentence *item = NULL;
210     gchar **list, **list_iter;
211
212     list_iter = list = g_strsplit(s, "\n", 0);
213     while ( *list_iter != NULL ) {
214         item = extcap_tokenize_sentence(*list_iter);
215         if (item)
216             sentences = g_list_append(sentences, item);
217         list_iter++;
218     }
219
220     g_strfreev(list);
221
222     return sentences;
223 }
224
225 static void extcap_free_value(extcap_value *v) {
226     if (v == NULL)
227         return;
228
229     g_free(v->call);
230     g_free(v->display);
231
232     g_free(v);
233 }
234
235 static void extcap_free_valuelist(gpointer data, gpointer user_data _U_) {
236     extcap_free_value((extcap_value *) data);
237 }
238
239 void extcap_free_arg(extcap_arg *a) {
240
241     if (a == NULL)
242         return;
243
244     g_free(a->call);
245     g_free(a->display);
246     g_free(a->tooltip);
247     g_free(a->fileextension);
248     g_free(a->regexp);
249     g_free(a->device_name);
250
251     if (a->range_start != NULL)
252         extcap_free_complex(a->range_start);
253
254     if (a->range_end != NULL)
255         extcap_free_complex(a->range_end);
256
257     if (a->default_complex != NULL)
258         extcap_free_complex(a->default_complex);
259
260     g_list_foreach(a->values, (GFunc) extcap_free_valuelist, NULL);
261 }
262
263 static void extcap_free_arg_list_cb(gpointer listentry, gpointer data _U_) {
264     if (listentry != NULL)
265         extcap_free_arg((extcap_arg *) listentry);
266 }
267
268 void extcap_free_arg_list(GList *a) {
269     g_list_foreach(a, extcap_free_arg_list_cb, NULL);
270     g_list_free(a);
271 }
272
273 static gint glist_find_numbered_arg(gconstpointer listelem, gconstpointer needle) {
274     if (((const extcap_arg *) listelem)->arg_num == *((const int*) needle))
275         return 0;
276     return 1;
277 }
278
279 static void extcap_free_tokenized_sentence(gpointer s, gpointer user_data _U_) {
280
281     if (s == NULL)
282         return;
283
284     g_free(((extcap_token_sentence *)s)->sentence);
285     g_hash_table_destroy(((extcap_token_sentence *)s)->param_list);
286 }
287
288 static extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
289     gchar * param_value = NULL;
290
291     extcap_arg *target_arg = NULL;
292     extcap_value *value = NULL;
293     GList * entry = NULL;
294     int tint;
295     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
296
297     if (s == NULL)
298         return target_arg;
299
300     if (g_ascii_strcasecmp(s->sentence, "arg") == 0) {
301         sent = EXTCAP_SENTENCE_ARG;
302         /* printf("ARG sentence\n"); */
303     } else if (g_ascii_strcasecmp(s->sentence, "value") == 0) {
304         sent = EXTCAP_SENTENCE_VALUE;
305         /* printf("VALUE sentence\n"); */
306     }
307
308     if (sent == EXTCAP_SENTENCE_ARG) {
309         target_arg = g_new0(extcap_arg, 1);
310         target_arg->arg_type = EXTCAP_ARG_UNKNOWN;
311         target_arg->save = TRUE;
312
313
314         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARGNUM))) == NULL) {
315             extcap_free_arg(target_arg);
316             return NULL ;
317         }
318
319         if (sscanf(param_value, "%d", &(target_arg->arg_num)) != 1) {
320             extcap_free_arg(target_arg);
321             return NULL ;
322         }
323
324         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_CALL))) == NULL) {
325             extcap_free_arg(target_arg);
326             return NULL ;
327         }
328         target_arg->call = g_strdup(param_value);
329
330         /* No value only parameters allowed */
331         if (strlen(target_arg->call) == 0) {
332             extcap_free_arg(target_arg);
333             return NULL ;
334         }
335
336         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY))) == NULL) {
337             extcap_free_arg(target_arg);
338             return NULL ;
339         }
340         target_arg->display = g_strdup(param_value);
341
342         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TOOLTIP)))
343                 != NULL) {
344             target_arg->tooltip = g_strdup(param_value);
345         }
346
347         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_FILE_MUSTEXIST)))
348                 != NULL) {
349             target_arg->fileexists = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, param_value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
350         }
351
352         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_FILE_EXTENSION)))
353                 != NULL) {
354             target_arg->fileextension = g_strdup(param_value);
355         }
356
357         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALIDATION)))
358                 != NULL) {
359             target_arg->regexp = g_strdup(param_value);
360         }
361
362         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_REQUIRED)))
363                 != NULL) {
364             target_arg->is_required = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, param_value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
365         }
366
367         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TYPE)))
368                 == NULL) {
369             /* printf("no type in ARG sentence\n"); */
370             extcap_free_arg(target_arg);
371             return NULL ;
372         }
373
374         if (g_ascii_strcasecmp(param_value, "integer") == 0) {
375             target_arg->arg_type = EXTCAP_ARG_INTEGER;
376         } else if (g_ascii_strcasecmp(param_value, "unsigned") == 0) {
377             target_arg->arg_type = EXTCAP_ARG_UNSIGNED;
378         } else if (g_ascii_strcasecmp(param_value, "long") == 0) {
379             target_arg->arg_type = EXTCAP_ARG_LONG;
380         } else if (g_ascii_strcasecmp(param_value, "double") == 0) {
381             target_arg->arg_type = EXTCAP_ARG_DOUBLE;
382         } else if (g_ascii_strcasecmp(param_value, "boolean") == 0) {
383             target_arg->arg_type = EXTCAP_ARG_BOOLEAN;
384         } else if (g_ascii_strcasecmp(param_value, "boolflag") == 0) {
385             target_arg->arg_type = EXTCAP_ARG_BOOLFLAG;
386         } else if (g_ascii_strcasecmp(param_value, "selector") == 0) {
387             target_arg->arg_type = EXTCAP_ARG_SELECTOR;
388         } else if (g_ascii_strcasecmp(param_value, "radio") == 0) {
389             target_arg->arg_type = EXTCAP_ARG_RADIO;
390         } else if (g_ascii_strcasecmp(param_value, "string") == 0) {
391             target_arg->arg_type = EXTCAP_ARG_STRING;
392         } else if (g_ascii_strcasecmp(param_value, "password") == 0) {
393             target_arg->arg_type = EXTCAP_ARG_PASSWORD;
394             /* default setting is to not save passwords */
395             target_arg->save = FALSE;
396         } else if (g_ascii_strcasecmp(param_value, "fileselect") == 0) {
397             target_arg->arg_type = EXTCAP_ARG_FILESELECT;
398         } else if (g_ascii_strcasecmp(param_value, "multicheck") == 0) {
399             target_arg->arg_type = EXTCAP_ARG_MULTICHECK;
400         } else {
401             printf("invalid type %s in ARG sentence\n", param_value);
402             extcap_free_arg(target_arg);
403             return NULL ;
404         }
405
406         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_SAVE)))
407                 != NULL) {
408             target_arg->save = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, param_value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
409         }
410
411         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_RANGE)))
412                 != NULL) {
413             gchar *cp = g_strstr_len(param_value, -1, ",");
414
415             if (cp == NULL) {
416                 printf("invalid range, expected value,value got %s\n",
417                         param_value);
418                 extcap_free_arg(target_arg);
419                 return NULL ;
420             }
421
422             if ((target_arg->range_start = extcap_parse_complex(
423                     target_arg->arg_type, param_value)) == NULL) {
424                 printf("invalid range, expected value,value got %s\n",
425                         param_value);
426                 extcap_free_arg(target_arg);
427                 return NULL ;
428             }
429
430             if ((target_arg->range_end = extcap_parse_complex(
431                     target_arg->arg_type, cp + 1)) == NULL) {
432                 printf("invalid range, expected value,value got %s\n",
433                         param_value);
434                 extcap_free_arg(target_arg);
435                 return NULL ;
436             }
437         }
438
439         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT)))
440                 != NULL) {
441             if ( target_arg->arg_type != EXTCAP_ARG_MULTICHECK && target_arg->arg_type != EXTCAP_ARG_SELECTOR )
442             {
443                 if ((target_arg->default_complex = extcap_parse_complex(
444                         target_arg->arg_type, param_value)) == NULL) {
445                     printf("invalid default, couldn't parse %s\n", param_value);
446                 }
447             }
448         }
449
450     } else if (sent == EXTCAP_SENTENCE_VALUE) {
451         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARG)))
452                 == NULL) {
453             printf("no arg in VALUE sentence\n");
454             return NULL ;
455         }
456
457         if (sscanf(param_value, "%d", &tint) != 1) {
458             printf("invalid arg in VALUE sentence\n");
459             return NULL ;
460         }
461
462         ;
463         if ((entry = g_list_find_custom(args, &tint, glist_find_numbered_arg))
464                 == NULL) {
465             printf("couldn't find arg %d in list for VALUE sentence\n", tint);
466             return NULL ;
467         }
468
469         value = g_new0(extcap_value, 1);
470         value->arg_num = tint;
471
472         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALUE)))
473                 == NULL) {
474             /* printf("no value in VALUE sentence\n"); */
475             extcap_free_value(value);
476             return NULL ;
477         }
478         value->call = g_strdup(param_value);
479
480         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
481                 == NULL) {
482             /* printf("no display in VALUE sentence\n"); */
483             extcap_free_value(value);
484             return NULL ;
485         }
486         value->display = g_strdup(param_value);
487
488         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_PARENT)))
489                 != NULL) {
490             value->parent = g_strdup(param_value);
491         }
492
493         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT)))
494                 != NULL) {
495             /* printf("found default value\n"); */
496             value->is_default = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, param_value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
497         }
498
499         if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ENABLED)))
500                 != NULL) {
501             value->enabled = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, param_value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
502         }
503
504         ((extcap_arg*) entry->data)->values = g_list_append(
505                 ((extcap_arg*) entry->data)->values, value);
506
507         return NULL ;
508     }
509
510     return target_arg;
511 }
512
513 GList * extcap_parse_args(gchar *output) {
514     GList * result = NULL;
515     GList * walker = NULL;
516     GList * temp = NULL;
517
518     walker = extcap_tokenize_sentences(output);
519     temp = walker;
520
521     while (walker) {
522         extcap_arg *ra = NULL;
523         extcap_token_sentence * sentence = (extcap_token_sentence *)walker->data;
524
525         if ((ra = extcap_parse_arg_sentence(result, sentence)) != NULL)
526             result = g_list_append(result, (gpointer) ra);
527
528         walker = g_list_next(walker);
529     }
530
531     g_list_foreach(temp, extcap_free_tokenized_sentence, NULL);
532
533     return result;
534 }
535
536 static extcap_interface * extcap_parse_interface_sentence(extcap_token_sentence *s) {
537     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
538     gchar * param_value = NULL;
539     extcap_interface * ri = NULL;
540
541     if (s == NULL)
542         return NULL;
543
544     if (g_ascii_strcasecmp(s->sentence, "interface") == 0) {
545         sent = EXTCAP_SENTENCE_INTERFACE;
546     } else if (g_ascii_strcasecmp(s->sentence, "extcap") == 0) {
547         sent = EXTCAP_SENTENCE_EXTCAP;
548     }
549
550     if (sent == EXTCAP_SENTENCE_UNKNOWN)
551         return NULL;
552
553     ri = g_new(extcap_interface, 1);
554
555     ri->call = NULL;
556     ri->display = NULL;
557     ri->version = NULL;
558
559     ri->if_type = sent;
560
561     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALUE)))
562             == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
563         printf("No value in INTERFACE sentence\n");
564         g_free(ri);
565         return NULL;
566     }
567     ri->call = g_strdup(param_value);
568
569     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
570             == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
571         printf("No display in INTERFACE sentence\n");
572         g_free(ri->call);
573         g_free(ri);
574         return NULL;
575     }
576     ri->display = g_strdup(param_value);
577
578     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VERSION)))
579             != NULL) {
580         ri->version = g_strdup(param_value);
581     }
582
583     return ri;
584 }
585
586 GList * extcap_parse_interfaces(gchar *output) {
587
588     GList * result = NULL;
589     GList * tokens = NULL;
590     GList * walker = extcap_tokenize_sentences(output);
591     tokens = walker;
592
593     while (walker) {
594         extcap_interface * ri = NULL;
595         extcap_token_sentence * if_sentence = (extcap_token_sentence *) walker->data;
596
597         if ( if_sentence != NULL && ( ri = extcap_parse_interface_sentence ( if_sentence ) ) != NULL )
598             result = g_list_append(result, ri);
599
600         walker = g_list_next(walker);
601     }
602
603     g_list_foreach(tokens, extcap_free_tokenized_sentence, NULL);
604
605     return result;
606 }
607
608 /* Parse a tokenized set of sentences and validate, looking for DLT definitions */
609 static extcap_dlt * extcap_parse_dlt_sentence(extcap_token_sentence *s) {
610     gchar *param_value = NULL;
611     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
612     extcap_dlt * result = NULL;
613
614     if (s == NULL)
615         return result;
616
617     if (g_ascii_strcasecmp(s->sentence, "dlt") == 0) {
618         sent = EXTCAP_SENTENCE_DLT;
619     }
620
621     if (sent == EXTCAP_SENTENCE_UNKNOWN)
622         return result;
623
624     result = g_new0(extcap_dlt, 1);
625
626     result->number = -1;
627     result->name = NULL;
628     result->display = NULL;
629
630     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARGNUM)))
631             == NULL) {
632         printf("No number in DLT sentence\n");
633         g_free(result);
634         return NULL;
635     }
636     if (sscanf(param_value, "%d", &(result->number)) != 1) {
637         printf("Invalid number in DLT sentence\n");
638         g_free(result);
639         return NULL;
640     }
641
642     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_NAME)))
643             == NULL) {
644         printf("No name in DLT sentence\n");
645         g_free(result);
646         return NULL;
647     }
648     result->name = g_strdup(param_value);
649
650     if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
651             == NULL) {
652         printf("No display in DLT sentence\n");
653         g_free(result->name);
654         g_free(result);
655         return NULL;
656     }
657     result->display = g_strdup(param_value);
658
659     return result;
660 }
661
662 GList * extcap_parse_dlts(gchar *output) {
663
664     GList * walker = NULL;
665     GList * temp = NULL;
666     GList * result = NULL;
667
668     walker = extcap_tokenize_sentences(output);
669
670     temp = walker;
671
672     while (walker) {
673         extcap_dlt *data = NULL;
674
675         if ((data = extcap_parse_dlt_sentence((extcap_token_sentence *)walker->data)) != NULL)
676             result = g_list_append(result, data);
677
678         walker = g_list_next(walker);
679     }
680
681     g_list_foreach(temp, extcap_free_tokenized_sentence, NULL);
682
683     return result;
684 }
685
686 /*
687  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
688  *
689  * Local variables:
690  * c-basic-offset: 4
691  * tab-width: 8
692  * indent-tabs-mode: nil
693  * End:
694  *
695  * vi: set shiftwidth=4 tabstop=8 expandtab:
696  * :indentSize=4:tabSize=8:noTabs=true:
697  */