huawei: new ^SYSCFG=? test parser

3 files changed, 462 insertions, 0 deletions

diff --git a/plugins/huawei/mm-modem-helpers-huawei.c b/plugins/huawei/mm-modem-helpers-huawei.c
index 7a1e8eeb..bd1e867f 100644
--- a/plugins/huawei/mm-modem-helpers-huawei.c
+++ b/plugins/huawei/mm-modem-helpers-huawei.c
@@ -15,6 +15,8 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
 
 #include <ModemManager.h>
 #define _LIBMM_INSIDE_MM
@@ -363,3 +365,300 @@ mm_huawei_parse_prefmode_test (const gchar *response,
 
     return out;
 }
+
+/*****************************************************************************/
+/* ^SYSCFG test parser */
+
+static gchar **
+split_groups (const gchar *str,
+              GError **error)
+{
+    const gchar *p = str;
+    GPtrArray *out;
+    guint groups = 0;
+
+    /*
+     * Split string: (a),((b1),(b2)),,(d),((e1),(e2))
+     * Into:
+     *   - a
+     *   - (b1),(b2)
+     *   -
+     *   - d
+     *   - (e1),(e2)
+     */
+
+    out = g_ptr_array_new_with_free_func (g_free);
+
+    while (TRUE) {
+        const gchar *start;
+        guint inner_groups;
+
+        /* Skip whitespaces */
+        while (*p == ' ' || *p == '\r' || *p == '\n')
+            p++;
+
+        /* We're done, return */
+        if (*p == '\0') {
+            g_ptr_array_set_size (out, out->len + 1);
+            return (gchar **) g_ptr_array_free (out, FALSE);
+        }
+
+        /* Group separators */
+        if (groups > 0) {
+            if (*p != ',') {
+                g_set_error (error,
+                             MM_CORE_ERROR,
+                             MM_CORE_ERROR_FAILED,
+                             "Unexpected group separator");
+                g_ptr_array_unref (out);
+                return NULL;
+            }
+            p++;
+        }
+
+        /* Skip whitespaces */
+        while (*p == ' ' || *p == '\r' || *p == '\n')
+            p++;
+
+        /* New group */
+        groups++;
+
+        /* Empty group? */
+        if (*p == ',' || *p == '\0') {
+            g_ptr_array_add (out, g_strdup (""));
+            continue;
+        }
+
+        /* No group start? */
+        if (*p != '(') {
+            /* Error */
+            g_set_error (error,
+                         MM_CORE_ERROR,
+                         MM_CORE_ERROR_FAILED,
+                         "Expected '(' not found");
+            g_ptr_array_unref (out);
+            return NULL;
+        }
+        p++;
+
+        inner_groups = 0;
+        start = p;
+        while (TRUE) {
+            if (*p == '(') {
+                inner_groups++;
+                p++;
+                continue;
+            }
+
+            if (*p == '\0') {
+                g_set_error (error,
+                             MM_CORE_ERROR,
+                             MM_CORE_ERROR_FAILED,
+                             "Early end of string found, unfinished group");
+                g_ptr_array_unref (out);
+                return NULL;
+            }
+
+            if (*p == ')') {
+                gchar *group;
+
+                if (inner_groups > 0) {
+                    inner_groups--;
+                    p++;
+                    continue;
+                }
+
+                group = g_strndup (start, p - start);
+                g_ptr_array_add (out, group);
+                p++;
+                break;
+            }
+
+            /* keep on */
+            p++;
+        }
+    }
+
+    g_assert_not_reached ();
+}
+
+static gboolean
+mode_from_syscfg (guint huawei_mode,
+                  MMModemMode *modem_mode,
+                  GError **error)
+{
+    g_assert (modem_mode != NULL);
+
+    *modem_mode = MM_MODEM_MODE_NONE;
+    switch (huawei_mode) {
+    case 2:
+        *modem_mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G;
+        break;
+    case 13:
+        *modem_mode = MM_MODEM_MODE_2G;
+        break;
+    case 14:
+        *modem_mode = MM_MODEM_MODE_3G;
+        break;
+    case 16:
+        /* ignore */
+        break;
+    default:
+        g_set_error (error,
+                     MM_CORE_ERROR,
+                     MM_CORE_ERROR_FAILED,
+                     "No translation from huawei prefmode '%u' to mode",
+                     huawei_mode);
+    }
+
+    return *modem_mode != MM_MODEM_MODE_NONE ? TRUE : FALSE;
+}
+
+static GArray *
+parse_syscfg_modes (const gchar *modes_str,
+                    const gchar *acqorder_str,
+                    GError **error)
+{
+    GArray *out;
+    gchar **split;
+    guint i;
+    gint min_acqorder = 0;
+    gint max_acqorder = 0;
+
+    /* Start parsing acquisition order */
+    if (!sscanf (acqorder_str, "%d-%d", &min_acqorder, &max_acqorder))
+        mm_dbg ("Error parsing ^SYSCFG acquisition order range (%s)", acqorder_str);
+
+    /* Just in case, we default to supporting only auto */
+    if (max_acqorder < min_acqorder) {
+        min_acqorder = 0;
+        max_acqorder = 0;
+    }
+
+    /* Now parse modes */
+    split = g_strsplit (modes_str, ",", -1);
+    out = g_array_sized_new (FALSE,
+                             FALSE,
+                             sizeof (MMHuaweiSyscfgCombination),
+                             g_strv_length (split));
+    for (i = 0; split[i]; i++) {
+        guint val;
+        guint allowed = MM_MODEM_MODE_NONE;
+        GError *inner_error = NULL;
+        MMHuaweiSyscfgCombination combination;
+
+        if (!mm_get_uint_from_str (mm_strip_quotes (split[i]), &val)) {
+            mm_dbg ("Error parsing ^SYSCFG mode value: %s", split[i]);
+            continue;
+        }
+
+        if (!mode_from_syscfg (val, &allowed, &inner_error)) {
+            if (inner_error) {
+                mm_dbg ("Unhandled ^SYSCFG: %s", inner_error->message);
+                g_error_free (inner_error);
+            }
+            continue;
+        }
+
+        switch (allowed) {
+        case MM_MODEM_MODE_2G:
+        case MM_MODEM_MODE_3G:
+            /* single mode */
+            combination.allowed = allowed;
+            combination.preferred = MM_MODEM_MODE_NONE;
+            combination.mode = val;
+            combination.acqorder = 0;
+            g_array_append_val (out, combination);
+            break;
+        case (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G):
+            /* 2G and 3G; auto */
+            combination.allowed = allowed;
+            combination.mode = val;
+            if (min_acqorder == 0) {
+                combination.preferred = MM_MODEM_MODE_NONE;
+                combination.acqorder = 0;
+                g_array_append_val (out, combination);
+            }
+            /* 2G and 3G; 2G preferred */
+            if (min_acqorder <= 1 && max_acqorder >= 1) {
+                combination.preferred = MM_MODEM_MODE_2G;
+                combination.acqorder = 1;
+                g_array_append_val (out, combination);
+            }
+            /* 2G and 3G; 3G preferred */
+            if (min_acqorder <= 2 && max_acqorder >= 2) {
+                combination.preferred = MM_MODEM_MODE_3G;
+                combination.acqorder = 2;
+                g_array_append_val (out, combination);
+            }
+            break;
+        default:
+            g_assert_not_reached ();
+        }
+    }
+
+    /* If we didn't build a valid array of combinations, return an error */
+    if (out->len == 0) {
+        g_set_error (error,
+                     MM_CORE_ERROR,
+                     MM_CORE_ERROR_FAILED,
+                     "Cannot parse list of allowed mode combinations: '%s,%s'",
+                     modes_str,
+                     acqorder_str);
+        g_array_unref (out);
+        return NULL;
+    }
+
+    return out;
+}
+
+GArray *
+mm_huawei_parse_syscfg_test (const gchar *response,
+                             GError **error)
+{
+    gchar **split;
+    GError *inner_error = NULL;
+    GArray *out;
+
+    if (!response || !g_str_has_prefix (response, "^SYSCFG:")) {
+        g_set_error (error,
+                     MM_CORE_ERROR,
+                     MM_CORE_ERROR_FAILED,
+                     "Missing ^SYSCFG prefix");
+        return NULL;
+    }
+
+    /* Examples:
+     *
+     * ^SYSCFG:(2,13,14,16),
+     *         (0-3),
+     *         ((400000,"WCDMA2100")),
+     *         (0-2),
+     *         (0-4)
+     */
+    split = split_groups (mm_strip_tag (response, "^SYSCFG:"), error);
+    if (!split)
+        return NULL;
+
+    /* We expect 5 string chunks */
+    if (g_strv_length (split) < 5) {
+        g_set_error (error,
+                     MM_CORE_ERROR,
+                     MM_CORE_ERROR_FAILED,
+                     "Unexpected ^SYSCFG format");
+        g_strfreev (split);
+        return FALSE;
+    }
+
+    /* Parse supported mode combinations */
+    out = parse_syscfg_modes (split[0], split[1], &inner_error);
+
+    g_strfreev (split);
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return NULL;
+    }
+
+    return out;
+}
diff --git a/plugins/huawei/mm-modem-helpers-huawei.h b/plugins/huawei/mm-modem-helpers-huawei.h
index 00191b2d..d0cbf693 100644
--- a/plugins/huawei/mm-modem-helpers-huawei.h
+++ b/plugins/huawei/mm-modem-helpers-huawei.h
@@ -63,4 +63,17 @@ typedef struct {
 GArray *mm_huawei_parse_prefmode_test (const gchar *response,
                                        GError **error);
 
+/*****************************************************************************/
+/* ^SYSCFG test parser */
+
+typedef struct {
+    guint mode;
+    guint acqorder;
+    MMModemMode allowed;
+    MMModemMode preferred;
+} MMHuaweiSyscfgCombination;
+
+GArray *mm_huawei_parse_syscfg_test (const gchar *response,
+                                     GError **error);
+
 #endif  /* MM_MODEM_HELPERS_HUAWEI_H */
diff --git a/plugins/huawei/tests/test-modem-helpers-huawei.c b/plugins/huawei/tests/test-modem-helpers-huawei.c
index c7b8b778..fbf287f0 100644
--- a/plugins/huawei/tests/test-modem-helpers-huawei.c
+++ b/plugins/huawei/tests/test-modem-helpers-huawei.c
@@ -374,6 +374,155 @@ test_prefmode (void)
 }
 
 /*****************************************************************************/
