void nm_connectivity_set_online (NMConnectivity *self, gboolean online) { #if WITH_CONCHECK NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (online && priv->uri && priv->interval) { if (!priv->check_id) priv->check_id = g_timeout_add_seconds (priv->interval, run_check, self); if (!priv->running) run_check (self); return; } else if (priv->check_id) { g_source_remove (priv->check_id); priv->check_id = 0; } #endif /* Either @online is %TRUE but we aren't checking connectivity, or * @online is %FALSE. Either way we can update our status immediately. */ update_state (self, online ? NM_CONNECTIVITY_FULL : NM_CONNECTIVITY_NONE); }
static void set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); switch (property_id) { case PROP_RUNNING: priv->running = g_value_get_boolean (value); break; case PROP_URI: g_free (priv->uri); priv->uri = sanitize_string_val (value); break; case PROP_INTERVAL: priv->interval = g_value_get_uint (value); break; case PROP_RESPONSE: g_free (priv->response); priv->response = sanitize_string_val (value); break; case PROP_CONNECTED: priv->connected = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static gboolean run_check (gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (user_data); NMConnectivityPrivate *priv; SoupURI *soup_uri; SoupMessage *msg; g_return_val_if_fail (NM_IS_CONNECTIVITY (self), FALSE); priv = NM_CONNECTIVITY_GET_PRIVATE (self); /* check given url async */ soup_uri = soup_uri_new (priv->uri); if (soup_uri && SOUP_URI_VALID_FOR_HTTP (soup_uri)) { msg = soup_message_new_from_uri ("GET", soup_uri); soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT); soup_session_queue_message (priv->soup_session, msg, nm_connectivity_check_cb, self); priv->running = TRUE; g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_RUNNING); nm_log_dbg (LOGD_CORE, "Connectivity check with uri '%s' started.", priv->uri); } else nm_log_err (LOGD_CORE, "Invalid uri '%s' for connectivity check.", priv->uri); if (soup_uri) soup_uri_free (soup_uri); return TRUE; /* keep firing */ }
static void get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); switch (property_id) { case PROP_URI: g_value_set_string (value, priv->uri); break; case PROP_INTERVAL: g_value_set_uint (value, priv->interval); break; case PROP_RESPONSE: g_value_set_string (value, priv->response); break; case PROP_STATE: g_value_set_uint (value, priv->state); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
NMConnectivityState nm_connectivity_get_state (NMConnectivity *connectivity) { g_return_val_if_fail (NM_IS_CONNECTIVITY (connectivity), NM_CONNECTIVITY_UNKNOWN); return NM_CONNECTIVITY_GET_PRIVATE (connectivity)->state; }
void nm_connectivity_check_async (NMConnectivity *self, GAsyncReadyCallback callback, gpointer user_data) { NMConnectivityPrivate *priv; #if WITH_CONCHECK SoupMessage *msg; #endif GSimpleAsyncResult *simple; g_return_if_fail (NM_IS_CONNECTIVITY (self)); priv = NM_CONNECTIVITY_GET_PRIVATE (self); simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, nm_connectivity_check_async); #if WITH_CONCHECK if (priv->uri && priv->interval) { msg = soup_message_new ("GET", priv->uri); soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT); soup_session_queue_message (priv->soup_session, msg, nm_connectivity_check_cb, simple); return; } #endif g_simple_async_result_set_op_res_gssize (simple, priv->state); g_simple_async_result_complete_in_idle (simple); }
static void _reschedule_periodic_checks (NMConnectivity *self, gboolean force_reschedule) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); #if WITH_CONCHECK if (priv->online && priv->uri && priv->interval) { if (force_reschedule || !priv->check_id) { if (priv->check_id) g_source_remove (priv->check_id); priv->check_id = g_timeout_add (0, idle_start_periodic_checks, self); priv->initial_check_obsoleted = FALSE; } } else { if (priv->check_id) { g_source_remove (priv->check_id); priv->check_id = 0; } } if (priv->check_id) return; #endif /* Either @online is %TRUE but we aren't checking connectivity, or * @online is %FALSE. Either way we can update our status immediately. */ update_state (self, priv->online ? NM_CONNECTIVITY_FULL : NM_CONNECTIVITY_NONE); }
static void nm_connectivity_init (NMConnectivity *self) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); priv->soup_session = soup_session_async_new_with_options (SOUP_SESSION_TIMEOUT, 15, NULL); }
gboolean nm_connectivity_get_connected (NMConnectivity *connectivity) { g_return_val_if_fail (NM_IS_CONNECTIVITY (connectivity), FALSE); return NM_CONNECTIVITY_GET_PRIVATE (connectivity)->connected; }
static void set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); const char *uri, *response; guint interval; gboolean changed; switch (property_id) { case PROP_URI: uri = g_value_get_string (value); if (uri && !*uri) uri = NULL; changed = g_strcmp0 (uri, priv->uri) != 0; #if WITH_CONCHECK if (uri) { SoupURI *soup_uri = soup_uri_new (uri); if (!soup_uri || !SOUP_URI_VALID_FOR_HTTP (soup_uri)) { _LOGE ("invalid uri '%s' for connectivity check.", uri); uri = NULL; } if (uri && soup_uri && changed && soup_uri_get_scheme(soup_uri) == SOUP_URI_SCHEME_HTTPS) _LOGW ("use of HTTPS for connectivity checking is not reliable and is discouraged (URI: %s)", uri); if (soup_uri) soup_uri_free (soup_uri); } #endif if (changed) { g_free (priv->uri); priv->uri = g_strdup (uri); _reschedule_periodic_checks (self, TRUE); } break; case PROP_INTERVAL: interval = g_value_get_uint (value); if (priv->interval != interval) { priv->interval = interval; _reschedule_periodic_checks (self, TRUE); } break; case PROP_RESPONSE: response = g_value_get_string (value); if (g_strcmp0 (response, priv->response) != 0) { /* a response %NULL means, NM_CONFIG_DEFAULT_CONNECTIVITY_RESPONSE. Any other response * (including "") is accepted. */ g_free (priv->response); priv->response = g_strdup (response); _reschedule_periodic_checks (self, TRUE); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void update_state (NMConnectivity *self, NMConnectivityState state) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (priv->state != state) { priv->state = state; g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_STATE); } }
static gboolean run_check (gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (user_data); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); nm_connectivity_check_async (self, run_check_complete, NULL); priv->running = TRUE; nm_log_dbg (LOGD_CONCHECK, "Connectivity check with uri '%s' started.", priv->uri); return TRUE; }
void nm_connectivity_stop_check (NMConnectivity *self) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (priv->check_id) { g_source_remove (priv->check_id); priv->check_id = 0; } update_connected (self, FALSE); }
static gboolean idle_start_periodic_checks (gpointer user_data) { NMConnectivity *self = user_data; NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); priv->check_id = g_timeout_add_seconds (priv->interval, run_check, self); if (!priv->initial_check_obsoleted) run_check (self); return FALSE; }
void nm_connectivity_set_online (NMConnectivity *self, gboolean online) { NMConnectivityPrivate *priv= NM_CONNECTIVITY_GET_PRIVATE (self); online = !!online; if (priv->online != online) { _LOGD ("set %s", online ? "online" : "offline"); priv->online = online; _reschedule_periodic_checks (self, FALSE); } }
static void update_state (NMConnectivity *self, NMConnectivityState state) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (priv->state != state) { _LOGD ("state changed from %s to %s", nm_connectivity_state_to_string (priv->state), nm_connectivity_state_to_string (state)); priv->state = state; g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_STATE); } }
void nm_connectivity_check_async (NMConnectivity *self, GAsyncReadyCallback callback, gpointer user_data) { NMConnectivityPrivate *priv; GSimpleAsyncResult *simple; g_return_if_fail (NM_IS_CONNECTIVITY (self)); priv = NM_CONNECTIVITY_GET_PRIVATE (self); simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, nm_connectivity_check_async); #if WITH_CONCHECK if (priv->uri && priv->interval) { SoupMessage *msg; ConCheckCbData *cb_data = g_slice_new (ConCheckCbData); msg = soup_message_new ("GET", priv->uri); soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT); /* Disable HTTP/1.1 keepalive; the connection should not persist */ soup_message_headers_append (msg->request_headers, "Connection", "close"); cb_data->simple = simple; cb_data->uri = g_strdup (priv->uri); cb_data->response = g_strdup (priv->response); /* For internal calls (periodic), remember the check-id at time of scheduling. */ cb_data->check_id_when_scheduled = IS_PERIODIC_CHECK (callback) ? priv->check_id : 0; soup_session_queue_message (priv->soup_session, msg, nm_connectivity_check_cb, cb_data); priv->initial_check_obsoleted = TRUE; _LOGD ("check: send %srequest to '%s'", IS_PERIODIC_CHECK (callback) ? "periodic " : "", priv->uri); return; } else { g_warn_if_fail (!IS_PERIODIC_CHECK (callback)); _LOGD ("check: faking request. Connectivity check disabled"); } #else _LOGD ("check: faking request. Compiled without connectivity-check support"); #endif g_simple_async_result_set_op_res_gssize (simple, priv->state); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); }
static void update_connected (NMConnectivity *self, gboolean connected) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); gboolean old_connected = priv->connected; if (priv->uri == NULL || priv->interval == 0) { /* Default to connected if no checks are to be run */ priv->connected = TRUE; } else priv->connected = connected; if (priv->connected != old_connected) g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_CONNECTED); }
static void nm_connectivity_check_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { GSimpleAsyncResult *simple = user_data; NMConnectivity *self; NMConnectivityPrivate *priv; NMConnectivityState new_state; const char *nm_header; self = NM_CONNECTIVITY (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); g_object_unref (self); priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) { nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' failed with '%s'.", priv->uri, msg->reason_phrase); new_state = NM_CONNECTIVITY_LIMITED; goto done; } /* Check headers; if we find the NM-specific one we're done */ nm_header = soup_message_headers_get_one (msg->response_headers, "X-NetworkManager-Status"); if (g_strcmp0 (nm_header, "online") == 0) { nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' with Status header successful.", priv->uri); new_state = NM_CONNECTIVITY_FULL; } else if (msg->status_code == SOUP_STATUS_OK) { /* check response */ if (msg->response_body->data && (g_str_has_prefix (msg->response_body->data, priv->response))) { nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' successful.", priv->uri); new_state = NM_CONNECTIVITY_FULL; } else { nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' did not match expected response '%s'; assuming captive portal.", priv->uri, priv->response); new_state = NM_CONNECTIVITY_PORTAL; } } else { nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' returned status '%d %s'; assuming captive portal.", priv->uri, msg->status_code, msg->reason_phrase); new_state = NM_CONNECTIVITY_PORTAL; } done: g_simple_async_result_set_op_res_gssize (simple, new_state); g_simple_async_result_complete (simple); update_state (self, new_state); }
static void run_check_complete (GObject *object, GAsyncResult *result, gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); GError *error = NULL; nm_connectivity_check_finish (self, result, &error); priv->running = FALSE; if (error) { nm_log_err (LOGD_CONCHECK, "Connectivity check failed: %s", error->message); g_error_free (error); } }
void nm_connectivity_start_check (NMConnectivity *self) { NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (!priv->uri || !priv->interval) { nm_connectivity_stop_check (self); return; } if (priv->check_id == 0) priv->check_id = g_timeout_add_seconds (priv->interval, run_check, self); /* Start an immediate check */ if (priv->running == FALSE) run_check (self); }
static void dispose (GObject *object) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (priv->soup_session) { soup_session_abort (priv->soup_session); g_object_unref (priv->soup_session); priv->soup_session = NULL; } g_free (priv->uri); g_free (priv->response); if (priv->check_id > 0) { g_source_remove (priv->check_id); priv->check_id = 0; } }
static void dispose (GObject *object) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); g_free (priv->uri); g_free (priv->response); #if WITH_CONCHECK if (priv->soup_session) { soup_session_abort (priv->soup_session); g_clear_object (&priv->soup_session); } if (priv->check_id > 0) { g_source_remove (priv->check_id); priv->check_id = 0; } #endif }
static void nm_connectivity_check_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (user_data); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); SoupURI *soup_uri; gboolean connected_new = FALSE; const char *nm_header; char *uri_string; soup_uri = soup_message_get_uri (msg); uri_string = soup_uri_to_string (soup_uri, FALSE); /* Check headers; if we find the NM-specific one we're done */ nm_header = soup_message_headers_get_one (msg->response_headers, "X-NetworkManager-Status"); if (g_strcmp0 (nm_header, "online") == 0) { nm_log_dbg (LOGD_CORE, "Connectivity check for uri '%s' with Status header successful.", uri_string); connected_new = TRUE; } else { /* check response */ if (msg->response_body->data && (g_str_has_prefix (msg->response_body->data, priv->response))) { nm_log_dbg (LOGD_CORE, "Connectivity check for uri '%s' with expected response '%s' successful.", uri_string, priv->response); connected_new = TRUE; } else { nm_log_dbg (LOGD_CORE, "Connectivity check for uri '%s' with expected response '%s' failed (status %d).", uri_string, priv->response, msg->status_code); } } g_free (uri_string); /* update connectivity and emit signal */ update_connected (self, connected_new); priv->running = FALSE; g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_RUNNING); }
static void set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { NMConnectivity *self = NM_CONNECTIVITY (object); NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self); switch (property_id) { case PROP_URI: g_free (priv->uri); priv->uri = get_non_empty_string_value (value); #if WITH_CONCHECK if (priv->uri) { SoupURI *uri = soup_uri_new (priv->uri); if (!uri || !SOUP_URI_VALID_FOR_HTTP (uri)) { nm_log_err (LOGD_CONCHECK, "Invalid uri '%s' for connectivity check.", priv->uri); g_free (priv->uri); priv->uri = NULL; } } #endif break; case PROP_INTERVAL: priv->interval = g_value_get_uint (value); break; case PROP_RESPONSE: g_free (priv->response); priv->response = get_non_empty_string_value (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void nm_connectivity_check_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { NMConnectivity *self; NMConnectivityPrivate *priv; ConCheckCbData *cb_data = user_data; GSimpleAsyncResult *simple = cb_data->simple; NMConnectivityState new_state; const char *nm_header; const char *uri = cb_data->uri; const char *response = cb_data->response ? cb_data->response : NM_CONFIG_DEFAULT_CONNECTIVITY_RESPONSE; self = NM_CONNECTIVITY (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); /* it is safe to unref @self here, @simple holds yet another reference. */ g_object_unref (self); priv = NM_CONNECTIVITY_GET_PRIVATE (self); if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) { _LOGI ("check for uri '%s' failed with '%s'", uri, msg->reason_phrase); new_state = NM_CONNECTIVITY_LIMITED; goto done; } if (msg->status_code == 511) { _LOGD ("check for uri '%s' returned status '%d %s'; captive portal present.", uri, msg->status_code, msg->reason_phrase); new_state = NM_CONNECTIVITY_PORTAL; } else { /* Check headers; if we find the NM-specific one we're done */ nm_header = soup_message_headers_get_one (msg->response_headers, "X-NetworkManager-Status"); if (g_strcmp0 (nm_header, "online") == 0) { _LOGD ("check for uri '%s' with Status header successful.", uri); new_state = NM_CONNECTIVITY_FULL; } else if (msg->status_code == SOUP_STATUS_OK) { /* check response */ if (msg->response_body->data && g_str_has_prefix (msg->response_body->data, response)) { _LOGD ("check for uri '%s' successful.", uri); new_state = NM_CONNECTIVITY_FULL; } else { _LOGI ("check for uri '%s' did not match expected response '%s'; assuming captive portal.", uri, response); new_state = NM_CONNECTIVITY_PORTAL; } } else { _LOGI ("check for uri '%s' returned status '%d %s'; assuming captive portal.", uri, msg->status_code, msg->reason_phrase); new_state = NM_CONNECTIVITY_PORTAL; } } done: /* Only update the state, if the call was done from external, or if the periodic check * is still the one that called this async check. */ if (!cb_data->check_id_when_scheduled || cb_data->check_id_when_scheduled == priv->check_id) { /* Only update the state, if the URI and response parameters did not change * since invocation. * The interval does not matter for exernal calls, and for internal calls * we don't reach this line if the interval changed. */ if ( !g_strcmp0 (cb_data->uri, priv->uri) && !g_strcmp0 (cb_data->response, priv->response)) update_state (self, new_state); } g_simple_async_result_set_op_res_gssize (simple, new_state); g_simple_async_result_complete (simple); g_object_unref (simple); g_free (cb_data->uri); g_free (cb_data->response); g_slice_free (ConCheckCbData, cb_data); }