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; } }
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 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 gboolean run_check (gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (user_data); nm_connectivity_check_async (self, run_check_complete, NULL); return TRUE; }
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; }
static void run_check_complete (GObject *object, GAsyncResult *result, gpointer user_data) { NMConnectivity *self = NM_CONNECTIVITY (object); GError *error = NULL; nm_connectivity_check_finish (self, result, &error); if (error) { _LOGE ("check failed: %s", error->message); g_error_free (error); } }
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); } }
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); }