Enhance portal check code to return connectivity_state

plugins/portal_check.c

 /*
  *  Portal Check - Determines if a user is in an IP restrict pool or behind a
  *                 captive portal.
  *
  *  This file initially created by Google, Inc.
  *
  *  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 69 matching lines @@
  */
 static long get_http_code(CURL *curl_handle)
 {
         long http_code = 0;
         curl_easy_getinfo (curl_handle, CURLINFO_RESPONSE_CODE, &http_code);
         _DBG_PORTAL("http response code is %d", (int) http_code);
         return http_code;
 }
 
 /**
- * Returns true iff we received an HTTP 204.
+ * Returns a connectivity state based on the status of an HTTP request
+ * to kGoogle204Url
  */
-static gboolean check_ip_pool(CURLMsg *request_status)
+static enum connman_service_connectivity_state check_connectivity_state(
+        CURLMsg *request_status)
 {
-        // Check the request state
+        CURLcode code = (CURLcode)request_status->data.result;
+
+        /* Check the request state */
         _DBG_PORTAL("curl code is %d", (int)request_status->data.result);
-        if (CURLE_OK == (CURLcode)request_status->data.result) {
+        if (CURLE_COULDNT_RESOLVE_HOST == code) {
+                /*
+                 * TODO(jglasgow): test resolving the address of the
+                 * captive portal web server instead
+                 */
+                _DBG_PORTAL("Cannot resolve %s", kGoogle204Url);
+                return CONNMAN_SERVICE_CONNECTIVITY_STATE_NONE;
+        }
+
+        if (CURLE_OK == code) {
                 if (get_http_code(request_status->easy_handle) == 204) {
                         _DBG_PORTAL("The user can route traffic");
-                        return FALSE;
+                        return CONNMAN_SERVICE_CONNECTIVITY_STATE_UNRESTRICTED;
                 }
         }
         _DBG_PORTAL("We're in an IP restrict pool");
-        return TRUE;
+        return CONNMAN_SERVICE_CONNECTIVITY_STATE_RESTRICTED;
 }
 
 /**
  * Calls curl_multi_perform until CURLM_CALL_MULTI_PERFORM is no longer
  * returned.
  */
 static void handle_multi_perform()
 {
-        // Multi perform may need to be called multiple times to set
-        // the request up successfully.
+        /*
+         * Multi perform may need to be called multiple times to set
+         * the request up successfully.
+         */
         CURLMcode err;
         do {
                 err = curl_multi_perform(curl_multi_handle_,
                                 &pending_requests_);
                 _DBG_PORTAL("Calling multi perform");
         } while (CURLM_CALL_MULTI_PERFORM == err);
 
         if (err != CURLM_OK) {
                 connman_error("%s: curl_multi_perform() = %s", __func__,
                               curl_multi_strerror(err));
         }
 }
 
 /**
  * Processes all currently queued libcurl requests.
  *
  * Returns TRUE if there are pending requests.  Returning true re-arms
  * the timer and causes this function to be called again.
  */
 static gboolean pending_request_callback(gpointer data)
 {
         int remaining_updates;
         CURLMsg* request_status;
+        struct portal_request *portal_request = NULL;
+        struct connman_service *service;
 
         _DBG_PORTAL("callback fired, %d jobs remain", pending_requests_);
 
         handle_multi_perform();
 
         request_status =
                 curl_multi_info_read(curl_multi_handle_, &remaining_updates);
 
-        if (request_status != NULL && CURLMSG_DONE == request_status->msg) {
-                struct portal_request *portal_request = NULL;
-                struct connman_service *service;
+        if (request_status == NULL || CURLMSG_DONE != request_status->msg) {
+                _DBG_PORTAL("remaining status is %d", remaining_updates);
+                return TRUE;
+        }
 
-                curl_easy_getinfo(request_status->easy_handle, CURLINFO_PRIVATE,
-                                  (char **)&portal_request);
-                service = portal_request->service;
 
-                _DBG_PORTAL("service = %s",
-                            connman_service_get_identifier(service));
+        curl_easy_getinfo(request_status->easy_handle, CURLINFO_PRIVATE,
+                          (char **)&portal_request);
+        service = portal_request->service;
 
-                if (portal_request == latest_request) {
-                        gboolean restricted = check_ip_pool(request_status);
+        _DBG_PORTAL("service = %s", connman_service_get_identifier(service));
 
-                        connman_service_set_restricted_pool(service, restricted);
-                } else {
-                        _DBG_PORTAL("Ignoring stale results");
-                }
-                curl_multi_remove_handle(curl_multi_handle_,
-                                         request_status->easy_handle);
-                free_request(portal_request);
-                _DBG_PORTAL("Cancelling the timer");
-                return FALSE;
+        if (portal_request == latest_request) {
+                enum connman_service_connectivity_state state =
+                        check_connectivity_state(request_status);
+
+                connman_service_set_connectivity_state(service, state);
+
+        } else {
+                _DBG_PORTAL("Ignoring stale results");
         }
-        _DBG_PORTAL("remaining status is %d", remaining_updates);
-        return TRUE;
+        curl_multi_remove_handle(curl_multi_handle_,
+                                 request_status->easy_handle);
+        free_request(portal_request);
+        _DBG_PORTAL("Cancelling the timer");
+        return FALSE;
 }
 
 /**
  * Returns TRUE if the new default route is connected via cellular.
  */
 static gboolean should_process_request(struct connman_service *service) {
         if (service == NULL) {
                 _DBG_PORTAL("Skipping portal check for NULL service");
                 return FALSE;
         }
@@ skipping 95 matching lines @@
         }
 
         mcode = curl_multi_add_handle(curl_multi_handle_, request_handle);
         if (mcode != CURLM_OK) {
                 connman_error("%s: curl_multi_add_handle() = %s", __func__,
                               curl_multi_strerror(mcode));
                 goto error;
         }
         handle_multi_perform();
 
-        // The timer will fire once per second until the request
-        // has been processed.
-        //
-        // TODO(rtc): Consider using fd_sets instead.
+        /*
+         * The timer will fire once per second until the request
+         * has been processed.
+         *
+         * TODO(rtc): Consider using fd_sets instead.
+         */
         g_timeout_add_seconds(1, pending_request_callback, NULL);
         return;
 
 error:
         free_request(portal_request);
 }
 
 /**
  * If the service transitions to not ready clear the restricted IP
  * pool flag.
  */
 void portal_service_state_changed(struct connman_service *service)
 {
         const char *service_type = connman_service_get_type(service);
         const char *service_state = connman_service_get_state(service);
 
         if (g_strcmp0(service_type, "cellular") != 0) {
                 return;
         }
 
         if (g_strcmp0(service_state, "ready") != 0) {
-                _DBG_PORTAL("%s: Clearing restricted pool flag, not ready",
+                _DBG_PORTAL("%s: Setting connectivity state unknown, not ready",
                             connman_service_get_identifier(service));
-                connman_service_set_restricted_pool(service, FALSE);
+                connman_service_set_connectivity_state(service,
+                        CONNMAN_SERVICE_CONNECTIVITY_STATE_UNKNOWN);
         }
 }
 
 static struct connman_notifier portal_notifier = {
         .name                   = "portal",
         .priority               = CONNMAN_NOTIFIER_PRIORITY_LOW,
         .default_changed        = portal_default_changed,
         .service_state_changed  = portal_service_state_changed,
 };
 
@@ skipping 15 matching lines @@
 }
 
 static void portal_finis(void)
 {
         connman_notifier_unregister(&portal_notifier);
         curl_multi_cleanup(curl_multi_handle_);
 }
 
 CONNMAN_PLUGIN_DEFINE(portal_check, "Chrome OS metrics plugin", VERSION,
         CONNMAN_PLUGIN_PRIORITY_DEFAULT, portal_init, portal_finis)