gboolean
nm_modem_check_connection_compatible (NMModem *self, NMConnection *connection)
{
if (NM_MODEM_GET_CLASS (self)->check_connection_compatible)
return NM_MODEM_GET_CLASS (self)->check_connection_compatible (self, connection);
return FALSE;
}
void
nm_modem_deactivate (NMModem *self, NMDevice *device)
{
/* First cleanup */
NM_MODEM_GET_CLASS (self)->deactivate_cleanup (self, device);
/* Then disconnect without waiting */
NM_MODEM_GET_CLASS (self)->disconnect (self, FALSE, NULL, NULL, NULL);
}
NMConnection *
nm_modem_get_best_auto_connection (NMModem *self,
GSList *connections,
char **specific_object)
{
if (NM_MODEM_GET_CLASS (self)->get_best_auto_connection)
return NM_MODEM_GET_CLASS (self)->get_best_auto_connection (self, connections, specific_object);
return NULL;
}
static void
deactivate_step (DeactivateContext *ctx)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (ctx->self);
GError *error = NULL;
/* Check cancellable in each step */
if (g_cancellable_set_error_if_cancelled (ctx->cancellable, &error)) {
g_simple_async_result_take_error (ctx->result, error);
deactivate_context_complete (ctx);
return;
}
switch (ctx->step) {
case DEACTIVATE_CONTEXT_STEP_FIRST:
ctx->step++;
/* Fall down */
case DEACTIVATE_CONTEXT_STEP_CLEANUP:
/* Make sure we keep a ref to the PPP manager if there is one */
if (priv->ppp_manager)
ctx->ppp_manager = g_object_ref (priv->ppp_manager);
/* Run cleanup */
NM_MODEM_GET_CLASS (ctx->self)->deactivate_cleanup (ctx->self, ctx->device);
ctx->step++;
/* Fall down */
case DEACTIVATE_CONTEXT_STEP_PPP_MANAGER_STOP:
/* If we have a PPP manager, stop it */
if (ctx->ppp_manager) {
nm_ppp_manager_stop (ctx->ppp_manager,
ctx->cancellable,
(GAsyncReadyCallback) ppp_manager_stop_ready,
ctx);
return;
}
ctx->step++;
/* Fall down */
case DEACTIVATE_CONTEXT_STEP_MM_DISCONNECT:
/* Disconnect asynchronously */
NM_MODEM_GET_CLASS (ctx->self)->disconnect (ctx->self,
FALSE,
ctx->cancellable,
(GAsyncReadyCallback) disconnect_ready,
ctx);
return;
case DEACTIVATE_CONTEXT_STEP_LAST:
nm_log_dbg (LOGD_MB, "(%s): modem deactivation finished",
nm_modem_get_uid (ctx->self));
deactivate_context_complete (ctx);
return;
}
g_assert_not_reached ();
}
gboolean
nm_modem_complete_connection (NMModem *self,
NMConnection *connection,
const GSList *existing_connections,
GError **error)
{
if (NM_MODEM_GET_CLASS (self)->complete_connection)
return NM_MODEM_GET_CLASS (self)->complete_connection (self, connection, existing_connections, error);
return FALSE;
}
static NMActStageReturn
ppp_stage3_ip4_config_start (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
const char *ppp_name = NULL;
GError *error = NULL;
NMActStageReturn ret;
g_return_val_if_fail (self != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (req != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
if (NM_MODEM_GET_CLASS (self)->get_user_pass) {
NMConnection *connection = nm_act_request_get_connection (req);
g_assert (connection);
if (!NM_MODEM_GET_CLASS (self)->get_user_pass (self, connection, &ppp_name, NULL))
return NM_ACT_STAGE_RETURN_FAILURE;
}
priv->ppp_manager = nm_ppp_manager_new (priv->iface);
if (nm_ppp_manager_start (priv->ppp_manager, req, ppp_name, 20, &error)) {
g_signal_connect (priv->ppp_manager, "state-changed",
G_CALLBACK (ppp_state_changed),
self);
g_signal_connect (priv->ppp_manager, "ip4-config",
G_CALLBACK (ppp_ip4_config),
self);
g_signal_connect (priv->ppp_manager, "stats",
G_CALLBACK (ppp_stats),
self);
ret = NM_ACT_STAGE_RETURN_POSTPONE;
} else {
nm_log_err (LOGD_PPP, "error starting PPP: (%d) %s",
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_error_free (error);
g_object_unref (priv->ppp_manager);
priv->ppp_manager = NULL;
*reason = NM_DEVICE_STATE_REASON_PPP_START_FAILED;
ret = NM_ACT_STAGE_RETURN_FAILURE;
}
return ret;
}
void
nm_modem_get_capabilities (NMModem *self,
NMDeviceModemCapabilities *modem_caps,
NMDeviceModemCapabilities *current_caps)
{
g_return_if_fail (NM_IS_MODEM (self));
NM_MODEM_GET_CLASS (self)->get_capabilities (self, modem_caps, current_caps);
}
NMActStageReturn
nm_modem_stage3_ip4_config_start (NMModem *self,
NMDevice *device,
NMDeviceClass *device_class,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv;
NMActRequest *req;
NMConnection *connection;
const char *method;
NMActStageReturn ret;
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_DEVICE (device), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_DEVICE_CLASS (device_class), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
req = nm_device_get_act_request (device);
g_assert (req);
connection = nm_act_request_get_applied_connection (req);
g_assert (connection);
method = nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP4_CONFIG);
/* Only Disabled and Auto methods make sense for WWAN */
if (strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED) == 0)
return NM_ACT_STAGE_RETURN_STOP;
if (strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO) != 0) {
nm_log_warn (LOGD_MB | LOGD_IP4,
"(%s): unhandled WWAN IPv4 method '%s'; will fail",
nm_modem_get_uid (self), method);
*reason = NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE;
return NM_ACT_STAGE_RETURN_FAILURE;
}
priv = NM_MODEM_GET_PRIVATE (self);
switch (priv->ip4_method) {
case NM_MODEM_IP_METHOD_PPP:
ret = ppp_stage3_ip_config_start (self, req, reason);
break;
case NM_MODEM_IP_METHOD_STATIC:
ret = NM_MODEM_GET_CLASS (self)->static_stage3_ip4_config_start (self, req, reason);
break;
case NM_MODEM_IP_METHOD_AUTO:
ret = device_class->act_stage3_ip4_config_start (device, NULL, reason);
break;
default:
nm_log_info (LOGD_MB, "(%s): IPv4 configuration disabled", nm_modem_get_uid (self));
ret = NM_ACT_STAGE_RETURN_STOP;
break;
}
return ret;
}
void
nm_modem_set_mm_enabled (NMModem *self,
gboolean enabled)
{
NMModemPrivate *priv;
priv = NM_MODEM_GET_PRIVATE (self);
if (priv->mm_enabled != enabled)
NM_MODEM_GET_CLASS (self)->set_mm_enabled (self, enabled);
}
gboolean
nm_modem_owns_port (NMModem *self, const char *iface)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
g_return_val_if_fail (iface != NULL, FALSE);
if (NM_MODEM_GET_CLASS (self)->owns_port)
return NM_MODEM_GET_CLASS (self)->owns_port (self, iface);
/* Fall back to data/control ports */
if (priv->ppp_iface && (strcmp (priv->ppp_iface, iface) == 0))
return TRUE;
if (priv->data_port && (strcmp (priv->data_port, iface) == 0))
return TRUE;
if (priv->control_port && (strcmp (priv->control_port, iface) == 0))
return TRUE;
return FALSE;
}
void
nm_modem_device_state_changed (NMModem *self,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason)
{
gboolean was_connected = FALSE, warn = TRUE;
NMModemPrivate *priv;
g_return_if_fail (NM_IS_MODEM (self));
if (old_state >= NM_DEVICE_STATE_PREPARE && old_state <= NM_DEVICE_STATE_DEACTIVATING)
was_connected = TRUE;
priv = NM_MODEM_GET_PRIVATE (self);
/* Make sure we don't leave the serial device open */
switch (new_state) {
case NM_DEVICE_STATE_UNMANAGED:
case NM_DEVICE_STATE_UNAVAILABLE:
case NM_DEVICE_STATE_FAILED:
case NM_DEVICE_STATE_DISCONNECTED:
if (priv->act_request) {
cancel_get_secrets (self);
g_object_unref (priv->act_request);
priv->act_request = NULL;
}
if (was_connected) {
/* Don't bother warning on FAILED since the modem is already gone */
if (new_state == NM_DEVICE_STATE_FAILED || new_state == NM_DEVICE_STATE_DISCONNECTED)
warn = FALSE;
/* First cleanup */
NM_MODEM_GET_CLASS (self)->deactivate_cleanup (self, NULL);
NM_MODEM_GET_CLASS (self)->disconnect (self, warn, NULL, NULL, NULL);
}
break;
default:
break;
}
}
NMActStageReturn
nm_modem_stage3_ip6_config_start (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv;
NMActStageReturn ret;
NMConnection *connection;
const char *method;
g_return_val_if_fail (self != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (req != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
connection = nm_act_request_get_applied_connection (req);
g_assert (connection);
method = nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP6_CONFIG);
/* Only Ignore and Auto methods make sense for WWAN */
if (strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE) == 0)
return NM_ACT_STAGE_RETURN_STOP;
if (strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) != 0) {
nm_log_warn (LOGD_MB | LOGD_IP6,
"(%s): unhandled WWAN IPv6 method '%s'; will fail",
nm_modem_get_uid (self), method);
*reason = NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE;
return NM_ACT_STAGE_RETURN_FAILURE;
}
priv = NM_MODEM_GET_PRIVATE (self);
switch (priv->ip6_method) {
case NM_MODEM_IP_METHOD_PPP:
ret = ppp_stage3_ip_config_start (self, req, reason);
break;
case NM_MODEM_IP_METHOD_STATIC:
case NM_MODEM_IP_METHOD_AUTO:
/* Both static and DHCP/Auto retrieve a base IP config from the modem
* which in the static case is the full config, and the DHCP/Auto case
* is just the IPv6LL address to use for SLAAC.
*/
ret = NM_MODEM_GET_CLASS (self)->stage3_ip6_config_request (self, reason);
break;
default:
nm_log_info (LOGD_MB, "(%s): IPv6 configuration disabled", nm_modem_get_uid (self));
ret = NM_ACT_STAGE_RETURN_STOP;
break;
}
return ret;
}
NMActStageReturn
nm_modem_act_stage1_prepare (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
NMActStageReturn ret;
GPtrArray *hints = NULL;
const char *setting_name = NULL;
NMSecretAgentGetSecretsFlags flags = NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION;
NMConnection *connection;
if (priv->act_request)
g_object_unref (priv->act_request);
priv->act_request = g_object_ref (req);
connection = nm_act_request_get_connection (req);
g_assert (connection);
setting_name = nm_connection_need_secrets (connection, &hints);
if (!setting_name) {
/* Ready to connect */
g_assert (!hints);
return NM_MODEM_GET_CLASS (self)->act_stage1_prepare (self, connection, reason);
}
/* Secrets required... */
if (priv->secrets_tries++)
flags |= NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW;
priv->secrets_id = nm_act_request_get_secrets (req,
setting_name,
flags,
hints ? g_ptr_array_index (hints, 0) : NULL,
modem_secrets_cb,
self);
if (priv->secrets_id) {
g_signal_emit (self, signals[AUTH_REQUESTED], 0);
ret = NM_ACT_STAGE_RETURN_POSTPONE;
} else {
*reason = NM_DEVICE_STATE_REASON_NO_SECRETS;
ret = NM_ACT_STAGE_RETURN_FAILURE;
}
if (hints)
g_ptr_array_free (hints, TRUE);
return ret;
}
static void
disconnect_ready (NMModem *self,
GAsyncResult *res,
DeactivateContext *ctx)
{
GError *error = NULL;
if (!NM_MODEM_GET_CLASS (self)->disconnect_finish (self, res, &error)) {
g_simple_async_result_take_error (ctx->result, error);
deactivate_context_complete (ctx);
return;
}
/* Go on */
ctx->step++;
deactivate_step (ctx);
}
NMActStageReturn
nm_modem_act_stage1_prepare (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
NMActStageReturn ret;
GPtrArray *hints = NULL;
const char *setting_name = NULL;
NMSettingsGetSecretsFlags flags = NM_SETTINGS_GET_SECRETS_FLAG_ALLOW_INTERACTION;
if (priv->act_request)
g_object_unref (priv->act_request);
priv->act_request = g_object_ref (req);
ret = NM_MODEM_GET_CLASS (self)->act_stage1_prepare (self,
req,
&hints,
&setting_name,
reason);
if ((ret == NM_ACT_STAGE_RETURN_POSTPONE) && setting_name) {
if (priv->secrets_tries++)
flags |= NM_SETTINGS_GET_SECRETS_FLAG_REQUEST_NEW;
priv->secrets_id = nm_act_request_get_secrets (req,
setting_name,
flags,
hints ? g_ptr_array_index (hints, 0) : NULL,
modem_secrets_cb,
self);
if (priv->secrets_id)
g_signal_emit (self, signals[AUTH_REQUESTED], 0);
else {
*reason = NM_DEVICE_STATE_REASON_NO_SECRETS;
ret = NM_ACT_STAGE_RETURN_FAILURE;
}
if (hints)
g_ptr_array_free (hints, TRUE);
}
return ret;
}
void
nm_modem_set_mm_enabled (NMModem *self,
gboolean enabled)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
NMModemState prev_state = priv->state;
if (enabled && priv->state >= NM_MODEM_STATE_ENABLING) {
nm_log_dbg (LOGD_MB, "(%s): cannot enable modem: already enabled",
nm_modem_get_uid (self));
return;
}
if (!enabled && priv->state <= NM_MODEM_STATE_DISABLING) {
nm_log_dbg (LOGD_MB, "(%s): cannot disable modem: already disabled",
nm_modem_get_uid (self));
return;
}
if (priv->state <= NM_MODEM_STATE_INITIALIZING) {
nm_log_dbg (LOGD_MB, "(%s): cannot enable/disable modem: initializing or failed",
nm_modem_get_uid (self));
return;
} else if (priv->state == NM_MODEM_STATE_LOCKED) {
/* Don't try to enable if the modem is locked since that will fail */
nm_log_warn (LOGD_MB, "(%s): cannot enable/disable modem: locked",
nm_modem_get_uid (self));
/* Try to unlock the modem if it's being enabled */
if (enabled)
g_signal_emit_by_name (self, NM_MODEM_AUTH_REQUESTED, 0);
return;
}
NM_MODEM_GET_CLASS (self)->set_mm_enabled (self, enabled);
/* Pre-empt the state change signal */
nm_modem_set_state (self,
enabled ? NM_MODEM_STATE_ENABLING : NM_MODEM_STATE_DISABLING,
"user preference");
priv->prev_state = prev_state;
}
NMActStageReturn
nm_modem_stage3_ip4_config_start (NMModem *self,
NMDevice *device,
NMDeviceClass *device_class,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv;
NMActRequest *req;
NMActStageReturn ret;
g_return_val_if_fail (self != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (device != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_DEVICE (device), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (device_class != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_DEVICE_CLASS (device_class), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
req = nm_device_get_act_request (device);
g_assert (req);
priv = NM_MODEM_GET_PRIVATE (self);
switch (priv->ip_method) {
case MM_MODEM_IP_METHOD_PPP:
ret = ppp_stage3_ip4_config_start (self, req, reason);
break;
case MM_MODEM_IP_METHOD_STATIC:
ret = NM_MODEM_GET_CLASS (self)->static_stage3_ip4_config_start (self, req, reason);
break;
case MM_MODEM_IP_METHOD_DHCP:
ret = device_class->act_stage3_ip4_config_start (device, NULL, reason);
break;
default:
nm_log_err (LOGD_MB, "unknown IP method %d", priv->ip_method);
ret = NM_ACT_STAGE_RETURN_FAILURE;
break;
}
return ret;
}
void
nm_modem_deactivate (NMModem *self, NMDevice *device)
{
NM_MODEM_GET_CLASS (self)->deactivate (self, device);
}
static NMActStageReturn
ppp_stage3_ip_config_start (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
const char *ppp_name = NULL;
GError *error = NULL;
NMActStageReturn ret;
guint ip_timeout = 30;
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
/* If we're already running PPP don't restart it; for example, if both
* IPv4 and IPv6 are requested, IPv4 gets started first, but we use the
* same pppd for both v4 and v6.
*/
if (priv->ppp_manager)
return NM_ACT_STAGE_RETURN_POSTPONE;
if (NM_MODEM_GET_CLASS (self)->get_user_pass) {
NMConnection *connection = nm_act_request_get_applied_connection (req);
g_assert (connection);
if (!NM_MODEM_GET_CLASS (self)->get_user_pass (self, connection, &ppp_name, NULL))
return NM_ACT_STAGE_RETURN_FAILURE;
}
/* Check if ModemManager requested a specific IP timeout to be used. If 0 reported,
* use the default one (30s) */
if (priv->mm_ip_timeout > 0) {
nm_log_info (LOGD_PPP, "(%s): using modem-specified IP timeout: %u seconds",
nm_modem_get_uid (self),
priv->mm_ip_timeout);
ip_timeout = priv->mm_ip_timeout;
}
priv->ppp_manager = nm_ppp_manager_new (priv->data_port);
if (nm_ppp_manager_start (priv->ppp_manager, req, ppp_name, ip_timeout, &error)) {
g_signal_connect (priv->ppp_manager, NM_PPP_MANAGER_STATE_CHANGED,
G_CALLBACK (ppp_state_changed),
self);
g_signal_connect (priv->ppp_manager, "ip4-config",
G_CALLBACK (ppp_ip4_config),
self);
g_signal_connect (priv->ppp_manager, "ip6-config",
G_CALLBACK (ppp_ip6_config),
self);
g_signal_connect (priv->ppp_manager, "stats",
G_CALLBACK (ppp_stats),
self);
ret = NM_ACT_STAGE_RETURN_POSTPONE;
} else {
nm_log_err (LOGD_PPP, "(%s): error starting PPP: %s",
nm_modem_get_uid (self),
error->message);
g_error_free (error);
nm_exported_object_clear_and_unexport (&priv->ppp_manager);
*reason = NM_DEVICE_STATE_REASON_PPP_START_FAILED;
ret = NM_ACT_STAGE_RETURN_FAILURE;
}
return ret;
}
static NMActStageReturn
ppp_stage3_ip4_config_start (NMModem *self,
NMActRequest *req,
NMDeviceStateReason *reason)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
const char *ppp_name = NULL;
GError *error = NULL;
NMActStageReturn ret;
guint ip_timeout = 20;
g_return_val_if_fail (self != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_MODEM (self), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (req != NULL, NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NM_ACT_STAGE_RETURN_FAILURE);
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
if (NM_MODEM_GET_CLASS (self)->get_user_pass) {
NMConnection *connection = nm_act_request_get_connection (req);
g_assert (connection);
if (!NM_MODEM_GET_CLASS (self)->get_user_pass (self, connection, &ppp_name, NULL))
return NM_ACT_STAGE_RETURN_FAILURE;
}
/* Check if ModemManager requested a specific IP timeout to be used. If 0 reported,
* use the default one (20s) */
if (priv->mm_ip_timeout > 0) {
nm_log_info (LOGD_PPP, "using modem-specified IP timeout: %u seconds",
priv->mm_ip_timeout);
ip_timeout = priv->mm_ip_timeout;
}
priv->ppp_manager = nm_ppp_manager_new (priv->iface);
if (nm_ppp_manager_start (priv->ppp_manager, req, ppp_name, ip_timeout, &error)) {
g_signal_connect (priv->ppp_manager, "state-changed",
G_CALLBACK (ppp_state_changed),
self);
g_signal_connect (priv->ppp_manager, "ip4-config",
G_CALLBACK (ppp_ip4_config),
self);
g_signal_connect (priv->ppp_manager, "stats",
G_CALLBACK (ppp_stats),
self);
ret = NM_ACT_STAGE_RETURN_POSTPONE;
} else {
nm_log_err (LOGD_PPP, "error starting PPP: (%d) %s",
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_error_free (error);
g_object_unref (priv->ppp_manager);
priv->ppp_manager = NULL;
*reason = NM_DEVICE_STATE_REASON_PPP_START_FAILED;
ret = NM_ACT_STAGE_RETURN_FAILURE;
}
return ret;
}
gboolean
nm_modem_check_connection_compatible (NMModem *self, NMConnection *connection)
{
NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
NMSettingConnection *s_con;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
if (g_str_equal (nm_setting_connection_get_connection_type (s_con),
NM_SETTING_GSM_SETTING_NAME)) {
NMSettingGsm *s_gsm;
const char *str;
s_gsm = nm_connection_get_setting_gsm (connection);
if (!s_gsm)
return FALSE;
str = nm_setting_gsm_get_device_id (s_gsm);
if (str) {
if (!priv->device_id) {
nm_log_dbg (LOGD_MB, "(%s): %s/%s has device-id, device does not",
priv->uid,
nm_connection_get_uuid (connection),
nm_connection_get_id (connection));
return FALSE;
}
if (strcmp (str, priv->device_id)) {
nm_log_dbg (LOGD_MB, "(%s): %s/%s device-id mismatch",
priv->uid,
nm_connection_get_uuid (connection),
nm_connection_get_id (connection));
return FALSE;
}
}
/* SIM properties may not be available before the SIM is unlocked, so
* to ensure that autoconnect works, the connection's SIM properties
* are only compared if present on the device.
*/
str = nm_setting_gsm_get_sim_id (s_gsm);
if (str && priv->sim_id) {
if (strcmp (str, priv->sim_id)) {
nm_log_dbg (LOGD_MB, "(%s): %s/%s sim-id mismatch",
priv->uid,
nm_connection_get_uuid (connection),
nm_connection_get_id (connection));
return FALSE;
}
}
str = nm_setting_gsm_get_sim_operator_id (s_gsm);
if (str && priv->sim_operator_id) {
if (strcmp (str, priv->sim_operator_id)) {
nm_log_dbg (LOGD_MB, "(%s): %s/%s sim-operator-id mismatch",
priv->uid,
nm_connection_get_uuid (connection),
nm_connection_get_id (connection));
return FALSE;
}
}
}
if (NM_MODEM_GET_CLASS (self)->check_connection_compatible)
return NM_MODEM_GET_CLASS (self)->check_connection_compatible (self, connection);
return FALSE;
}