static gboolean load_current_modes_finish (MMIfaceModem *_self, GAsyncResult *res, MMModemMode *allowed, MMModemMode *preferred, GError **error) { MMBroadbandModemMbm *self = MM_BROADBAND_MODEM_MBM (_self); const gchar *response; guint a; response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, error); if (!response) return FALSE; if (mm_get_uint_from_str (mm_strip_tag (response, "+CFUN:"), &a)) { /* No settings to set preferred */ *preferred = MM_MODEM_MODE_NONE; switch (a) { case MBM_NETWORK_MODE_OFFLINE: case MBM_NETWORK_MODE_LOW_POWER: /* Do not update internal mbm_mode */ *allowed = MM_MODEM_MODE_NONE; break; case MBM_NETWORK_MODE_2G: self->priv->mbm_mode = MBM_NETWORK_MODE_2G; *allowed = MM_MODEM_MODE_2G; break; case MBM_NETWORK_MODE_3G: self->priv->mbm_mode = MBM_NETWORK_MODE_3G; *allowed = MM_MODEM_MODE_3G; break; default: /* Do not update internal mbm_mode */ *allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G); break; } return TRUE; } g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Couldn't parse +CFUN response: '%s'", response); return FALSE; }
void mmcli_modem_signal_run_synchronous (GDBusConnection *connection) { GError *error = NULL; /* Initialize context */ ctx = g_new0 (Context, 1); ctx->object = mmcli_get_modem_sync (connection, mmcli_get_common_modem_string (), &ctx->manager); ctx->modem_signal = mm_object_get_modem_signal (ctx->object); /* Setup operation timeout */ if (ctx->modem_signal) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_signal)); ensure_modem_signal (); /* Request to get signal info? */ if (get_flag) { print_signal_info (); return; } /* Request to set rate? */ if (setup_str) { guint rate; gboolean result; if (!mm_get_uint_from_str (setup_str, &rate)) { g_printerr ("error: invalid rate value '%s'", setup_str); exit (EXIT_FAILURE); } g_debug ("Synchronously setting up extended signal quality information retrieval..."); result = mm_modem_signal_setup_sync (ctx->modem_signal, rate, NULL, &error); setup_process_reply (result, error); return; } g_warn_if_reached (); }
static MMModemPowerState load_power_state_finish (MMIfaceModem *self, GAsyncResult *res, GError **error) { const gchar *response; guint a; response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, error); if (!response) return FALSE; if (mm_get_uint_from_str (mm_strip_tag (response, "+CFUN:"), &a)) { switch (a) { case MBM_NETWORK_MODE_OFFLINE: return MM_MODEM_POWER_STATE_OFF; case MBM_NETWORK_MODE_LOW_POWER: return MM_MODEM_POWER_STATE_LOW; case MBM_NETWORK_MODE_ANY: case MBM_NETWORK_MODE_2G: case MBM_NETWORK_MODE_3G: return MM_MODEM_POWER_STATE_ON; default: break; } } g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Couldn't parse +CFUN response: '%s'", response); return MM_MODEM_POWER_STATE_UNKNOWN; }
static void get_modem_ready (GObject *source, GAsyncResult *result) { ctx->object = mmcli_get_modem_finish (result, &ctx->manager); ctx->modem_signal = mm_object_get_modem_signal (ctx->object); /* Setup operation timeout */ if (ctx->modem_signal) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_signal)); ensure_modem_signal (); if (get_flag) g_assert_not_reached (); /* Request to setup? */ if (setup_str) { guint rate; if (!mm_get_uint_from_str (setup_str, &rate)) { g_printerr ("error: invalid rate value '%s'", setup_str); exit (EXIT_FAILURE); } g_debug ("Asynchronously setting up extended signal quality information retrieval..."); mm_modem_signal_setup (ctx->modem_signal, rate, ctx->cancellable, (GAsyncReadyCallback)setup_ready, NULL); return; } g_warn_if_reached (); }
void mmcli_modem_location_run_synchronous (GDBusConnection *connection) { GError *error = NULL; /* Initialize context */ ctx = g_new0 (Context, 1); ctx->object = mmcli_get_modem_sync (connection, mmcli_get_common_modem_string (), &ctx->manager); ctx->modem_location = mm_object_get_modem_location (ctx->object); /* Setup operation timeout */ if (ctx->modem_location) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_location)); ensure_modem_location (); /* Request to get location status? */ if (status_flag) { g_debug ("Printing location status..."); print_location_status (); return; } /* Request to setup location gathering? */ if (enable_3gpp_flag || disable_3gpp_flag || enable_agps_flag || disable_agps_flag || enable_gps_nmea_flag || disable_gps_nmea_flag || enable_gps_raw_flag || disable_gps_raw_flag || enable_cdma_bs_flag || disable_cdma_bs_flag || enable_gps_unmanaged_flag || disable_gps_unmanaged_flag || set_enable_signal_flag || set_disable_signal_flag) { gboolean result; g_debug ("Synchronously setting up location gathering..."); result = mm_modem_location_setup_sync (ctx->modem_location, build_sources_from_flags (), build_signals_location_from_flags (), NULL, &error); setup_process_reply (result, error); return; } /* Request to get location from the modem? */ if (get_3gpp_flag || get_gps_nmea_flag || get_gps_raw_flag || get_cdma_bs_flag) { MMLocation3gpp *location_3gpp = NULL; MMLocationGpsNmea *location_gps_nmea = NULL; MMLocationGpsRaw *location_gps_raw = NULL; MMLocationCdmaBs *location_cdma_bs = NULL; g_debug ("Synchronously getting location from the modem..."); mm_modem_location_get_full_sync (ctx->modem_location, get_3gpp_flag ? &location_3gpp : NULL, get_gps_nmea_flag ? &location_gps_nmea : NULL, get_gps_raw_flag ? &location_gps_raw : NULL, get_cdma_bs_flag ? &location_cdma_bs : NULL, NULL, &error); get_location_process_reply (location_3gpp, location_gps_nmea, location_gps_raw, location_cdma_bs, error); return; } /* Request to set SUPL server? */ if (set_supl_server_str) { gboolean result; g_debug ("Synchronously setting SUPL server..."); result = mm_modem_location_set_supl_server_sync (ctx->modem_location, set_supl_server_str, NULL, &error); set_supl_server_process_reply (result, error); return; } /* Request to set GPS refresh rate? */ if (set_gps_refresh_rate_str) { gboolean result; guint rate; if (!mm_get_uint_from_str (set_gps_refresh_rate_str, &rate)) { g_printerr ("error: couldn't set GPS refresh rate: invalid rate given: '%s'\n", set_gps_refresh_rate_str); exit (EXIT_FAILURE); } g_debug ("Synchronously setting GPS refresh rate..."); result = mm_modem_location_set_gps_refresh_rate_sync (ctx->modem_location, rate, NULL, &error); set_gps_refresh_rate_process_reply (result, error); return; } g_warn_if_reached (); }
static void get_modem_ready (GObject *source, GAsyncResult *result, gpointer none) { ctx->object = mmcli_get_modem_finish (result, &ctx->manager); ctx->modem_location = mm_object_get_modem_location (ctx->object); /* Setup operation timeout */ if (ctx->modem_location) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_location)); ensure_modem_location (); if (status_flag) g_assert_not_reached (); /* Request to setup location gathering? */ if (enable_3gpp_flag || disable_3gpp_flag || enable_agps_flag || disable_agps_flag || enable_gps_nmea_flag || disable_gps_nmea_flag || enable_gps_raw_flag || disable_gps_raw_flag || enable_cdma_bs_flag || disable_cdma_bs_flag || enable_gps_unmanaged_flag || disable_gps_unmanaged_flag || set_enable_signal_flag || set_disable_signal_flag) { g_debug ("Asynchronously setting up location gathering..."); mm_modem_location_setup (ctx->modem_location, build_sources_from_flags (), build_signals_location_from_flags (), ctx->cancellable, (GAsyncReadyCallback)setup_ready, NULL); return; } /* Request to get location from the modem? */ if (get_3gpp_flag || get_gps_nmea_flag || get_gps_raw_flag || get_cdma_bs_flag) { g_debug ("Asynchronously getting location from the modem..."); mm_modem_location_get_full (ctx->modem_location, ctx->cancellable, (GAsyncReadyCallback)get_location_ready, NULL); return; } /* Request to set SUPL server? */ if (set_supl_server_str) { g_debug ("Asynchronously setting SUPL server..."); mm_modem_location_set_supl_server (ctx->modem_location, set_supl_server_str, ctx->cancellable, (GAsyncReadyCallback)set_supl_server_ready, NULL); return; } /* Request to set GPS refresh rate? */ if (set_gps_refresh_rate_str) { guint rate; if (!mm_get_uint_from_str (set_gps_refresh_rate_str, &rate)) { g_printerr ("error: couldn't set GPS refresh rate: invalid rate given: '%s'\n", set_gps_refresh_rate_str); exit (EXIT_FAILURE); } g_debug ("Asynchronously setting GPS refresh rate..."); mm_modem_location_set_gps_refresh_rate (ctx->modem_location, rate, ctx->cancellable, (GAsyncReadyCallback)set_gps_refresh_rate_ready, NULL); return; } g_warn_if_reached (); }
const MMHuaweiSyscfgCombination * mm_huawei_parse_syscfg_response (const gchar *response, const GArray *supported_mode_combinations, GError **error) { gchar **split; guint mode; guint acqorder; guint i; if (!response || !g_str_has_prefix (response, "^SYSCFG:")) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Missing ^SYSCFG prefix"); return NULL; } /* Format: * * ^SYSCFG: <mode>,<acqorder>,<band>,<roam>,<srvdomain> */ response = mm_strip_tag (response, "^SYSCFG:"); split = g_strsplit (response, ",", -1); /* We expect 5 string chunks */ if (g_strv_length (split) < 5 || !mm_get_uint_from_str (split[0], &mode) || !mm_get_uint_from_str (split[1], &acqorder)) { /* Dump error to upper layer */ g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Unexpected ^SYSCFG response: '%s'", response); g_strfreev (split); return NULL; } /* Fix invalid modes with non-sensical acquisition orders */ if (mode == 14 && acqorder != 0) /* WCDMA only but acqorder != "Automatic" */ acqorder = 0; else if (mode == 13 && acqorder != 0) /* GSM only but acqorder != "Automatic" */ acqorder = 0; /* Look for current modes among the supported ones */ for (i = 0; i < supported_mode_combinations->len; i++) { const MMHuaweiSyscfgCombination *combination; combination = &g_array_index (supported_mode_combinations, MMHuaweiSyscfgCombination, i); if (mode == combination->mode && acqorder == combination->acqorder) { g_strfreev (split); return combination; } } g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "No SYSCFG combination found matching the current one (%d,%d)", mode, acqorder); g_strfreev (split); return NULL; }
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 (); } } g_strfreev (split); /* 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_prefmode_test (const gchar *response, GError **error) { gchar **split; guint i; MMModemMode all = MM_MODEM_MODE_NONE; GArray *out; response = mm_strip_tag (response, "^PREFMODE:"); split = g_strsplit_set (response, " (,)\r\n", -1); if (!split) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Unexpected ^PREFMODE format output"); return NULL; } out = g_array_sized_new (FALSE, FALSE, sizeof (MMHuaweiPrefmodeCombination), 3); for (i = 0; split[i]; i++) { guint val; MMModemMode preferred = MM_MODEM_MODE_NONE; GError *inner_error = NULL; MMHuaweiPrefmodeCombination combination; if (split[i][0] == '\0') continue; if (!mm_get_uint_from_str (split[i], &val)) { mm_dbg ("Error parsing ^PREFMODE value: %s", split[i]); continue; } if (!mode_from_prefmode (val, &preferred, &inner_error)) { mm_dbg ("Unhandled ^PREFMODE: %s", inner_error->message); g_error_free (inner_error); continue; } combination.prefmode = val; combination.allowed = MM_MODEM_MODE_NONE; /* reset it later */ combination.preferred = preferred; all |= preferred; g_array_append_val (out, combination); } g_strfreev (split); /* No value */ if (out->len == 0) { g_array_unref (out); g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "^PREFMODE response contains no valid values"); return NULL; } /* Single value listed; PREFERRED=NONE... */ if (out->len == 1) { MMHuaweiPrefmodeCombination *combination; combination = &g_array_index (out, MMHuaweiPrefmodeCombination, 0); combination->allowed = all; combination->preferred = MM_MODEM_MODE_NONE; } else { /* Multiple values, reset ALLOWED */ for (i = 0; i < out->len; i++) { MMHuaweiPrefmodeCombination *combination; combination = &g_array_index (out, MMHuaweiPrefmodeCombination, i); combination->allowed = all; if (combination->preferred == all) combination->preferred = MM_MODEM_MODE_NONE; } } return out; }
gboolean mm_mbm_parse_cfun_test (const gchar *response, guint32 *supported_mask, GError **error) { gchar **groups; guint32 mask = 0; g_assert (supported_mask); if (!response || !g_str_has_prefix (response, CFUN_TAG)) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Missing " CFUN_TAG " prefix"); return FALSE; } /* * AT+CFUN=? * +CFUN: (0,1,4-6),(0,1) * OK */ /* Strip tag from response */ response = mm_strip_tag (response, CFUN_TAG); /* Split response in (groups) */ groups = mm_split_string_groups (response); /* First group is the one listing supported modes */ if (groups && groups[0]) { gchar **supported_modes; supported_modes = g_strsplit_set (groups[0], ", ", -1); if (supported_modes) { guint i; for (i = 0; supported_modes[i]; i++) { gchar *separator; guint mode; if (!supported_modes[i][0]) continue; /* Check if this is a range that's being given to us */ separator = strchr (supported_modes[i], '-'); if (separator) { gchar *first_str; gchar *last_str; guint first; guint last; *separator = '\0'; first_str = supported_modes[i]; last_str = separator + 1; if (!mm_get_uint_from_str (first_str, &first)) g_warning ("Couldn't match range start: '%s'", first_str); else if (!mm_get_uint_from_str (last_str, &last)) g_warning ("Couldn't match range stop: '%s'", last_str); else if (first >= last) g_warning ("Couldn't match range: wrong first '%s' and last '%s' items", first_str, last_str); else { for (mode = first; mode <= last; mode++) add_supported_mode (&mask, mode); } } else { if (!mm_get_uint_from_str (supported_modes[i], &mode)) g_warning ("Couldn't match mode: '%s'", supported_modes[i]); else add_supported_mode (&mask, mode); } } g_strfreev (supported_modes); } } g_strfreev (groups); if (mask) *supported_mask = mask; return !!mask; }