extcap: Cleanup complex types and add save option

Cleanup handling of complex data types and use only
glib defined datatypes while handling argument values.

Add a save parameter, which (additionally) can set, that
a parameter is not saved in a configuration file. Passwords
are by default not saved, which may be overwritten using
this parameter

Change-Id: I67eff0f3286170f082d532e806a39511c40df647
Reviewed-on: https://code.wireshark.org/review/13573
Petri-Dish: Roland Knall <rknall@gmail.com>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Dario Lombardo <lomato@gmail.com>
Reviewed-by: Roland Knall <rknall@gmail.com>

1 files changed, 62 insertions, 202 deletions

diff --git a/extcap_parser.c b/extcap_parser.c
index a562ada52c..37c0e70728 100644
--- a/extcap_parser.c
+++ b/extcap_parser.c
@@ -28,6 +28,7 @@
 #include <glib.h>
 #include <string.h>
 
+#include "extcap.h"
 #include "extcap_parser.h"
 
 void extcap_printf_complex(extcap_complex *comp) {
@@ -37,210 +38,82 @@ void extcap_printf_complex(extcap_complex *comp) {
 }
 
 gchar *extcap_get_complex_as_string(extcap_complex *comp) {
-    /* Pick an arbitrary size that should be big enough */
-    gchar *ret = g_new(gchar, 32);
-
-    if (comp == NULL) {
-        g_snprintf(ret, 32, "(null)");
-        return ret;
-    }
-
-    switch (comp->complex_type) {
-    case EXTCAP_ARG_INTEGER:
-        g_snprintf(ret, 32, "%d", comp->complex_value.int_value);
-        break;
-    case EXTCAP_ARG_UNSIGNED:
-        g_snprintf(ret, 32, "%u", comp->complex_value.uint_value);
-        break;
-    case EXTCAP_ARG_LONG:
-        g_snprintf(ret, 32, "%ld", comp->complex_value.long_value);
-        break;
-    case EXTCAP_ARG_DOUBLE:
-        g_snprintf(ret, 32, "%f", comp->complex_value.double_value);
-        break;
-    case EXTCAP_ARG_BOOLEAN:
-        g_snprintf(ret, 32, "%s",
-                comp->complex_value.bool_value ? "true" : "false");
-        break;
-    case EXTCAP_ARG_STRING:
-    case EXTCAP_ARG_PASSWORD:
-    case EXTCAP_ARG_FILESELECT:
-        g_free(ret);
-        ret = g_strdup(comp->complex_value.string_value);
-        break;
-    default:
-        /* Nulling out the return string */
-        g_snprintf(ret, 32, " ");
-        break;
-    }
-
-    return ret;
+    return (comp ? g_strdup(comp->_val) : NULL);
 }
 
 extcap_complex *extcap_parse_complex(extcap_arg_type complex_type,
         const gchar *data) {
-    extcap_complex *rc = g_new(extcap_complex, 1);
-    gboolean success = FALSE;
-    long double exp_f;
-
-    switch (complex_type) {
-    case EXTCAP_ARG_INTEGER:
-        if (sscanf(data, "%Lf", &exp_f) == 1) {
-            rc->complex_value.int_value = (int) exp_f;
-            success = TRUE;
-            break;
-        }
-        break;
-    case EXTCAP_ARG_UNSIGNED:
-        if (sscanf(data, "%Lf", &exp_f) == 1) {
-            rc->complex_value.uint_value = (unsigned int) exp_f;
-            success = TRUE;
-            break;
-        }
-        break;
-    case EXTCAP_ARG_LONG:
-        if (sscanf(data, "%Lf", &exp_f) == 1) {
-            rc->complex_value.long_value = (long) exp_f;
-            success = TRUE;
-            break;
-        }
-        break;
-    case EXTCAP_ARG_DOUBLE:
-        if (sscanf(data, "%Lf", &exp_f) == 1) {
-            rc->complex_value.double_value = (double) exp_f;
-            success = TRUE;
-            break;
-        }
-        break;
-    case EXTCAP_ARG_BOOLEAN:
-    case EXTCAP_ARG_BOOLFLAG:
-        if (data[0] == 't' || data[0] == 'T' || data[0] == '1') {
-            rc->complex_value.bool_value = 1;
-        } else {
-            rc->complex_value.bool_value = 0;
-        }
-        success = TRUE;
-        break;
-    case EXTCAP_ARG_STRING:
-    case EXTCAP_ARG_PASSWORD:
-    case EXTCAP_ARG_FILESELECT:
-        rc->complex_value.string_value = g_strdup(data);
-        success = TRUE;
-        break;
-    default:
-        break;
-    }
 
-    if (!success) {
-        g_free(rc);
-        return NULL ;
-    }
+    extcap_complex *rc = g_new0(extcap_complex, 1);
 
+    rc->_val = g_strdup( (gchar *) data);
     rc->complex_type = complex_type;
-    rc->value_filled = TRUE;
 
     return rc;
 }
 
 gboolean extcap_compare_is_default(extcap_arg *element, extcap_complex *test) {
-    gboolean result = FALSE;
-
-    if (element->default_complex == NULL)
-        return result;
-
-    switch (element->arg_type) {
-    case EXTCAP_ARG_INTEGER:
-        if (extcap_complex_get_int(test)
-                == extcap_complex_get_int(element->default_complex))
-            result = TRUE;
-        break;
-    case EXTCAP_ARG_UNSIGNED:
-        if (extcap_complex_get_uint(test)
-                == extcap_complex_get_uint(element->default_complex))
-            result = TRUE;
-        break;
-    case EXTCAP_ARG_LONG:
-        if (extcap_complex_get_long(test)
-                == extcap_complex_get_long(element->default_complex))
-            result = TRUE;
-        break;
-    case EXTCAP_ARG_DOUBLE:
-        if (extcap_complex_get_double(test)
-                == extcap_complex_get_double(element->default_complex))
-            result = TRUE;
-        break;
-    case EXTCAP_ARG_BOOLEAN:
-    case EXTCAP_ARG_BOOLFLAG:
-        if (extcap_complex_get_bool(test)
-                == extcap_complex_get_bool(element->default_complex))
-            result = TRUE;
-        break;
-    case EXTCAP_ARG_STRING:
-    case EXTCAP_ARG_PASSWORD:
-        if (strcmp(extcap_complex_get_string(test),
-                extcap_complex_get_string(element->default_complex)) == 0)
-            result = TRUE;
-        break;
-
-    default:
-        break;
-    }
+    if ( element == NULL || element->default_complex == NULL || test == NULL )
+        return FALSE;
+
+    if ( g_strcmp0(element->default_complex->_val, test->_val) == 0 )
+        return TRUE;
 
-    return result;
+    return FALSE;
 }
 
 void extcap_free_complex(extcap_complex *comp) {
-    if (comp->complex_type == EXTCAP_ARG_STRING
-            || comp->complex_type == EXTCAP_ARG_PASSWORD
-            || comp->complex_type == EXTCAP_ARG_FILESELECT)
-        g_free(comp->complex_value.string_value);
-
+    if ( comp )
+        g_free(comp->_val);
     g_free(comp);
 }
 
-int extcap_complex_get_int(extcap_complex *comp) {
-    if ( comp == NULL )
-        return (int)0;
-    return comp->complex_value.int_value;
+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);
 }
 
