static void
real_connection_secrets_updated (NMDevice *device,
NMConnection *connection,
GSList *updated_settings,
RequestSecretsCaller caller)
{
NMDeviceModemPrivate *priv = NM_DEVICE_MODEM_GET_PRIVATE (device);
NMActRequest *req;
g_return_if_fail (IS_ACTIVATING_STATE (nm_device_get_state (device)));
req = nm_device_get_act_request (device);
g_assert (req);
if (!nm_modem_connection_secrets_updated (priv->modem,
req,
connection,
updated_settings,
caller)) {
nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS);
return;
}
/* PPP handles stuff itself... */
if (caller == SECRETS_CALLER_PPP)
return;
/* Otherwise, on success for modem secrets we need to schedule stage1 again */
g_return_if_fail (nm_device_get_state (device) == NM_DEVICE_STATE_NEED_AUTH);
nm_device_activate_schedule_stage1_device_prepare (device);
}
static void
real_connection_secrets_updated (NMDevice *device,
NMConnection *connection,
GSList *updated_settings,
RequestSecretsCaller caller)
{
NMDeviceBt *self = NM_DEVICE_BT (device);
NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (self);
NMActRequest *req;
NMDeviceStateReason reason = NM_DEVICE_STATE_REASON_NONE;
g_return_if_fail (IS_ACTIVATING_STATE (nm_device_get_state (device)));
req = nm_device_get_act_request (device);
g_assert (req);
if (!nm_modem_connection_secrets_updated (priv->modem,
req,
connection,
updated_settings,
caller)) {
nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS);
return;
}
/* PPP handles stuff itself... */
if (caller == SECRETS_CALLER_PPP)
return;
/* Otherwise, on success for GSM/CDMA secrets we need to schedule modem stage1 again */
g_return_if_fail (nm_device_get_state (device) == NM_DEVICE_STATE_NEED_AUTH);
if (!modem_stage1 (self, priv->modem, &reason))
nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_FAILED, reason);
}
void
nm_modem_device_state_changed (NMModem *self,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason)
{
gboolean was_connected = FALSE;
NMModemPrivate *priv;
g_return_if_fail (self != NULL);
g_return_if_fail (NM_IS_MODEM (self));
if (IS_ACTIVATING_STATE (old_state) || (old_state == NM_DEVICE_STATE_ACTIVATED))
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_NEED_AUTH:
if (priv->ppp_manager)
break;
/* else fall through */
case NM_DEVICE_STATE_UNMANAGED:
case NM_DEVICE_STATE_UNAVAILABLE:
case NM_DEVICE_STATE_FAILED:
case NM_DEVICE_STATE_DISCONNECTED:
if (new_state != NM_DEVICE_STATE_NEED_AUTH) {
if (priv->act_request) {
cancel_get_secrets (self);
g_object_unref (priv->act_request);
priv->act_request = NULL;
}
}
if (was_connected) {
dbus_g_proxy_begin_call (nm_modem_get_proxy (self, MM_DBUS_INTERFACE_MODEM),
"Disconnect",
disconnect_done,
self,
NULL,
G_TYPE_INVALID);
}
break;
default:
break;
}
}
static void
device_state_changed (NMDevice *device,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason,
gpointer user_data)
{
NMPolicy *policy = (NMPolicy *) user_data;
NMConnection *connection = get_device_connection (device);
switch (new_state) {
case NM_DEVICE_STATE_FAILED:
/* Mark the connection invalid if it failed during activation so that
* it doesn't get automatically chosen over and over and over again.
*/
if (connection && IS_ACTIVATING_STATE (old_state)) {
g_object_set_data (G_OBJECT (connection), INVALID_TAG, GUINT_TO_POINTER (TRUE));
nm_log_info (LOGD_DEVICE, "Marking connection '%s' invalid.", get_connection_id (connection));
nm_connection_clear_secrets (connection);
}
schedule_activate_check (policy, device, 3);
break;
case NM_DEVICE_STATE_ACTIVATED:
if (connection) {
/* Clear the invalid tag on the connection */
g_object_set_data (G_OBJECT (connection), INVALID_TAG, NULL);
/* And clear secrets so they will always be requested from the
* settings service when the next connection is made.
*/
nm_connection_clear_secrets (connection);
}
update_routing_and_dns (policy, FALSE);
break;
case NM_DEVICE_STATE_UNMANAGED:
case NM_DEVICE_STATE_UNAVAILABLE:
case NM_DEVICE_STATE_DISCONNECTED:
update_routing_and_dns (policy, FALSE);
schedule_activate_check (policy, device, 0);
break;
default:
break;
}
}
static void
wmx_connect_result_cb (struct wmxsdk *wmxsdk,
WIMAX_API_NETWORK_CONNECTION_RESP result,
void *user_data)
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (user_data);
NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
NMDeviceState state;
state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (self));
if (IS_ACTIVATING_STATE (state)) {
priv->connect_failed = (result == WIMAX_API_CONNECTION_SUCCESS);
/* Wait for the state change so we can get the reason code; we
* cache the connect failure so we don't have to wait for the
* activation timeout.
*/
}
}
static void
wmx_state_change_cb (struct wmxsdk *wmxsdk,
WIMAX_API_DEVICE_STATUS new_status,
WIMAX_API_DEVICE_STATUS old_status,
WIMAX_API_STATUS_REASON reason,
void *user_data)
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (user_data);
NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
NMDeviceState state;
const char *iface;
gboolean old_available = FALSE;
const char *nsp_name = NULL;
if (new_status == old_status)
return;
iface = nm_device_get_iface (NM_DEVICE (self));
state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (self));
old_available = nm_device_is_available (NM_DEVICE (self));
priv->status = new_status;
if (priv->current_nsp)
nsp_name = nm_wimax_nsp_get_name (priv->current_nsp);
nm_log_dbg (LOGD_WIMAX, "(%s): wimax state change %s -> %s (reason %d)",
iface,
iwmx_sdk_dev_status_to_str (old_status),
iwmx_sdk_dev_status_to_str (new_status),
reason);
switch (new_status) {
case WIMAX_API_DEVICE_STATUS_UnInitialized:
case WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW:
case WIMAX_API_DEVICE_STATUS_RF_OFF_HW:
case WIMAX_API_DEVICE_STATUS_RF_OFF_SW:
if (priv->wimaxd_enabled) {
priv->wimaxd_enabled = FALSE;
if (update_availability (self, old_available))
return;
}
break;
case WIMAX_API_DEVICE_STATUS_Connecting:
case WIMAX_API_DEVICE_STATUS_Data_Connected:
/* If for some reason we're initially connected, force a disconnect here */
if (state < NM_DEVICE_STATE_DISCONNECTED)
force_disconnect (self, wmxsdk);
/* Fall through */
case WIMAX_API_DEVICE_STATUS_Ready:
case WIMAX_API_DEVICE_STATUS_Scanning:
if (priv->wimaxd_enabled == FALSE) {
priv->wimaxd_enabled = TRUE;
if (update_availability (self, old_available))
return;
}
break;
default:
nm_log_warn (LOGD_WIMAX, "(%s): unhandled WiMAX device state %d",
iface, new_status);
break;
}
/* Handle activation success and failure */
if (IS_ACTIVATING_STATE (state)) {
if (new_status == WIMAX_API_DEVICE_STATUS_Data_Connected) {
/* Success */
clear_activation_timeout (self);
nm_log_info (LOGD_WIMAX, "(%s): connected to '%s'",
iface, nsp_name);
nm_device_activate_schedule_stage3_ip_config_start (NM_DEVICE (self));
return;
}
if (priv->connect_failed) {
/* Connection attempt failed */
nm_log_info (LOGD_WIMAX, "(%s): connection to '%s' failed: (%d) %s",
iface, nsp_name, reason, iwmx_sdk_reason_to_str (reason));
nm_device_state_changed (NM_DEVICE (self),
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
return;
}
}
/* Handle disconnection */
if (state == NM_DEVICE_STATE_ACTIVATED) {
if ( old_status == WIMAX_API_DEVICE_STATUS_Data_Connected
&& new_status < WIMAX_API_DEVICE_STATUS_Connecting) {
nm_log_info (LOGD_WIMAX, "(%s): disconnected from '%s': (%d) %s",
iface, nsp_name, reason, iwmx_sdk_reason_to_str (reason));
nm_device_state_changed (NM_DEVICE (self),
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_CONFIG_FAILED);
}
}
}
