Enhance portal check code to return connectivity_state

src/service.c

 /*
  *
  *  Connection Manager
  *
  *  Copyright (C) 2007-2009  Intel Corporation. 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 47 matching lines @@
         connman_bool_t autoconnect;
         connman_bool_t userconnect;
         connman_bool_t active;
         GTimeVal modified;
         char *name;
         char *passphrase;
         char *identity;
         char *certpath;
         char *authpath;
         char *profile;
+        enum connman_service_connectivity_state connectivity_state;

[Eric Shienbrood, 2010/11/19 17:52:56]

Can you move this up to be with the other enums?

[Jason Glasgow, 2010/11/19 19:48:19]

Done.

 
         /* TODO(sleffler) overlay storage */
         struct {
                 char *operator_name;
                 char *operator_code;
                 char *olp_url;
                 char *usage_url;
                 enum connman_network_activation_state activation_state;
                 enum connman_network_cellular_technology network_technology;
                 enum connman_network_cellular_roaming_state roaming_state;
-                connman_bool_t restricted_pool;
         } cellular;
         struct {
                 unsigned int wep_key_len;
                 connman_uint8_t wep_key_idx;
                 connman_uint8_t wep_key_matter[MAX_WEP_KEYSPACE];
                 connman_bool_t hidden_ssid;
         } wifi;
 
         struct connman_device *device;
         struct connman_network *network;
@@ skipping 332 matching lines @@
         case CONNMAN_NETWORK_ROAMING_STATE_UNKNOWN:
                 return "unknown";
         case CONNMAN_NETWORK_ROAMING_STATE_HOME:
                 return "home";
         case CONNMAN_NETWORK_ROAMING_STATE_ROAMING:
                 return "roaming";
         }
         return NULL;
 }
 
+static const char *connectivity_state2string(
+        enum connman_service_connectivity_state connectivity)
+{
+        switch(connectivity) {
+        case CONNMAN_SERVICE_CONNECTIVITY_STATE_UNKNOWN:
+                return "unknown";
+        case CONNMAN_SERVICE_CONNECTIVITY_STATE_UNRESTRICTED:
+                return "unrestricted";
+        case CONNMAN_SERVICE_CONNECTIVITY_STATE_RESTRICTED:
+                return "restricted";
+        case CONNMAN_SERVICE_CONNECTIVITY_STATE_NONE:
+                return "none";
+        }
+        return NULL;
+}
+
 static struct connman_service *get_active_service(void)
 {
         struct connman_service *service;
         GSequenceIter *iter;
 
         iter = g_sequence_get_begin_iter(service_list);
 
         if (g_sequence_iter_is_end(iter) == TRUE) {
                 _DBG_SERVICE("no services");
                 return NULL;
@@ skipping 221 matching lines @@
                 connman_dbus_dict_append_variant(&dict, "AutoConnect",
                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 
         connman_dbus_dict_append_variant(&dict, "IsActive",
                                          DBUS_TYPE_BOOLEAN, &service->active);
 
         if (service->name != NULL)
                 connman_dbus_dict_append_variant(&dict, "Name",
                                         DBUS_TYPE_STRING, &service->name);
 
+        str = connectivity_state2string(service->connectivity_state);
+        if (str != NULL)
+                connman_dbus_dict_append_variant(&dict, "ConnectivityState",
+                                                 DBUS_TYPE_STRING, &str);
+
         device = connman_service_get_device(service);
         if (device != NULL) {
                 const char *path = connman_device_get_path(device);
                 if (path != NULL)
                         connman_dbus_dict_append_variant(&dict, "Device",
                                         DBUS_TYPE_OBJECT_PATH, &path);
         }
 
         switch (service->type) {
         case CONNMAN_SERVICE_TYPE_UNKNOWN:
@@ skipping 40 matching lines @@
                 if (service->cellular.olp_url != NULL) {
                         connman_dbus_dict_append_variant(&dict,
                                 "Cellular.OlpUrl", DBUS_TYPE_STRING,
                                 &service->cellular.olp_url);
                 }
                 if (service->cellular.usage_url != NULL) {
                         connman_dbus_dict_append_variant(&dict,
                                 "Cellular.UsageUrl", DBUS_TYPE_STRING,
                                 &service->cellular.usage_url);
                 }
-                connman_dbus_dict_append_variant(&dict,
-                         "Cellular.RestrictedPool", DBUS_TYPE_BOOLEAN,
-                         &service->cellular.restricted_pool);
                 break;
         case CONNMAN_SERVICE_TYPE_WIFI:
                 connman_dbus_dict_append_variant(&dict, "WiFi.HiddenSSID",
                         DBUS_TYPE_BOOLEAN, &service->wifi.hidden_ssid);
 
                 if (service->network != NULL) {
                         connman_uint16_t frequency;
                         enum connman_network_phymode phymode;
 
                         frequency = connman_network_get_uint16(service->network,
@@ skipping 855 matching lines @@
         }
         if (oroam != roaming_state && roam_str != NULL) {
                 (void) connman_dbus_send_property_changed_variant(
                                 service->path,
                                 CONNMAN_SERVICE_INTERFACE,
                                 "Cellular.RoamingState",
                                 DBUS_TYPE_STRING, &roam_str);
         }
 }
 
-void connman_service_set_restricted_pool(struct connman_service *service,
-                                         connman_bool_t restricted)
+void connman_service_set_connectivity_state(struct connman_service *service,
+      enum connman_service_connectivity_state connectivity)
 {
-        connman_bool_t orestricted = service->cellular.restricted_pool;
-        service->cellular.restricted_pool = restricted;
-        if (orestricted != restricted)
+        enum connman_service_connectivity_state
+                oconnectivity = service->connectivity_state;
+        const char *state_str = connectivity_state2string(connectivity);
+
+        service->connectivity_state = connectivity;
+        if (oconnectivity != connectivity)
                 (void) connman_dbus_send_property_changed_variant(
                                 service->path,
                                 CONNMAN_SERVICE_INTERFACE,
-                                "Cellular.RestrictedPool",
-                                DBUS_TYPE_BOOLEAN, &restricted);
+                                "ConnectivityState",

[Eric Shienbrood, 2010/11/19 17:52:56]

Can you update service-api.txt to document this property, and remove the
description of RestrictedPool?

[Jason Glasgow, 2010/11/19 19:48:19]

Thank you.
Done.

+                                DBUS_TYPE_STRING, &state_str);
 }
 
 static void remove_timeout(struct connman_service *service)
 {
         if (service->timeout > 0) {
                 gboolean ret = g_source_remove(service->timeout);
                 DBG(DBG_SERVICE | DBG_WIFI, "service %p timeout %d ret %d",
                         service, service->timeout, ret);
 
                 service->timeout = 0;
@@ skipping 2323 matching lines @@
         service_list = NULL;
 
         g_hash_table_destroy(service_hash);
         service_hash = NULL;
 
         connman_storage_unregister(&service_storage);
         connman_notifier_unregister(&service_notifier);
 
         dbus_connection_unref(connection);
 }