-unsigned int extcap_complex_get_uint(extcap_complex *comp) {
-    if ( comp == NULL )
-        return (unsigned int)0;
-    return comp->complex_value.uint_value;
+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);
 }
 
-long extcap_complex_get_long(extcap_complex *comp) {
-    if ( comp == NULL )
-        return (long)0;
-    return comp->complex_value.long_value;
+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 );
 }
 
-double extcap_complex_get_double(extcap_complex *comp) {
-    if ( comp == NULL )
-        return (double)0;
-    return comp->complex_value.double_value;
+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 );
 }
 
 gboolean extcap_complex_get_bool(extcap_complex *comp) {
-    if ( comp == NULL )
+    if ( comp == NULL || comp->_val == NULL  )
         return FALSE;
-    return comp->complex_value.bool_value;
+
+    if ( comp->complex_type != EXTCAP_ARG_BOOLEAN && comp->complex_type != EXTCAP_ARG_BOOLFLAG )
+        return FALSE;
+
+    return g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, comp->_val, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
 }
 
 gchar *extcap_complex_get_string(extcap_complex *comp) {
-    return comp->complex_value.string_value;
+    /* Not checking for argument type, to use this method as fallback if only strings are needed */
+    return comp != NULL ? comp->_val : NULL;
 }
 
 void extcap_free_tokenized_param(extcap_token_param *v) {
-    if (v == NULL)
-        return;
-
-    if (v->arg != NULL)
+    if (v != NULL)
+    {
         g_free(v->arg);
-
-    if (v->value != NULL)
         g_free(v->value);
+    }
 
     g_free(v);
 }
