Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1003 insertions, 0 deletions

diff --git a/extcap_parser.c b/extcap_parser.c
new file mode 100644
index 00000000..8a5e56ad
--- /dev/null
+++ b/extcap_parser.c
@@ -0,0 +1,1003 @@
+/* extcap_parser.c
+ *
+ * Routines for extcap external capture
+ * Copyright 2013, Mike Ryan <mikeryan@lacklustre.net>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <config.h>
+#define WS_LOG_DOMAIN LOG_DOMAIN_EXTCAP
+
+#include <stdio.h>
+#include <glib.h>
+#include <string.h>
+
+#include "ui/iface_toolbar.h"
+#include "wsutil/strtoi.h"
+
+#include "extcap.h"
+#include "extcap_parser.h"
+#include "ws_attributes.h"
+
+void extcap_printf_complex(extcap_complex *comp) {
+    gchar *ret = extcap_get_complex_as_string(comp);
+    printf("%s", ret);
+    g_free(ret);
+}
+
+gchar *extcap_get_complex_as_string(extcap_complex *comp) {
+    return (comp ? g_strdup(comp->_val) : NULL);
+}
+
+extcap_complex *extcap_parse_complex(extcap_arg_type complex_type,
+                                     const gchar *data) {
+
+    extcap_complex *rc = g_new0(extcap_complex, 1);
+
+    rc->_val = g_strdup(data);
+    rc->complex_type = complex_type;
+
+    return rc;
+}
+
+gboolean extcap_compare_is_default(extcap_arg *element, extcap_complex *test) {
+    if (element == NULL || element->default_complex == NULL || test == NULL)
+        return FALSE;
+
+    if (g_strcmp0(element->default_complex->_val, test->_val) == 0)
+        return TRUE;
+
+    return FALSE;
+}
+
+void extcap_free_complex(extcap_complex *comp) {
+    if (comp)
+        g_free(comp->_val);
+    g_free(comp);
+}
+
+gint extcap_complex_get_int(extcap_complex *comp) {
+    if (comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_INTEGER)
+        return (gint)0;
+
+    return (gint) g_ascii_strtoll(comp->_val, NULL, 10);
+}
+
+guint extcap_complex_get_uint(extcap_complex *comp) {
+    if (comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_UNSIGNED)
+        return (guint)0;
+    return (guint) g_ascii_strtoull(comp->_val, NULL, 10);
+}
+
+gint64 extcap_complex_get_long(extcap_complex *comp) {
+    if (comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_LONG)
+        return (gint64)0;
+    return g_ascii_strtoll(comp->_val, NULL, 10);
+}
+
+gdouble extcap_complex_get_double(extcap_complex *comp) {
+    if (comp == NULL || comp->_val == NULL || comp->complex_type != EXTCAP_ARG_DOUBLE)
+        return (gdouble)0;
+    return g_strtod(comp->_val, NULL);
+}
+
+static gboolean matches_regex(const char *pattern, const char *subject) {
+    if (!g_utf8_validate(subject, -1, NULL))
+        return FALSE;
+    return g_regex_match_simple(pattern, subject, (GRegexCompileFlags) (G_REGEX_CASELESS), (GRegexMatchFlags)0);
+}
+
+gboolean extcap_complex_get_bool(extcap_complex *comp) {
+    if (comp == NULL || comp->_val == NULL)
+        return FALSE;
+
+    if (comp->complex_type != EXTCAP_ARG_BOOLEAN && comp->complex_type != EXTCAP_ARG_BOOLFLAG)
+        return FALSE;
+
+    return matches_regex(EXTCAP_BOOLEAN_REGEX, comp->_val);
+}
+
+gchar *extcap_complex_get_string(extcap_complex *comp) {
+    /* Not checking for argument type, to use this method as fallback if only strings are needed */
+    return comp != NULL ? comp->_val : NULL;
+}
+
+static extcap_token_sentence *extcap_tokenize_sentence(const gchar *s) {
+    GRegex *regex = NULL;
+    GMatchInfo *match_info = NULL;
+    GError *error = NULL;
+    gchar *param_value = NULL;
+    guint param_type = EXTCAP_PARAM_UNKNOWN;
+
+    if (!g_utf8_validate(s, -1, NULL))
+        return FALSE;
+
+    extcap_token_sentence *rs = g_new0(extcap_token_sentence, 1);
+
+    rs->sentence = NULL;
+
+    /* Regex for catching just the allowed values for sentences */
+    if ((regex = g_regex_new("^[\\t| ]*(arg|value|interface|extcap|dlt|control)(?=[\\t| ]+\\{)",
+                             (GRegexCompileFlags) (G_REGEX_CASELESS),
+                             (GRegexMatchFlags) 0, NULL)) != NULL) {
+        g_regex_match(regex, s, (GRegexMatchFlags) 0, &match_info);
+
+        if (g_match_info_matches(match_info))
+            rs->sentence = g_match_info_fetch(match_info, 0);
+
+        g_match_info_free(match_info);
+        g_regex_unref(regex);
+    }
+    /* No valid sentence found, exiting here */
+    if (rs->sentence == NULL) {
+        g_free(rs);
+        return NULL;
+    }
+
+    rs->param_list = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
+
+    /* Capture the argument and the value of the list. This will ensure,
+     * that regex patterns given to {validation=} are parsed correctly,
+     * as long as }{ does not occur within the pattern */
+    regex = g_regex_new("\\{([a-zA-Z_-]*?)\\=(.*?)\\}(?=\\{|$|\\s)",
+                        (GRegexCompileFlags) (G_REGEX_CASELESS),
+                        (GRegexMatchFlags) 0, NULL);
+    if (regex != NULL) {
+        g_regex_match_full(regex, s, -1, 0, (GRegexMatchFlags) 0, &match_info, &error);
+        while (g_match_info_matches(match_info)) {
+            gchar *arg = g_match_info_fetch(match_info, 1);
+
+            if (arg == NULL)
+                break;
+
+            param_value = g_match_info_fetch(match_info, 2);
+
+            if (g_ascii_strcasecmp(arg, "number") == 0) {
+                param_type = EXTCAP_PARAM_ARGNUM;
+            } else if (g_ascii_strcasecmp(arg, "call") == 0) {
+                param_type = EXTCAP_PARAM_CALL;
+            } else if (g_ascii_strcasecmp(arg, "display") == 0) {
+                param_type = EXTCAP_PARAM_DISPLAY;
+            } else if (g_ascii_strcasecmp(arg, "type") == 0) {
+                param_type = EXTCAP_PARAM_TYPE;
+            } else if (g_ascii_strcasecmp(arg, "arg") == 0) {
+                param_type = EXTCAP_PARAM_ARG;
+            } else if (g_ascii_strcasecmp(arg, "default") == 0) {
+                param_type = EXTCAP_PARAM_DEFAULT;
+            } else if (g_ascii_strcasecmp(arg, "value") == 0) {
+                param_type = EXTCAP_PARAM_VALUE;
+            } else if (g_ascii_strcasecmp(arg, "range") == 0) {
+                param_type = EXTCAP_PARAM_RANGE;
+            } else if (g_ascii_strcasecmp(arg, "tooltip") == 0) {
+                param_type = EXTCAP_PARAM_TOOLTIP;
+            } else if (g_ascii_strcasecmp(arg, "placeholder") == 0) {
+                param_type = EXTCAP_PARAM_PLACEHOLDER;
+            } else if (g_ascii_strcasecmp(arg, "mustexist") == 0) {
+                param_type = EXTCAP_PARAM_FILE_MUSTEXIST;
+            } else if (g_ascii_strcasecmp(arg, "fileext") == 0) {
+                param_type = EXTCAP_PARAM_FILE_EXTENSION;
+            } else if (g_ascii_strcasecmp(arg, "group") == 0) {
+                param_type = EXTCAP_PARAM_GROUP;
+            } else if (g_ascii_strcasecmp(arg, "name") == 0) {
+                param_type = EXTCAP_PARAM_NAME;
+            } else if (g_ascii_strcasecmp(arg, "enabled") == 0) {
+                param_type = EXTCAP_PARAM_ENABLED;
+            } else if (g_ascii_strcasecmp(arg, "parent") == 0) {
+                param_type = EXTCAP_PARAM_PARENT;
+            } else if (g_ascii_strcasecmp(arg, "reload") == 0) {
+                param_type = EXTCAP_PARAM_RELOAD;
+            } else if (g_ascii_strcasecmp(arg, "required") == 0) {
+                param_type = EXTCAP_PARAM_REQUIRED;
+            } else if (g_ascii_strcasecmp(arg, "save") == 0) {
+                param_type = EXTCAP_PARAM_SAVE;
+            } else if (g_ascii_strcasecmp(arg, "validation") == 0) {
+                param_type = EXTCAP_PARAM_VALIDATION;
+            } else if (g_ascii_strcasecmp(arg, "version") == 0) {
+                param_type = EXTCAP_PARAM_VERSION;
+            } else if (g_ascii_strcasecmp(arg, "help") == 0) {
+                param_type = EXTCAP_PARAM_HELP;
+            } else if (g_ascii_strcasecmp(arg, "control") == 0) {
+                param_type = EXTCAP_PARAM_CONTROL;
+            } else if (g_ascii_strcasecmp(arg, "role") == 0) {
+                param_type = EXTCAP_PARAM_ROLE;
+            } else {
+                param_type = EXTCAP_PARAM_UNKNOWN;
+            }
+
+            g_hash_table_insert(rs->param_list, ENUM_KEY(param_type), param_value);
+
+            g_match_info_next(match_info, &error);
+            g_free(arg);
+        }
+        g_match_info_free(match_info);
+        g_regex_unref(regex);
+    }
+
+    return rs;
+}
+
+static GList *extcap_tokenize_sentences(const gchar *s) {
+
+    GList *sentences = NULL;
+    extcap_token_sentence *item = NULL;
+    gchar **list, **list_iter;
+
+    list_iter = list = g_strsplit(s, "\n", 0);
+    while (*list_iter != NULL) {
+        item = extcap_tokenize_sentence(*list_iter);
+        if (item)
+            sentences = g_list_append(sentences, item);
+        list_iter++;
+    }
+
+    g_strfreev(list);
+
+    return sentences;
+}
+
+static void extcap_free_value(extcap_value *v) {
+    if (v == NULL)
+        return;
+
+    g_free(v->call);
+    g_free(v->display);
+    g_free(v->parent);
+
+    g_free(v);
+}
+
+static void extcap_free_valuelist(gpointer data, gpointer user_data _U_) {
+    extcap_free_value((extcap_value *) data);
+}
+
+void extcap_free_arg(extcap_arg *a) {
+
+    if (a == NULL)
+        return;
+
+    g_free(a->call);
+    g_free(a->display);
+    g_free(a->tooltip);
+    g_free(a->placeholder);
+    g_free(a->fileextension);
+    g_free(a->regexp);
+    g_free(a->group);
+    g_free(a->device_name);
+
+    if (a->range_start != NULL)
+        extcap_free_complex(a->range_start);
+
+    if (a->range_end != NULL)
+        extcap_free_complex(a->range_end);
+
+    if (a->default_complex != NULL)
+        extcap_free_complex(a->default_complex);
+
+    g_list_foreach(a->values, (GFunc) extcap_free_valuelist, NULL);
+    g_list_free(a->values);
+    g_free(a);
+}
+
+static void extcap_free_toolbar_value(iface_toolbar_value *value)
+{
+    if (value == NULL)
+    {
+        return;
+    }
+
+    g_free(value->value);
+    g_free(value->display);
+    g_free(value);
+}
+
+void extcap_free_toolbar_control(iface_toolbar_control *control)
+{
+    if (control == NULL)
+    {
+        return;
+    }
+
+    g_free(control->display);
+    g_free(control->validation);
+    g_free(control->tooltip);
+    g_free(control->placeholder);
+    if (control->ctrl_type == INTERFACE_TYPE_STRING) {
+        g_free(control->default_value.string);
+    }
+    g_list_free_full(control->values, (GDestroyNotify)extcap_free_toolbar_value);
+    g_free(control);
+}
+
+void extcap_free_arg_list(GList *a) {
+    g_list_free_full(a, (GDestroyNotify)extcap_free_arg);
+}
+
+static gint glist_find_numbered_arg(gconstpointer listelem, gconstpointer needle) {
+    if (((const extcap_arg *) listelem)->arg_num == *((const int *) needle))
+        return 0;
+    return 1;
+}
+
+static gint glist_find_numbered_control(gconstpointer listelem, gconstpointer needle) {
+    if (((const iface_toolbar_control *) listelem)->num == *((const int *) needle))
+        return 0;
+    return 1;
+}
+
+static void extcap_free_tokenized_sentence(gpointer s, gpointer user_data _U_) {
+    extcap_token_sentence *t = (extcap_token_sentence *)s;
+
+    if (t == NULL)
+        return;
+
+    g_free(t->sentence);
+    g_hash_table_destroy(t->param_list);
+    g_free(t);
+}
+
+static void extcap_free_tokenized_sentences(GList *sentences) {
+    if (sentences == NULL)
+        return;
+
+    g_list_foreach(sentences, extcap_free_tokenized_sentence, NULL);
+    g_list_free(sentences);
+}
+
+static extcap_value *extcap_parse_value_sentence(extcap_token_sentence *s) {
+    extcap_value *value = NULL;
+    gchar *param_value = NULL;
+
+    int tint = 0;
+
+    if (s == NULL)
+        return value;
+
+    if (g_ascii_strcasecmp(s->sentence, "value") == 0) {
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARG)))
+                == NULL) {
+            printf("no arg in VALUE sentence\n");
+            return NULL;
+        }
+
+        if (sscanf(param_value, "%d", &tint) != 1) {
+            printf("invalid arg in VALUE sentence\n");
+            return NULL;
+        }
+
+        value = g_new0(extcap_value, 1);
+        value->arg_num = tint;
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALUE)))
+                == NULL) {
+            /* printf("no value in VALUE sentence\n"); */
+            extcap_free_value(value);
+            return NULL;
+        }
+        value->call = g_strdup(param_value);
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
+                == NULL) {
+            /* printf("no display in VALUE sentence\n"); */
+            extcap_free_value(value);
+            return NULL;
+        }
+        value->display = g_strdup(param_value);
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_PARENT)))
+                != NULL) {
+            value->parent = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT)))
+                != NULL) {
+            /* printf("found default value\n"); */
+            value->is_default = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ENABLED)))
+                != NULL) {
+            value->enabled = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+    }
+
+    return value;
+}
+
+static extcap_arg *extcap_parse_arg_sentence(GList *args, extcap_token_sentence *s) {
+    gchar *param_value = NULL;
+
+    extcap_arg *target_arg = NULL;
+    extcap_value *value = NULL;
+    GList *entry = NULL;
+
+    extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
+
+    if (s == NULL)
+        return target_arg;
+
+    if (g_ascii_strcasecmp(s->sentence, "arg") == 0) {
+        sent = EXTCAP_SENTENCE_ARG;
+        /* printf("ARG sentence\n"); */
+    } else if (g_ascii_strcasecmp(s->sentence, "value") == 0) {
+        sent = EXTCAP_SENTENCE_VALUE;
+        /* printf("VALUE sentence\n"); */
+    }
+
+    if (sent == EXTCAP_SENTENCE_ARG) {
+        target_arg = g_new0(extcap_arg, 1);
+        target_arg->arg_type = EXTCAP_ARG_UNKNOWN;
+        target_arg->save = TRUE;
+
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARGNUM))) == NULL) {
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+
+        if (sscanf(param_value, "%d", &(target_arg->arg_num)) != 1) {
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_CALL))) == NULL) {
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+        target_arg->call = g_strdup(param_value);
+
+        /* No value only parameters allowed */
+        if (strlen(target_arg->call) == 0) {
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY))) == NULL) {
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+        target_arg->display = g_strdup(param_value);
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TOOLTIP)))
+                != NULL) {
+            target_arg->tooltip = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_PLACEHOLDER)))
+                != NULL) {
+            target_arg->placeholder = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_FILE_MUSTEXIST)))
+                != NULL) {
+            target_arg->fileexists = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_FILE_EXTENSION)))
+                != NULL) {
+            target_arg->fileextension = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALIDATION)))
+                != NULL) {
+            target_arg->regexp = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_GROUP)))
+                != NULL) {
+            target_arg->group = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_REQUIRED)))
+                != NULL) {
+            target_arg->is_required = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TYPE)))
+                == NULL) {
+            /* printf("no type in ARG sentence\n"); */
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+
+        if (g_ascii_strcasecmp(param_value, "integer") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_INTEGER;
+        } else if (g_ascii_strcasecmp(param_value, "unsigned") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_UNSIGNED;
+        } else if (g_ascii_strcasecmp(param_value, "long") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_LONG;
+        } else if (g_ascii_strcasecmp(param_value, "double") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_DOUBLE;
+        } else if (g_ascii_strcasecmp(param_value, "boolean") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_BOOLEAN;
+        } else if (g_ascii_strcasecmp(param_value, "boolflag") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_BOOLFLAG;
+        } else if (g_ascii_strcasecmp(param_value, "selector") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_SELECTOR;
+        } else if (g_ascii_strcasecmp(param_value, "editselector") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_EDIT_SELECTOR;
+        } else if (g_ascii_strcasecmp(param_value, "radio") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_RADIO;
+        } else if (g_ascii_strcasecmp(param_value, "string") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_STRING;
+        } else if (g_ascii_strcasecmp(param_value, "password") == 0) {
+            /* Password is never saved because is mapped to PREF_PASSWORD later */
+            target_arg->arg_type = EXTCAP_ARG_PASSWORD;
+        } else if (g_ascii_strcasecmp(param_value, "fileselect") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_FILESELECT;
+        } else if (g_ascii_strcasecmp(param_value, "multicheck") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_MULTICHECK;
+        } else if (g_ascii_strcasecmp(param_value, "timestamp") == 0) {
+            target_arg->arg_type = EXTCAP_ARG_TIMESTAMP;
+        } else {
+            printf("invalid type %s in ARG sentence\n", param_value);
+            extcap_free_arg(target_arg);
+            return NULL;
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_SAVE)))
+                != NULL) {
+            target_arg->save = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_RELOAD)))
+                != NULL) {
+            target_arg->reload = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_RANGE)))
+                != NULL) {
+            gchar *cp = g_strstr_len(param_value, -1, ",");
+
+            if (cp == NULL) {
+                printf("invalid range, expected value,value got %s\n",
+                       param_value);
+                extcap_free_arg(target_arg);
+                return NULL;
+            }
+
+            if ((target_arg->range_start = extcap_parse_complex(
+                                               target_arg->arg_type, param_value)) == NULL) {
+                printf("invalid range, expected value,value got %s\n",
+                       param_value);
+                extcap_free_arg(target_arg);
+                return NULL;
+            }
+
+            if ((target_arg->range_end = extcap_parse_complex(
+                                             target_arg->arg_type, cp + 1)) == NULL) {
+                printf("invalid range, expected value,value got %s\n",
+                       param_value);
+                extcap_free_arg(target_arg);
+                return NULL;
+            }
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT)))
+                != NULL) {
+            if (target_arg->arg_type != EXTCAP_ARG_MULTICHECK && target_arg->arg_type != EXTCAP_ARG_SELECTOR)
+            {
+                if ((target_arg->default_complex = extcap_parse_complex(
+                                                       target_arg->arg_type, param_value)) == NULL) {
+                    printf("invalid default, couldn't parse %s\n", param_value);
+                }
+            }
+        }
+
+    } else if (sent == EXTCAP_SENTENCE_VALUE) {
+        value = extcap_parse_value_sentence(s);
+        if (value == NULL)
+            return NULL;
+
+        if ((entry = g_list_find_custom(args, &value->arg_num, glist_find_numbered_arg))
+                == NULL) {
+            printf("couldn't find arg %d in list for VALUE sentence\n", value->arg_num);
+            return NULL;
+        }
+
+        ((extcap_arg *) entry->data)->values = g_list_append(
+                ((extcap_arg *) entry->data)->values, value);
+
+        return NULL;
+    }
+
+    return target_arg;
+}
+
+GList *extcap_parse_args(gchar *output) {
+    GList *result = NULL;
+    GList *walker = NULL;
+    GList *temp = NULL;
+
+    walker = extcap_tokenize_sentences(output);
+    temp = walker;
+
+    while (walker) {
+        extcap_arg *ra = NULL;
+        extcap_token_sentence *sentence = (extcap_token_sentence *)walker->data;
+
+        if ((ra = extcap_parse_arg_sentence(result, sentence)) != NULL)
+            result = g_list_append(result, (gpointer) ra);
+
+        walker = g_list_next(walker);
+    }
+
+    extcap_free_tokenized_sentences(temp);
+
+    return result;
+}
+
+GList *extcap_parse_values(gchar *output) {
+    GList *result = NULL;
+    GList *walker = NULL;
+    GList *temp = NULL;
+
+    walker = extcap_tokenize_sentences(output);
+    temp = walker;
+
+    while (walker) {
+        extcap_value *ra = NULL;
+        extcap_token_sentence *sentence = (extcap_token_sentence *)walker->data;
+
+        if ((ra = extcap_parse_value_sentence(sentence)) != NULL)
+            result = g_list_append(result, (gpointer) ra);
+
+        walker = g_list_next(walker);
+    }
+
+    extcap_free_tokenized_sentences(temp);
+
+    return result;
+}
+
+static extcap_interface *extcap_parse_interface_sentence(extcap_token_sentence *s) {
+    extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
+    gchar *param_value = NULL;
+    extcap_interface *ri = NULL;
+
+    if (s == NULL)
+        return NULL;
+
+    if (g_ascii_strcasecmp(s->sentence, "interface") == 0) {
+        sent = EXTCAP_SENTENCE_INTERFACE;
+    } else if (g_ascii_strcasecmp(s->sentence, "extcap") == 0) {
+        sent = EXTCAP_SENTENCE_EXTCAP;
+    }
+
+    if (sent == EXTCAP_SENTENCE_UNKNOWN)
+        return NULL;
+
+    ri = g_new0(extcap_interface, 1);
+
+    ri->if_type = sent;
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALUE)))
+            == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
+        printf("No value in INTERFACE sentence\n");
+        g_free(ri);
+        return NULL;
+    }
+    ri->call = g_strdup(param_value);
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
+            == NULL && sent == EXTCAP_SENTENCE_INTERFACE) {
+        printf("No display in INTERFACE sentence\n");
+        g_free(ri->call);
+        g_free(ri);
+        return NULL;
+    }
+    ri->display = g_strdup(param_value);
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VERSION)))
+            != NULL) {
+        ri->version = g_strdup(param_value);
+    }
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_HELP)))
+            != NULL) {
+        ri->help = g_strdup(param_value);
+    }
+
+    return ri;
+}
+
+static iface_toolbar_control *extcap_parse_control_sentence(GList *control_items, extcap_token_sentence *s)
+{
+    extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
+    gchar *param_value = NULL;
+    iface_toolbar_control *control = NULL;
+    iface_toolbar_value *value = NULL;
+    GList *entry = NULL;
+    guint32 num = 0;
+
+    if (s == NULL)
+        return NULL;
+
+    if (g_ascii_strcasecmp(s->sentence, "control") == 0) {
+        sent = EXTCAP_SENTENCE_CONTROL;
+    } else if (g_ascii_strcasecmp(s->sentence, "value") == 0) {
+        sent = EXTCAP_SENTENCE_VALUE;
+    }
+
+    if (sent == EXTCAP_SENTENCE_UNKNOWN)
+        return NULL;
+
+    if (sent == EXTCAP_SENTENCE_CONTROL) {
+        control = g_new0(iface_toolbar_control, 1);
+        control->ctrl_type = INTERFACE_TYPE_UNKNOWN;
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARGNUM));
+        if (param_value == NULL) {
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+
+        if (!ws_strtou32(param_value, NULL, &num)) {
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+        control->num = (int)num;
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY));
+        if (param_value == NULL) {
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+        control->display = g_strdup(param_value);
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALIDATION)))
+            != NULL) {
+            control->validation = g_strdup(param_value);
+        }
+
+        if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_REQUIRED)))
+            != NULL) {
+            control->is_required = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TOOLTIP));
+        control->tooltip = g_strdup(param_value);
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_PLACEHOLDER));
+        control->placeholder = g_strdup(param_value);
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_TYPE));
+        if (param_value == NULL) {
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+
+        extcap_arg_type arg_type = EXTCAP_ARG_UNKNOWN;
+        if (g_ascii_strcasecmp(param_value, "boolean") == 0) {
+            control->ctrl_type = INTERFACE_TYPE_BOOLEAN;
+            arg_type = EXTCAP_ARG_BOOLEAN;
+        } else if (g_ascii_strcasecmp(param_value, "button") == 0) {
+            control->ctrl_type = INTERFACE_TYPE_BUTTON;
+        } else if (g_ascii_strcasecmp(param_value, "selector") == 0) {
+            control->ctrl_type = INTERFACE_TYPE_SELECTOR;
+        } else if (g_ascii_strcasecmp(param_value, "string") == 0) {
+            control->ctrl_type = INTERFACE_TYPE_STRING;
+            arg_type = EXTCAP_ARG_STRING;
+        } else {
+            printf("invalid type %s in CONTROL sentence\n", param_value);
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ROLE));
+        if (param_value != NULL) {
+            if (g_ascii_strcasecmp(param_value, "control") == 0) {
+                control->ctrl_role = INTERFACE_ROLE_CONTROL;
+            } else if (g_ascii_strcasecmp(param_value, "help") == 0) {
+                control->ctrl_role = INTERFACE_ROLE_HELP;
+            } else if (g_ascii_strcasecmp(param_value, "logger") == 0) {
+                control->ctrl_role = INTERFACE_ROLE_LOGGER;
+            } else if (g_ascii_strcasecmp(param_value, "restore") == 0) {
+                control->ctrl_role = INTERFACE_ROLE_RESTORE;
+            } else {
+                printf("invalid role %s in CONTROL sentence\n", param_value);
+                control->ctrl_role = INTERFACE_ROLE_UNKNOWN;
+            }
+        } else {
+            /* Default role */
+            control->ctrl_role = INTERFACE_ROLE_CONTROL;
+        }
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT));
+        if (param_value != NULL) {
+            if (arg_type != EXTCAP_ARG_UNKNOWN) {
+                extcap_complex *complex = extcap_parse_complex(arg_type, param_value);
+                if (complex != NULL) {
+                    if (arg_type == EXTCAP_ARG_BOOLEAN) {
+                        control->default_value.boolean = extcap_complex_get_bool(complex);
+                    } else if (arg_type == EXTCAP_ARG_STRING) {
+                        control->default_value.string = g_strdup(complex->_val);
+                    }
+                    extcap_free_complex(complex);
+                } else {
+                    printf("invalid default, couldn't parse %s\n", param_value);
+                }
+            }
+        }
+
+    } else if (sent == EXTCAP_SENTENCE_VALUE) {
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_CONTROL));
+        if (param_value == NULL) {
+            printf("no control in VALUE sentence\n");
+            return NULL;
+        }
+
+        if (!ws_strtou32(param_value, NULL, &num)) {
+            extcap_free_toolbar_control(control);
+            return NULL;
+        }
+
+        entry = g_list_find_custom(control_items, &num, glist_find_numbered_control);
+        if (entry == NULL) {
+            printf("couldn't find control %u in list for VALUE sentence\n", num);
+            return NULL;
+        }
+
+        value = g_new0(iface_toolbar_value, 1);
+        value->num = (int)num;
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_VALUE));
+        if (param_value == NULL) {
+            extcap_free_toolbar_value(value);
+            return NULL;
+        }
+        value->value = g_strdup(param_value);
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY));
+        if (param_value == NULL) {
+            extcap_free_toolbar_value(value);
+            return NULL;
+        }
+        value->display = g_strdup(param_value);
+
+        param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DEFAULT));
+        if (param_value != NULL) {
+            value->is_default = matches_regex(EXTCAP_BOOLEAN_REGEX, param_value);
+        }
+
+        control = (iface_toolbar_control *)entry->data;
+        control->values = g_list_append(control->values, value);
+
+        return NULL;
+    }
+
+    return control;
+}
+
+GList *extcap_parse_interfaces(gchar *output, GList **control_items) {
+
+    GList *result = NULL;
+    GList *tokens = NULL;
+    GList *walker = extcap_tokenize_sentences(output);
+    tokens = walker;
+
+    while (walker) {
+        extcap_interface *ri = NULL;
+        iface_toolbar_control *ti = NULL;
+        extcap_token_sentence *if_sentence = (extcap_token_sentence *) walker->data;
+
+        if (if_sentence) {
+            if ((g_ascii_strcasecmp(if_sentence->sentence, "interface") == 0) ||
+                (g_ascii_strcasecmp(if_sentence->sentence, "extcap") == 0))
+            {
+                if ((ri = extcap_parse_interface_sentence(if_sentence))) {
+                    result = g_list_append(result, ri);
+                }
+            } else if (control_items &&
+                       ((g_ascii_strcasecmp(if_sentence->sentence, "control") == 0) ||
+                        (g_ascii_strcasecmp(if_sentence->sentence, "value") == 0)))
+            {
+                if ((ti = extcap_parse_control_sentence(*control_items, if_sentence))) {
+                    *control_items = g_list_append(*control_items, ti);
+                }
+            }
+        }
+
+        walker = g_list_next(walker);
+    }
+
+    extcap_free_tokenized_sentences(tokens);
+
+    return result;
+}
+
+/* Parse a tokenized set of sentences and validate, looking for DLT definitions */
+static extcap_dlt *extcap_parse_dlt_sentence(extcap_token_sentence *s) {
+    gchar *param_value = NULL;
+    extcap_sentence_type sent = EXTCAP_SENTENCE_UNKNOWN;
+    extcap_dlt *result = NULL;
+
+    if (s == NULL)
+        return result;
+
+    if (g_ascii_strcasecmp(s->sentence, "dlt") == 0) {
+        sent = EXTCAP_SENTENCE_DLT;
+    }
+
+    if (sent == EXTCAP_SENTENCE_UNKNOWN)
+        return result;
+
+    result = g_new0(extcap_dlt, 1);
+
+    result->number = -1;
+    result->name = NULL;
+    result->display = NULL;
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_ARGNUM)))
+            == NULL) {
+        printf("No number in DLT sentence\n");
+        g_free(result);
+        return NULL;
+    }
+    if (sscanf(param_value, "%d", &(result->number)) != 1) {
+        printf("Invalid number in DLT sentence\n");
+        g_free(result);
+        return NULL;
+    }
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_NAME)))
+            == NULL) {
+        printf("No name in DLT sentence\n");
+        g_free(result);
+        return NULL;
+    }
+    result->name = g_strdup(param_value);
+
+    if ((param_value = (gchar *)g_hash_table_lookup(s->param_list, ENUM_KEY(EXTCAP_PARAM_DISPLAY)))
+            == NULL) {
+        printf("No display in DLT sentence\n");
+        g_free(result->name);
+        g_free(result);
+        return NULL;
+    }
+    result->display = g_strdup(param_value);
+
+    return result;
+}
+
+GList *extcap_parse_dlts(gchar *output) {
+
+    GList *walker = NULL;
+    GList *temp = NULL;
+    GList *result = NULL;
+
+    walker = extcap_tokenize_sentences(output);
+
+    temp = walker;
+
+    while (walker) {
+        extcap_dlt *data = NULL;
+
+        if ((data = extcap_parse_dlt_sentence((extcap_token_sentence *)walker->data)) != NULL)
+            result = g_list_append(result, data);
+
+        walker = g_list_next(walker);
+    }
+
+    extcap_free_tokenized_sentences(temp);
+
+    return result;
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */