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 void extcap_free_tokenized_param(extcap_token_param *v) {
 112     if (v != NULL)
 113     {
 114         g_free(v->arg);
 115         g_free(v->value);
 116     }
 117
 118     g_free(v);
 119 }
 120
 121 void extcap_free_tokenized_sentence(extcap_token_sentence *s) {
 122     extcap_token_param *tv;
 123
 124     if (s == NULL)
 125         return;
 126
 127     if (s->sentence != NULL)
 128         g_free(s->sentence);
 129
 130     while (s->param_list != NULL ) {
 131         tv = s->param_list;
 132         s->param_list = tv->next_token;
 133
 134         extcap_free_tokenized_param(tv);
 135     }
 136     g_free(s);
 137 }
 138
 139 void extcap_free_tokenized_sentence_list(extcap_token_sentence *f) {
 140     extcap_token_sentence *t;
 141
 142     while (f != NULL ) {
 143         t = f->next_sentence;
 144         extcap_free_tokenized_sentence(f);
 145         f = t;
 146     }
 147 }
 148
 149 extcap_token_sentence *extcap_tokenize_sentence(const gchar *s) {
 150     extcap_token_param *tv = NULL;
 151     GRegex * regex = NULL;
 152     GMatchInfo * match_info = NULL;
 153     GError * error = NULL;
 154
 155     extcap_token_sentence *rs = g_new(extcap_token_sentence, 1);
 156
 157     rs->sentence = NULL;
 158     rs->next_sentence = NULL;
 159     rs->param_list = NULL;
 160
 161     /* Regex for catching just the allowed values for sentences */
 162     if ( ( regex = g_regex_new ( "^[\\t| ]*(arg|value|interface|extcap|dlt)(?=[\\t| ]+\\{)",
 163             (GRegexCompileFlags) G_REGEX_CASELESS, (GRegexMatchFlags) 0, NULL ) ) != NULL ) {
 164         g_regex_match ( regex, s, (GRegexMatchFlags) 0, &match_info );
 165
 166         if ( g_match_info_matches ( match_info ) )
 167             rs->sentence = g_match_info_fetch(match_info, 0);
 168
 169         g_match_info_free ( match_info );
 170         g_regex_unref ( regex );
 171     }
 172     /* No valid sentence found, exiting here */
 173     if ( rs->sentence == NULL ) {
 174         extcap_free_tokenized_sentence(rs);
 175         return NULL;
 176     }
 177
 178     /* Capture the argument and the value of the list. This will ensure,
 179      * that regex patterns given to {validation=} are parsed correctly,
 180      * as long as }{ does not occur within the pattern */
 181     regex = g_regex_new ( "\\{([a-zA-Z_-]*?)\\=(.*?)\\}(?=\\{|$|\\s)",
 182             (GRegexCompileFlags) G_REGEX_CASELESS, (GRegexMatchFlags) 0, NULL );
 183     if ( regex != NULL ) {
 184         g_regex_match_full(regex, s, -1, 0, (GRegexMatchFlags) 0, &match_info, &error );
 185         while(g_match_info_matches(match_info)) {
 186             gchar * arg = g_match_info_fetch ( match_info, 1 );
 187
 188             if ( arg == NULL )
 189                 break;
 190
 191             tv = g_new(extcap_token_param, 1);
 192             tv->arg = arg;
 193             tv->value = g_match_info_fetch ( match_info, 2 );
 194
 195             if (g_ascii_strcasecmp(tv->arg, "number") == 0) {
 196                 tv->param_type = EXTCAP_PARAM_ARGNUM;
 197             } else if (g_ascii_strcasecmp(tv->arg, "call") == 0) {
 198                 tv->param_type = EXTCAP_PARAM_CALL;
 199             } else if (g_ascii_strcasecmp(tv->arg, "display") == 0) {
 200                 tv->param_type = EXTCAP_PARAM_DISPLAY;
 201             } else if (g_ascii_strcasecmp(tv->arg, "type") == 0) {
 202                 tv->param_type = EXTCAP_PARAM_TYPE;
 203             } else if (g_ascii_strcasecmp(tv->arg, "arg") == 0) {
 204                 tv->param_type = EXTCAP_PARAM_ARG;
 205             } else if (g_ascii_strcasecmp(tv->arg, "default") == 0) {
 206                 tv->param_type = EXTCAP_PARAM_DEFAULT;
 207             } else if (g_ascii_strcasecmp(tv->arg, "value") == 0) {
 208                 tv->param_type = EXTCAP_PARAM_VALUE;
 209             } else if (g_ascii_strcasecmp(tv->arg, "range") == 0) {
 210                 tv->param_type = EXTCAP_PARAM_RANGE;
 211             } else if (g_ascii_strcasecmp(tv->arg, "tooltip") == 0) {
 212                 tv->param_type = EXTCAP_PARAM_TOOLTIP;
 213             } else if (g_ascii_strcasecmp(tv->arg, "mustexist") == 0) {
 214                 tv->param_type = EXTCAP_PARAM_FILE_MUSTEXIST;
 215             } else if (g_ascii_strcasecmp(tv->arg, "fileext") == 0) {
 216                 tv->param_type = EXTCAP_PARAM_FILE_EXTENSION;
 217             } else if (g_ascii_strcasecmp(tv->arg, "name") == 0) {
 218                 tv->param_type = EXTCAP_PARAM_NAME;
 219             } else if (g_ascii_strcasecmp(tv->arg, "enabled") == 0) {
 220                 tv->param_type = EXTCAP_PARAM_ENABLED;
 221             } else if (g_ascii_strcasecmp(tv->arg, "parent") == 0) {
 222                 tv->param_type = EXTCAP_PARAM_PARENT;
 223             } else if (g_ascii_strcasecmp(tv->arg, "required") == 0) {
 224                 tv->param_type = EXTCAP_PARAM_REQUIRED;
 225             } else if (g_ascii_strcasecmp(tv->arg, "save") == 0) {
 226                 tv->param_type = EXTCAP_PARAM_SAVE;
 227             } else if (g_ascii_strcasecmp(tv->arg, "validation") == 0) {
 228                 tv->param_type = EXTCAP_PARAM_VALIDATION;
 229             } else if (g_ascii_strcasecmp(tv->arg, "version") == 0) {
 230                 tv->param_type = EXTCAP_PARAM_VERSION;
 231             } else {
 232                 tv->param_type = EXTCAP_PARAM_UNKNOWN;
 233             }
 234
 235             tv->next_token = rs->param_list;
 236             rs->param_list = tv;
 237
 238             g_match_info_next(match_info, &error);
 239         }
 240         g_match_info_free(match_info);
 241         g_regex_unref(regex);
 242     }
 243
 244     return rs;
 245 }
 246
 247 extcap_token_sentence *extcap_tokenize_sentences(const gchar *s) {
 248     extcap_token_sentence *first = NULL, *cur = NULL, *last = NULL;
 249
 250     gchar **list, **list_iter;
 251
 252     list_iter = list = g_strsplit(s, "\n", 0);
 253
 254     while (*list_iter != NULL ) {
 255         cur = extcap_tokenize_sentence(*list_iter);
 256
 257         if (cur != NULL) {
 258             if (first == NULL) {
 259                 first = cur;
 260                 last = cur;
 261             } else {
 262                 last->next_sentence = cur;
 263                 last = cur;
 264             }
 265         }
 266
 267         list_iter++;
 268     }
 269
 270     g_strfreev(list);
 271
 272     return first;
 273 }
 274
 275 extcap_token_param *extcap_find_param_by_type(extcap_token_param *first,
 276         extcap_param_type t) {
 277     while (first != NULL ) {
 278         if (first->param_type == t) {
 279             return first;
 280         }
 281
 282         first = first->next_token;
 283     }
 284
 285     return NULL ;
 286 }
 287
 288 void extcap_free_value(extcap_value *v) {
 289     if (v == NULL)
 290         return;
 291
 292     g_free(v->call);
 293     g_free(v->display);
 294
 295     g_free(v);
 296 }
 297
 298 extcap_interface *extcap_new_interface(void) {
 299     extcap_interface *r = g_new(extcap_interface, 1);
 300
 301     r->call = r->display = r->version = NULL;
 302     r->if_type = EXTCAP_SENTENCE_UNKNOWN;
 303     r->next_interface = NULL;
 304
 305     return r;
 306 }
 307
 308 void extcap_free_interface(extcap_interface *i) {
 309     extcap_interface *next_i = i;
 310
 311     while (i) {
 312         next_i = i->next_interface;
 313         g_free(i->call);
 314         g_free(i->display);
 315         g_free(i->version);
 316         g_free(i);
 317         i = next_i;
 318     }
 319 }
 320
 321 extcap_dlt *extcap_new_dlt(void) {
 322     extcap_dlt *r = g_new(extcap_dlt, 1);
 323
 324     r->number = -1;
 325     r->name = r->display = NULL;
 326     r->next_dlt = NULL;
 327
 328     return r;
 329 }
 330
 331 void extcap_free_dlt(extcap_dlt *d) {
 332     if (d == NULL)
 333         return;
 334
 335     g_free(d->name);
 336     g_free(d->display);
 337 }
 338
 339 static void extcap_free_valuelist(gpointer data, gpointer user_data _U_) {
 340     extcap_free_value((extcap_value *) data);
 341 }
 342
 343 void extcap_free_arg(extcap_arg *a) {
 344
 345     if (a == NULL)
 346         return;
 347
 348     g_free(a->call);
 349     g_free(a->display);
 350     g_free(a->tooltip);
 351     g_free(a->fileextension);
 352     g_free(a->regexp);
 353     g_free(a->storeval);
 354
 355     if (a->range_start != NULL)
 356         extcap_free_complex(a->range_start);
 357
 358     if (a->range_end != NULL)
 359         extcap_free_complex(a->range_end);
 360
 361     if (a->default_complex != NULL)
 362         extcap_free_complex(a->default_complex);
 363
 364     g_list_foreach(a->values, (GFunc) extcap_free_valuelist, NULL);
 365 }
 366
 367 static void extcap_free_arg_list_cb(gpointer listentry, gpointer data _U_) {
 368     if (listentry != NULL)
 369         extcap_free_arg((extcap_arg *) listentry);
 370 }
 371
 372 void extcap_free_arg_list(GList *a) {
 373     g_list_foreach(a, extcap_free_arg_list_cb, NULL);
 374     g_list_free(a);
 375 }
 376
 377 static gint glist_find_numbered_arg(gconstpointer listelem, gconstpointer needle) {
 378     if (((const extcap_arg *) listelem)->arg_num == *((const int*) needle))
 379         return 0;
 380     return 1;
 381 }
 382
 383 extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
 384     extcap_token_param *v = NULL;
 385     extcap_arg *target_arg = NULL;
 386     extcap_value *value = NULL;
 387     GList * entry = NULL;
 388     int tint;
 389     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
 390
 391     if (s == NULL)
 392         return target_arg;
 393
 394     if (g_ascii_strcasecmp(s->sentence, "arg") == 0) {
 395         sent = EXTCAP_SENTENCE_ARG;
 396         /* printf("ARG sentence\n"); */
 397     } else if (g_ascii_strcasecmp(s->sentence, "value") == 0) {
 398         sent = EXTCAP_SENTENCE_VALUE;
 399         /* printf("VALUE sentence\n"); */
 400     }
 401
 402     if (sent == EXTCAP_SENTENCE_ARG) {
 403         target_arg = g_new0(extcap_arg, 1);
 404         target_arg->arg_type = EXTCAP_ARG_UNKNOWN;
 405         target_arg->save = TRUE;
 406
 407         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ARGNUM))
 408                 == NULL) {
 409             extcap_free_arg(target_arg);
 410             return NULL ;
 411         }
 412
 413         if (sscanf(v->value, "%d", &(target_arg->arg_num)) != 1) {
 414             extcap_free_arg(target_arg);
 415             return NULL ;
 416         }
 417
 418         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_CALL))
 419                 == NULL) {
 420             extcap_free_arg(target_arg);
 421             return NULL ;
 422         }
 423         target_arg->call = g_strdup(v->value);
 424
 425         /* No value only parameters allowed */
 426         if (strlen(target_arg->call) == 0) {
 427             extcap_free_arg(target_arg);
 428             return NULL ;
 429         }
 430
 431         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DISPLAY))
 432                 == NULL) {
 433             extcap_free_arg(target_arg);
 434             return NULL ;
 435         }
 436         target_arg->display = g_strdup(v->value);
 437
 438         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_TOOLTIP))
 439                 != NULL) {
 440             target_arg->tooltip = g_strdup(v->value);
 441         }
 442
 443         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_FILE_MUSTEXIST))
 444                 != NULL) {
 445             target_arg->fileexists = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 446         }
 447
 448         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_FILE_EXTENSION))
 449                 != NULL) {
 450             target_arg->fileextension = g_strdup(v->value);
 451         }
 452
 453         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_VALIDATION))
 454                 != NULL) {
 455             target_arg->regexp = g_strdup(v->value);
 456         }
 457
 458         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_REQUIRED))
 459                 != NULL) {
 460             target_arg->is_required = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 461         }
 462
 463         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_TYPE))
 464                 == NULL) {
 465             /* printf("no type in ARG sentence\n"); */
 466             extcap_free_arg(target_arg);
 467             return NULL ;
 468         }
 469
 470         if (g_ascii_strcasecmp(v->value, "integer") == 0) {
 471             target_arg->arg_type = EXTCAP_ARG_INTEGER;
 472         } else if (g_ascii_strcasecmp(v->value, "unsigned") == 0) {
 473             target_arg->arg_type = EXTCAP_ARG_UNSIGNED;
 474         } else if (g_ascii_strcasecmp(v->value, "long") == 0) {
 475             target_arg->arg_type = EXTCAP_ARG_LONG;
 476         } else if (g_ascii_strcasecmp(v->value, "double") == 0) {
 477             target_arg->arg_type = EXTCAP_ARG_DOUBLE;
 478         } else if (g_ascii_strcasecmp(v->value, "boolean") == 0) {
 479             target_arg->arg_type = EXTCAP_ARG_BOOLEAN;
 480         } else if (g_ascii_strcasecmp(v->value, "boolflag") == 0) {
 481             target_arg->arg_type = EXTCAP_ARG_BOOLFLAG;
 482         } else if (g_ascii_strcasecmp(v->value, "selector") == 0) {
 483             target_arg->arg_type = EXTCAP_ARG_SELECTOR;
 484         } else if (g_ascii_strcasecmp(v->value, "radio") == 0) {
 485             target_arg->arg_type = EXTCAP_ARG_RADIO;
 486         } else if (g_ascii_strcasecmp(v->value, "string") == 0) {
 487             target_arg->arg_type = EXTCAP_ARG_STRING;
 488         } else if (g_ascii_strcasecmp(v->value, "password") == 0) {
 489             target_arg->arg_type = EXTCAP_ARG_PASSWORD;
 490             /* default setting is to not save passwords */
 491             target_arg->save = FALSE;
 492         } else if (g_ascii_strcasecmp(v->value, "fileselect") == 0) {
 493             target_arg->arg_type = EXTCAP_ARG_FILESELECT;
 494         } else if (g_ascii_strcasecmp(v->value, "multicheck") == 0) {
 495             target_arg->arg_type = EXTCAP_ARG_MULTICHECK;
 496         } else {
 497             printf("invalid type %s in ARG sentence\n", v->value);
 498             extcap_free_arg(target_arg);
 499             return NULL ;
 500         }
 501
 502         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_SAVE))
 503                 != NULL) {
 504             target_arg->save = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 505         }
 506
 507         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_RANGE))
 508                 != NULL) {
 509             gchar *cp = g_strstr_len(v->value, -1, ",");
 510
 511             if (cp == NULL) {
 512                 printf("invalid range, expected value,value got %s\n",
 513                         v->value);
 514                 extcap_free_arg(target_arg);
 515                 return NULL ;
 516             }
 517
 518             if ((target_arg->range_start = extcap_parse_complex(
 519                     target_arg->arg_type, v->value)) == NULL) {
 520                 printf("invalid range, expected value,value got %s\n",
 521                         v->value);
 522                 extcap_free_arg(target_arg);
 523                 return NULL ;
 524             }
 525
 526             if ((target_arg->range_end = extcap_parse_complex(
 527                     target_arg->arg_type, cp + 1)) == NULL) {
 528                 printf("invalid range, expected value,value got %s\n",
 529                         v->value);
 530                 extcap_free_arg(target_arg);
 531                 return NULL ;
 532             }
 533         }
 534
 535         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DEFAULT))
 536                 != NULL) {
 537             if ( target_arg->arg_type != EXTCAP_ARG_MULTICHECK && target_arg->arg_type != EXTCAP_ARG_SELECTOR )
 538             {
 539                 if ((target_arg->default_complex = extcap_parse_complex(
 540                         target_arg->arg_type, v->value)) == NULL) {
 541                     printf("invalid default, couldn't parse %s\n", v->value);
 542                 }
 543             }
 544         }
 545
 546     } else if (sent == EXTCAP_SENTENCE_VALUE) {
 547         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ARG))
 548                 == NULL) {
 549             printf("no arg in VALUE sentence\n");
 550             return NULL ;
 551         }
 552
 553         if (sscanf(v->value, "%d", &tint) != 1) {
 554             printf("invalid arg in VALUE sentence\n");
 555             return NULL ;
 556         }
 557
 558         ;
 559         if ((entry = g_list_find_custom(args, &tint, glist_find_numbered_arg))
 560                 == NULL) {
 561             printf("couldn't find arg %d in list for VALUE sentence\n", tint);
 562             return NULL ;
 563         }
 564
 565         value = g_new0(extcap_value, 1);
 566         value->arg_num = tint;
 567
 568         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_VALUE))
 569                 == NULL) {
 570             /* printf("no value in VALUE sentence\n"); */
 571             extcap_free_value(value);
 572             return NULL ;
 573         }
 574         value->call = g_strdup(v->value);
 575
 576         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DISPLAY))
 577                 == NULL) {
 578             /* printf("no display in VALUE sentence\n"); */
 579             extcap_free_value(value);
 580             return NULL ;
 581         }
 582         value->display = g_strdup(v->value);
 583
 584         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_PARENT))
 585                 != NULL) {
 586             value->parent = g_strdup(v->value);
 587         }
 588
 589         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DEFAULT))
 590                 != NULL) {
 591             /* printf("found default value\n"); */
 592             value->is_default = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 593         }
 594
 595         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ENABLED))
 596                 != NULL) {
 597             value->enabled = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 598         }
 599
 600         ((extcap_arg*) entry->data)->values = g_list_append(
 601                 ((extcap_arg*) entry->data)->values, value);
 602
 603         return NULL ;
 604     }
 605
 606     return target_arg;
 607 }
 608
 609 GList * extcap_parse_args(extcap_token_sentence *first_s) {
 610     GList * args = NULL;
 611
 612     while (first_s) {
 613         extcap_arg *ra = NULL;
 614
 615         if ((ra = extcap_parse_arg_sentence(args, first_s)) != NULL)
 616             args = g_list_append(args, (gpointer) ra);
 617
 618         first_s = first_s->next_sentence;
 619     }
 620
 621     return args;
 622 }
 623
 624 int extcap_parse_interface_sentence(extcap_token_sentence *s,
 625         extcap_interface **ri) {
 626     extcap_token_param *v = NULL;
 627     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
 628
 629     *ri = NULL;
 630
 631     if (s == NULL)
 632         return -1;
 633
 634     if (g_ascii_strcasecmp(s->sentence, "interface") == 0) {
 635         sent = EXTCAP_SENTENCE_INTERFACE;
 636     } else if (g_ascii_strcasecmp(s->sentence, "extcap") == 0) {
 637         sent = EXTCAP_SENTENCE_EXTCAP;
 638     }
 639
 640     if (sent == EXTCAP_SENTENCE_UNKNOWN)
 641         return -1;
 642
 643     *ri = extcap_new_interface();
 644
 645     (*ri)->if_type = sent;
 646
 647     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_VALUE))
 648             == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
 649         printf("No value in INTERFACE sentence\n");
 650         extcap_free_interface(*ri);
 651         return -1;
 652     }
 653     if ( v != NULL )
 654        (*ri)->call = g_strdup(v->value);
 655
 656     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DISPLAY))
 657             == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
 658         printf("No display in INTERFACE sentence\n");
 659         extcap_free_interface(*ri);
 660         return -1;
 661     }
 662     if ( v != NULL )
 663         (*ri)->display = g_strdup(v->value);
 664
 665     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_VERSION))
 666             != NULL) {
 667         (*ri)->version = g_strdup(v->value);
 668     }
 669
 670     return 1;
 671 }
 672
 673 int extcap_parse_interfaces(extcap_token_sentence *first_s,
 674         extcap_interface **first_int) {
 675     extcap_interface *first_i = NULL, *last_i = NULL;
 676
 677     while (first_s) {
 678         extcap_interface *ri;
 679
 680         if (extcap_parse_interface_sentence(first_s, &ri) >= 0 && ri != NULL) {
 681             if (first_i == NULL) {
 682                 first_i = last_i = ri;
 683             } else {
 684                 last_i->next_interface = ri;
 685                 last_i = ri;
 686             }
 687         }
 688
 689         first_s = first_s->next_sentence;
 690     }
 691
 692     *first_int = first_i;
 693
 694     return 1;
 695 }
 696
 697 int extcap_parse_dlt_sentence(extcap_token_sentence *s, extcap_dlt **rd) {
 698     extcap_token_param *v = NULL;
 699     extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
 700
 701     *rd = NULL;
 702
 703     if (s == NULL)
 704         return -1;
 705
 706     if (g_ascii_strcasecmp(s->sentence, "dlt") == 0) {
 707         sent = EXTCAP_SENTENCE_DLT;
 708     }
 709
 710     if (sent == EXTCAP_SENTENCE_UNKNOWN)
 711         return -1;
 712
 713     *rd = extcap_new_dlt();
 714
 715     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ARGNUM))
 716             == NULL) {
 717         printf("No number in DLT sentence\n");
 718         extcap_free_dlt(*rd);
 719         return -1;
 720     }
 721     if (sscanf(v->value, "%d", &((*rd)->number)) != 1) {
 722         printf("Invalid number in DLT sentence\n");
 723         extcap_free_dlt(*rd);
 724         return -1;
 725     }
 726
 727     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_NAME))
 728             == NULL) {
 729         printf("No name in DLT sentence\n");
 730         extcap_free_dlt(*rd);
 731         return -1;
 732     }
 733     (*rd)->name = g_strdup(v->value);
 734
 735     if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DISPLAY))
 736             == NULL) {
 737         printf("No display in DLT sentence\n");
 738         extcap_free_dlt(*rd);
 739         return -1;
 740     }
 741     (*rd)->display = g_strdup(v->value);
 742
 743     return 1;
 744 }
 745
 746 int extcap_parse_dlts(extcap_token_sentence *first_s, extcap_dlt **first_dlt) {
 747     extcap_dlt *first_d = NULL, *last_d = NULL;
 748
 749     while (first_s) {
 750         extcap_dlt *rd;
 751
 752         if (extcap_parse_dlt_sentence(first_s, &rd) >= 0 && rd != NULL) {
 753             if (first_d == NULL) {
 754                 first_d = last_d = rd;
 755             } else {
 756                 last_d->next_dlt = rd;
 757                 last_d = rd;
 758             }
 759         }
 760
 761         first_s = first_s->next_sentence;
 762     }
 763
 764     *first_dlt = first_d;
 765
 766     return 1;
 767 }
 768
 769 /*
 770  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 771  *
 772  * Local variables:
 773  * c-basic-offset: 4
 774  * tab-width: 8
 775  * indent-tabs-mode: nil
 776  * End:
 777  *
 778  * vi: set shiftwidth=4 tabstop=8 expandtab:
 779  * :indentSize=4:tabSize=8:noTabs=true:
 780  */