+/* Test ^SYSCFG=? responses */
+
+#define MAX_SYSCFG_COMBINATIONS 5
+
+typedef struct {
+    const gchar *str;
+    MMHuaweiSyscfgCombination expected_modes[MAX_SYSCFG_COMBINATIONS];
+} SyscfgTest;
+
+static const SyscfgTest syscfg_tests[] = {
+    {
+        "^SYSCFG:(2,13,14,16),(0-3),((400000,\"WCDMA2100\")),(0-2),(0-4)\r\n",
+        {
+            {
+                .mode = 2,
+                .acqorder = 0,
+                .allowed = (MM_MODEM_MODE_3G | MM_MODEM_MODE_2G),
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            {
+                .mode = 2,
+                .acqorder = 1,
+                .allowed = (MM_MODEM_MODE_3G | MM_MODEM_MODE_2G),
+                .preferred = MM_MODEM_MODE_2G
+            },
+            {
+                .mode = 2,
+                .acqorder = 2,
+                .allowed = (MM_MODEM_MODE_3G | MM_MODEM_MODE_2G),
+                .preferred = MM_MODEM_MODE_3G
+            },
+            {
+                .mode = 13,
+                .acqorder = 0,
+                .allowed = MM_MODEM_MODE_2G,
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            {
+                .mode = 14,
+                .acqorder = 0,
+                .allowed = MM_MODEM_MODE_3G,
+                .preferred = MM_MODEM_MODE_NONE
+            }
+        }
+    },
+    {
+        "^SYSCFG:(2,13,14,16),(0),((400000,\"WCDMA2100\")),(0-2),(0-4)\r\n",
+        {
+            {
+                .mode = 2,
+                .acqorder = 0,
+                .allowed = (MM_MODEM_MODE_3G | MM_MODEM_MODE_2G),
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            {
+                .mode = 13,
+                .acqorder = 0,
+                .allowed = MM_MODEM_MODE_2G,
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            {
+                .mode = 14,
+                .acqorder = 0,
+                .allowed = MM_MODEM_MODE_3G,
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            { 0, 0, 0, 0 }
+        }
+    },
+    {
+        "^SYSCFG:(13),(0),((400000,\"WCDMA2100\")),(0-2),(0-4)\r\n",
+        {
+            {
+                .mode = 13,
+                .acqorder = 0,
+                .allowed = MM_MODEM_MODE_2G,
+                .preferred = MM_MODEM_MODE_NONE
+            },
+            { 0, 0, 0, 0 }
+        }
+    }
+};
+
+static void
+test_syscfg (void)
+{
+    guint i;
+
+    for (i = 0; i < G_N_ELEMENTS (syscfg_tests); i++) {
+        GError *error = NULL;
+        GArray *combinations = NULL;
+        guint j;
+        guint n_expected_combinations = 0;
+
+        for (j = 0; j < MAX_SYSCFG_COMBINATIONS; j++) {
+            if (syscfg_tests[i].expected_modes[j].mode != 0)
+                n_expected_combinations++;
+        }
+
+        combinations = mm_huawei_parse_syscfg_test (syscfg_tests[i].str, &error);
+        g_assert_no_error (error);
+        g_assert (combinations != NULL);
+        g_assert_cmpuint (combinations->len, ==, n_expected_combinations);
+
+#if defined ENABLE_TEST_MESSAGE_TRACES
+        for (j = 0; j < combinations->len; j++) {
+            MMHuaweiSyscfgCombination *single;
+            gchar *allowed_str;
+            gchar *preferred_str;
+
+            single = &g_array_index (combinations, MMHuaweiSyscfgCombination, j);
+            allowed_str = mm_modem_mode_build_string_from_mask (single->allowed);
+            preferred_str = mm_modem_mode_build_string_from_mask (single->preferred);
+            mm_dbg ("Test[%u], Combination[%u]: %u, %u, \"%s\", \"%s\"",
+                    i,
+                    j,
+                    single->mode,
+                    single->acqorder,
+                    allowed_str,
+                    preferred_str);
+            g_free (allowed_str);
+            g_free (preferred_str);
+        }
+#endif
+
+        for (j = 0; j < combinations->len; j++) {
+            MMHuaweiSyscfgCombination *single;
+            guint k;
+            gboolean found = FALSE;
+
+            single = &g_array_index (combinations, MMHuaweiSyscfgCombination, j);
+            for (k = 0; k <= n_expected_combinations; k++) {
+                if (single->allowed == syscfg_tests[i].expected_modes[k].allowed &&
+                    single->preferred == syscfg_tests[i].expected_modes[k].preferred &&
+                    single->mode == syscfg_tests[i].expected_modes[k].mode &&
+                    single->acqorder == syscfg_tests[i].expected_modes[k].acqorder) {
+                    found = TRUE;
+                    break;
+                }
+            }
+
+            g_assert (found == TRUE);
+        }
+
+        g_array_unref (combinations);
+    }
+}
+
+/*****************************************************************************/
 
 void
 _mm_log (const char *loc,
@@ -406,6 +555,7 @@ int main (int argc, char **argv)
     g_test_add_func ("/MM/huawei/sysinfo", test_sysinfo);
     g_test_add_func ("/MM/huawei/sysinfoex", test_sysinfoex);
     g_test_add_func ("/MM/huawei/prefmode", test_prefmode);
+    g_test_add_func ("/MM/huawei/syscfg", test_syscfg);
 
     return g_test_run ();
 }