colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

huawei: new ^SYSCFG=? test parser

Browse Source
This commit is contained in:
Aleksander Morgado
2013-11-07 23:30:53 +01:00
parent ceb578a824
commit 677dd7da91
3 changed files with 462 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
plugins/huawei/mm-modem-helpers-huawei.c
View File

@@ -15,6 +15,8 @@
*/ */
#include <string.h> #include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ModemManager.h> #include <ModemManager.h>
#define _LIBMM_INSIDE_MM #define _LIBMM_INSIDE_MM
@@ -363,3 +365,300 @@ mm_huawei_parse_prefmode_test (const gchar *response,
return out; 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;
}

13
plugins/huawei/mm-modem-helpers-huawei.h
View File

@@ -63,4 +63,17 @@ typedef struct {
GArray *mm_huawei_parse_prefmode_test (const gchar *response, GArray *mm_huawei_parse_prefmode_test (const gchar *response,
GError **error); 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 */ #endif /* MM_MODEM_HELPERS_HUAWEI_H */

150
plugins/huawei/tests/test-modem-helpers-huawei.c
View File

@@ -373,6 +373,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 void
@@ -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/sysinfo", test_sysinfo);
g_test_add_func ("/MM/huawei/sysinfoex", test_sysinfoex); g_test_add_func ("/MM/huawei/sysinfoex", test_sysinfoex);
g_test_add_func ("/MM/huawei/prefmode", test_prefmode); g_test_add_func ("/MM/huawei/prefmode", test_prefmode);
g_test_add_func ("/MM/huawei/syscfg", test_syscfg);
return g_test_run (); return g_test_run ();
} }