Simplify handing of activate; return activate errors

plugins/modemmgr.c

 /*
  *
  *  Connection Manager
  *
  *  Copyright (C) 2010-2011  The Chromium OS Authors. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  *
@@ skipping 127 matching lines @@
 
 };
 
 enum modem_event {
         ME_NO_EVENT,
         ME_PROPERTIES_CHANGED,
         ME_SIGNAL_QUALITY_CHANGED,
         ME_REGISTRATION_STATE_CHANGED,
         ME_ENABLE_SUCCEEDED,
         ME_ENABLE_FAILED,
-        ME_ACTIVATE_SUCCEEDED,
-        ME_ACTIVATE_FAILED,
         ME_REGISTER_SUCCEEDED,
         ME_REGISTER_FAILED,
         ME_DISABLE_SUCCEEDED,
         ME_DISABLE_FAILED,
         ME_GETIP4CONFIG_SUCCEEDED,
         ME_GETIP4CONFIG_FAILED,
         ME_GETINFO_SUCCEEDED,
         ME_GETINFO_FAILED,
         ME_GET_PROPERTIES_SUCCEEDED,
         ME_GET_PROPERTIES_FAILED,
@@ skipping 160 matching lines @@
         task->work = work;
         task->index = 0;
         _DBG_MODEMMGR("%s: %s", modem->dbus_path, task->work->name);
 
         modem_task_run(modem);
         return -EINPROGRESS;
 }
 
 static void modem_enable_task(struct modem_data *);
 static void modem_get_identifiers_task(struct modem_data *);
-static void modem_activate_task(struct modem_data *);
 static void modem_disable_task(struct modem_data *);
 static void modem_get_status_task(struct modem_data *);
 static void modem_get_info_task(struct modem_data *);
 static void modem_connect_task(struct modem_data *);
 static void modem_disconnect_task(struct modem_data *);
 static void modem_get_properties_task(struct modem_data *);
 static void modem_get_gsm_properties_task(struct modem_data *modem);
 static void modem_create_device_task(struct modem_data *);
 static void modem_get_registration_state_task(struct modem_data *);
 static void modem_register_task(struct modem_data *);
 
 static struct modem_task_work initialize_modem_work = {
         "initialize", {
                 modem_get_properties_task,
                 modem_create_device_task,
                 0}};
 
 static struct modem_task_work enable_cdma_modem_work = {
         "enable_cdma", {
                 modem_enable_task,
                 modem_get_status_task,
                 modem_get_identifiers_task,
                 modem_get_info_task,
                 modem_get_registration_state_task,
                 0}};
 
-static struct modem_task_work activate_modem_work = {
-        "activate", {
-                modem_activate_task,
-                modem_get_registration_state_task,
-                0}};
-
 static struct modem_task_work enable_gsm_modem_work = {
         "enable_gsm", {
                 modem_enable_task,
                 modem_register_task,
                 modem_get_status_task,
                 modem_get_identifiers_task,
                 modem_get_gsm_properties_task,
                 modem_get_info_task,
                 modem_get_registration_state_task,
                 0}};
@@ skipping 740 matching lines @@
         enum connman_network_activation_state state,
         enum connman_element_error err)
 {
         struct connman_network *network = get_network(modem);
         if (network != NULL) {
                 modem->activation_state = state;
                 connman_network_set_activation_state(network, state, err);
         }
 }
 
-
 /**
  * modem_activate_reply:
  * @modem: modem object
  * @user_data: pointer to modem_task object
  *
  * Handle the reply from a DBUS activate message.  Certain errors are
  * indicative of the modem already being activated, so if that is the
  * case, we can proceed despite the error.
  */
 
 static void modem_activate_reply(DBusPendingCall *call, void *user_data)
 {
         struct modem_data *modem = (struct modem_data *)user_data;
+        uint32_t status = -1;
+        DBusMessage *reply;
+        DBusError error;
 
-        _DBG_MODEMMGR("activate_reply modem %s", modem->dbus_path);
-        modem_dbus_handle_reply(__func__, call, modem,
-                                ME_ACTIVATE_SUCCEEDED, ME_ACTIVATE_FAILED,
-                                MM_MODEM_ACTIVATED_ERROR,
-                                DBUS_TYPE_INVALID /* no return values */);
+        dbus_error_init(&error);
+
+        reply = dbus_pending_call_steal_reply(call);
+        if (reply == NULL) {
+                CONNMAN_ERROR("%s: Failed steal reply", __func__);
+                goto done_no_reply;
+        }
+
+        if (dbus_set_error_from_message(&error, reply)) {
+                if (g_strcmp0(error.name, MM_MODEM_INITIATED_ERROR) == 0) {
+                        /*
+                         * Activation can take a long while.  We rely
+                         * on a signal to indicate a future state
+                         * change of the modem, or for the modem to
+                         * disappear.  Nothing to do.
+                         */
+                        dbus_message_unref(reply);
+                        return;
+                }
+                CONNMAN_ERROR("DBus Error: %s:%s",
+                              error.name, error.message);
+                goto done;
+        }
+
+        if (dbus_message_get_args(reply, &error,
+                                  DBUS_TYPE_UINT32,
+                                  &status,
+                                  DBUS_TYPE_INVALID) == FALSE) {
+                if (dbus_error_is_set(&error) == TRUE) {
+                        CONNMAN_ERROR("Error retrieving reply argument: %s:%s",
+                                      error.name, error.message);
+                } else {
+                        CONNMAN_ERROR("Reply argument type is not UINT32");
+                }
+        }
+done:
+        dbus_message_unref(reply);
+done_no_reply:
+        if (status != 0) {
+                modem_update_activation_state(modem,
+                     /* FIXME(jglasgow): need to leave state unchanged */
+                     CONNMAN_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED,
+                     convert_activation_error(status));
+        }
+        /*
+         * For the case of status == 0, we rely either on an explicit
+         * signal of the new modem state, or we expect the modem to
+         * disappear, reset itself and come back
+         */
 }
 
 