@@ -349,6 +222,8 @@ extcap_token_sentence *extcap_tokenize_sentence(const gchar *s) {
                 tv->param_type = EXTCAP_PARAM_PARENT;
             } else if (g_ascii_strcasecmp(tv->arg, "required") == 0) {
                 tv->param_type = EXTCAP_PARAM_REQUIRED;
+            } else if (g_ascii_strcasecmp(tv->arg, "save") == 0) {
+                tv->param_type = EXTCAP_PARAM_SAVE;
             } else if (g_ascii_strcasecmp(tv->arg, "validation") == 0) {
                 tv->param_type = EXTCAP_PARAM_VALIDATION;
             } else if (g_ascii_strcasecmp(tv->arg, "version") == 0) {
@@ -464,27 +339,6 @@ void extcap_free_dlt(extcap_dlt *d) {
     g_free(d->display);
 }
 
-extcap_arg *extcap_new_arg(void) {
-    extcap_arg *r = g_new(extcap_arg, 1);
-
-    r->call = NULL;
-    r->display = NULL;
-    r->tooltip = NULL;
-    r->arg_type = EXTCAP_ARG_UNKNOWN;
-    r->range_start = NULL;
-    r->range_end = NULL;
-    r->default_complex = NULL;
-    r->fileexists = FALSE;
-    r->fileextension = NULL;
-    r->regexp = NULL;
-    r->is_required = FALSE;
-
-    r->values = NULL;
-    /*r->next_arg = NULL; */
-
-    return r;
-}
-
 static void extcap_free_valuelist(gpointer data, gpointer user_data _U_) {
     extcap_free_value((extcap_value *) data);
 }
@@ -548,7 +402,8 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
     }
 
     if (sent == EXTCAP_SENTENCE_ARG) {
-        target_arg = extcap_new_arg();
+        target_arg = g_new0(extcap_arg, 1);
+        target_arg->arg_type = EXTCAP_ARG_UNKNOWN;
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ARGNUM))
                 == NULL) {
@@ -588,7 +443,7 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_FILE_MUSTEXIST))
                 != NULL) {
-            target_arg->fileexists = (v->value[0] == 't' || v->value[0] == 'T');
+            target_arg->fileexists = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
         }
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_FILE_EXTENSION))
@@ -603,7 +458,7 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_REQUIRED))
                 != NULL) {
-            target_arg->is_required = (v->value[0] == 't' || v->value[0] == 'T');
+            target_arg->is_required = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
         }
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_TYPE))
@@ -633,6 +488,8 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
             target_arg->arg_type = EXTCAP_ARG_STRING;
         } else if (g_ascii_strcasecmp(v->value, "password") == 0) {
             target_arg->arg_type = EXTCAP_ARG_PASSWORD;
+            /* default setting is to not save passwords */
+            target_arg->do_not_save = TRUE;
         } else if (g_ascii_strcasecmp(v->value, "fileselect") == 0) {
             target_arg->arg_type = EXTCAP_ARG_FILESELECT;
         } else if (g_ascii_strcasecmp(v->value, "multicheck") == 0) {
@@ -643,6 +500,11 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
             return NULL ;
         }
 
+        if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_SAVE))
+                != NULL) {
+            target_arg->do_not_save = ! g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
+        }
+
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_RANGE))
                 != NULL) {
             gchar *cp = g_strstr_len(v->value, -1, ",");
@@ -673,9 +535,12 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DEFAULT))
                 != NULL) {
-            if ((target_arg->default_complex = extcap_parse_complex(
-                    target_arg->arg_type, v->value)) == NULL) {
-                printf("invalid default, couldn't parse %s\n", v->value);
+            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, v->value)) == NULL) {
+                    printf("invalid default, couldn't parse %s\n", v->value);
+                }
             }
         }
 
@@ -698,13 +563,8 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
             return NULL ;
         }
 
-        value = g_new(extcap_value, 1);
-        value->display = NULL;
-        value->call = NULL;
-        value->enabled = FALSE;
-        value->is_default = FALSE;
+        value = g_new0(extcap_value, 1);
         value->arg_num = tint;
-        value->parent = NULL;
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_VALUE))
                 == NULL) {
@@ -730,12 +590,12 @@ extcap_arg *extcap_parse_arg_sentence(GList * args, extcap_token_sentence *s) {
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_DEFAULT))
                 != NULL) {
             /* printf("found default value\n"); */
-            value->is_default = (v->value[0] == 't' || v->value[0] == 'T');
+            value->is_default = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
         }
 
         if ((v = extcap_find_param_by_type(s->param_list, EXTCAP_PARAM_ENABLED))
                 != NULL) {
-            value->enabled = (v->value[0] == 't' || v->value[0] == 'T');
+            value->enabled = g_regex_match_simple(EXTCAP_BOOLEAN_REGEX, v->value, G_REGEX_CASELESS, (GRegexMatchFlags)0 );
         }
 
         ((extcap_arg*) entry->data)->values = g_list_append(