-/**
- * modem_activate_task:
- * @modem: modem object
- * @task: modem task object
- *
- * Send a DBUS message to activate a modem.  As a task, all failures
- * must be reported via modem_handle_event.
- */
-static void modem_activate_task(struct modem_data *modem)
-{
-        const char *carrier = "";       /* Use modem's default carrier */
-        DBusMessage *message;
-
-        _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
-
-        if (modem_dbus_build_message(modem->owner, MM_MODEM_CDMA_INTERFACE,
-                                     modem->dbus_path, &message,
-                                     MM_MODEM_CDMA_METHOD_ACTIVATE) < 0) {
-                _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
-                modem_handle_event(modem, ME_ACTIVATE_FAILED);
-                return;
-        }
-
-        dbus_message_append_args(message,
-                                 DBUS_TYPE_STRING, &carrier,
-                                 DBUS_TYPE_INVALID);
-
-        modem_update_activation_state(modem,
-                CONNMAN_NETWORK_ACTIVATION_STATE_ACTIVATING,
-                CONNMAN_ELEMENT_ERROR_UNKNOWN);
-
-        if (modem_dbus_send_with_reply(message,
-                                       modem,
-                                       modem_activate_reply,
-                                       ACTIVATE_TIMEOUT_MS) < 0) {
-                _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
-                modem_handle_event(modem, ME_ACTIVATE_FAILED);
-                return;
-        }
-}
-
-
 /**
  * modem_register_reply:
  * @modem: modem object
  * @user_data: pointer to modem_task object
  *
  * Handle the reply from a DBUS register message.
  */
 
 static void modem_register_reply(DBusPendingCall *call, void *user_data)
 {
@@ skipping 1248 matching lines @@
                         return;
                 case ME_DISABLE_SUCCEEDED:
                         modem_set_powered(modem, FALSE);
                         modem->state = MODEM_STATE_DISABLED;
                         modem_task_run(modem);
                         return;
                 case ME_DISABLE_FAILED:
                         modem_set_powered(modem, TRUE);
                         modem_task_completed(&modem);
                         return;
-                case ME_ACTIVATE_SUCCEEDED:
-                        /* dbus signal will update activation state later */
-                        modem_task_run(modem);
-                        return;
-                case ME_ACTIVATE_FAILED:
-                        modem_update_activation_state(modem,
-                                CONNMAN_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED,
-                                CONNMAN_ELEMENT_ERROR_ACTIVATION_FAILED);
-                        modem_task_run(modem);
-                        return;
                 case ME_REGISTER_SUCCEEDED:
                         /*
                          * Do not change state yet,
                          * wait for ME_GET_REGISTRATION_STATE_SUCCEEDED
                          */
                         modem_task_run(modem);
                         return;
                 case ME_REGISTER_FAILED:
                         modem->gsm_registration_state =
                                 MM_MODEM_GSM_NETWORK_REG_STATUS_IDLE;
@@ skipping 76 matching lines @@
                          * create a connman network object and may
                          * auto connect.
                          */
                         modem_task_completed(&modem);
                         if (modem != NULL)
                                 modem_registration_state_change(modem);
                         return;
                 case ME_GET_REGISTRATION_STATE_FAILED:
                         modem_task_completed(&modem);
                         return;
-                case ME_ACTIVATE_SUCCEEDED:
-                        /* dbus signal will update activation state later */
-                        modem_task_run(modem);
-                        return;
-                case ME_ACTIVATE_FAILED:
-                        modem_update_activation_state(modem,
-                                CONNMAN_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED,
-                                CONNMAN_ELEMENT_ERROR_ACTIVATION_FAILED);
-                        modem_task_run(modem);
-                        return;
                 case ME_GET_SIGNALQUALITY_FAILED:
                         /* N.B. We can continue even without signal quality */
                         return;
                 case ME_GET_SIGNALQUALITY_SUCCEEDED:
                 case ME_SIGNAL_QUALITY_CHANGED:
                         modem_update_signal_quality(modem);
                         return;
                 case ME_GETINFO_SUCCEEDED:
                 case ME_GETINFO_FAILED:
                 case ME_GET_PROPERTIES_SUCCEEDED:
@@ skipping 64 matching lines @@
 static const char *eventToString(enum modem_event event)
 {
         static char text[32];
         switch (event) {
         case ME_NO_EVENT: return "NO_EVENT";
         case ME_PROPERTIES_CHANGED: return "PROPERTIES_CHANGED";
         case ME_SIGNAL_QUALITY_CHANGED: return "SIGNAL_QUALITY_CHANGED";
         case ME_REGISTRATION_STATE_CHANGED: return "REGISTRATION_STATE_CHANGED";
         case ME_ENABLE_SUCCEEDED: return "ENABLE_SUCCEEDED";
         case ME_ENABLE_FAILED: return "ENABLE_FAILED";
-        case ME_ACTIVATE_SUCCEEDED: return "ACTIVATE_SUCCEEDED";
-        case ME_ACTIVATE_FAILED: return "ACTIVATE_FAILED";
         case ME_REGISTER_SUCCEEDED: return "REGISTER_SUCCEEDED";
         case ME_REGISTER_FAILED: return "REGISTER_FAILED";
         case ME_DISABLE_SUCCEEDED: return "DISABLE_SUCCEEDED";
         case ME_DISABLE_FAILED: return "DISABLE_FAILED";
         case ME_GETIP4CONFIG_SUCCEEDED: return "GETIP4CONFIG_SUCCEEDED";
         case ME_GETIP4CONFIG_FAILED: return "GETIP4CONFIG_FAILED";
         case ME_GETINFO_SUCCEEDED: return "GETINFO_SUCCEEDED";
         case ME_GETINFO_FAILED: return "GETINFO_FAILED";
         case ME_GET_PROPERTIES_SUCCEEDED: return "GET_PROPERTIES_SUCCEEDED";
         case ME_GET_PROPERTIES_FAILED: return "GET_PROPERTIES_FAILED";
@@ skipping 268 matching lines @@
 }
 
 static void network_remove(struct connman_network *network)
 {
         _DBG_MODEMMGR("network %p", network);
 }
 
 /**
  * Activate the modem on the network.
  *
- * We may need to bring in some upstream changes.
  */
 static int modem_network_activate(struct connman_network *network,
         const char *carrier)
 {
         struct modem_data *modem;
+        DBusMessage *message;
 
         modem = network_get_modem(network, __func__);
         if (modem == NULL) {
                 return -ENODEV;
         }
         if (modem->type != MM_MODEM_TYPE_CDMA) {
                 _DBG_MODEMMGR("Cannot activate non-CDMA modem\n");
                 return -EINVAL;
         }
         switch (modem->state) {
         case MODEM_STATE_ENABLED:
         case MODEM_STATE_REGISTERED:
                 break;
         default:
                 _DBG_MODEMMGR("Cannot activate in state: %s\n",
                               stateToString(modem->state));
                 return -EIO;
         }
-        return modem_task_run_new(modem, &activate_modem_work);
+
+        if (modem_dbus_build_message(modem->owner, MM_MODEM_CDMA_INTERFACE,
+                                     modem->dbus_path, &message,
+                                     MM_MODEM_CDMA_METHOD_ACTIVATE) < 0) {
+                _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
+                return -EIO;
+        }
+
+        _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
+        dbus_message_append_args(message,
+                                 DBUS_TYPE_STRING, &carrier,
+                                 DBUS_TYPE_INVALID);
+
+        if (modem_dbus_send_with_reply(message,
+                                       modem,
+                                       modem_activate_reply,
+                                       ACTIVATE_TIMEOUT_MS) < 0) {
+                _DBG_MODEMMGR("activate modem %s", modem->dbus_path);
+                return -EIO;
+        }
+        modem_update_activation_state(modem,
+                CONNMAN_NETWORK_ACTIVATION_STATE_ACTIVATING,
+                CONNMAN_ELEMENT_ERROR_UNKNOWN);
+
+        return 0;
 }
 
 static struct connman_network_driver network_driver = {
         .name           = "network",
         .type           = CONNMAN_NETWORK_TYPE_CELLULAR,
         .probe          = network_probe,
         .remove         = network_remove,
         .connect        = network_connect,
         .disconnect     = network_disconnect,
         /* .setup               = network_setup,  upstream */
@@ skipping 273 matching lines @@
                                 &extract_err)) {
                         struct connman_network *network = get_network(modem);
                         if (network != NULL)
                                 connman_network_set_olp_url(network,
                                                             olp_url);
                         g_free(modem->olp_url);
                         modem->olp_url = g_strdup(olp_url);
                 }
                 dbus_message_iter_next(&dict);
         }