---
src/main.c | 2 +-
src/nm-policy.c | 389 ++++++++++++++++++++++++++++++++-----------------------
src/nm-policy.h | 21 +++-
3 files changed, 246 insertions(+), 166 deletions(-)
diff --git a/src/main.c b/src/main.c
index 328c253..109b352 100644
--- a/src/main.c
+++ b/src/main.c
@@ -778,7 +778,7 @@ main (int argc, char *argv[])
done:
if (policy)
- nm_policy_destroy (policy);
+ g_object_unref (policy);
if (manager)
g_object_unref (manager);
diff --git a/src/nm-policy.c b/src/nm-policy.c
index 20729fd..f84306a 100644
--- a/src/nm-policy.c
+++ b/src/nm-policy.c
@@ -48,7 +48,8 @@
#include "nm-policy-hostname.h"
#include "nm-manager-auth.h"
-struct NMPolicy {
+typedef struct {
+ gboolean disposed;
NMManager *manager;
guint update_state_id;
GSList *pending_activation_checks;
@@ -71,7 +72,12 @@ struct NMPolicy {
char *orig_hostname; /* hostname at NM start time */
char *cur_hostname; /* hostname we want to assign */
-};
+} NMPolicyPrivate;
+
+
+G_DEFINE_TYPE (NMPolicy, nm_policy, G_TYPE_OBJECT)
+
+#define NM_POLICY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o),
NM_TYPE_POLICY, NMPolicyPrivate))
#define RETRIES_TAG "autoconnect-retries"
#define RETRIES_DEFAULT 4
@@ -227,23 +233,25 @@ get_best_ip6_device (NMManager *manager, NMActRequest
**out_req)
}
static void
-_set_hostname (NMPolicy *policy,
+_set_hostname (NMPolicy *self,
gboolean change_hostname,
const char *new_hostname,
const char *msg)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
+
if (change_hostname) {
NMDnsManager *dns_mgr;
- g_free (policy->cur_hostname);
- policy->cur_hostname = g_strdup (new_hostname);
+ g_free (priv->cur_hostname);
+ priv->cur_hostname = g_strdup (new_hostname);
dns_mgr = nm_dns_manager_get (NULL);
- nm_dns_manager_set_hostname (dns_mgr, policy->cur_hostname);
+ nm_dns_manager_set_hostname (dns_mgr, priv->cur_hostname);
g_object_unref (dns_mgr);
}
- if (nm_policy_set_system_hostname (policy->cur_hostname, msg))
+ if (nm_policy_set_system_hostname (priv->cur_hostname, msg))
nm_utils_call_dispatcher ("hostname", NULL, NULL, NULL, NULL,
NULL);
}
@@ -253,36 +261,38 @@ lookup_callback (HostnameThread *thread,
const char *hostname,
gpointer user_data)
{
- NMPolicy *policy = (NMPolicy *) user_data;
+ NMPolicy *self = (NMPolicy *) user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
char *msg;
/* Update the hostname if the calling lookup thread is the in-progress
one */
- if (!hostname_thread_is_dead (thread) && (thread == policy->lookup)) {
- policy->lookup = NULL;
+ if (!hostname_thread_is_dead (thread) && (thread == priv->lookup)) {
+ priv->lookup = NULL;
if (!hostname) {
/* Fall back to localhost.localdomain */
msg = g_strdup_printf ("address lookup failed: %d",
result);
- _set_hostname (policy, TRUE, NULL, msg);
+ _set_hostname (self, TRUE, NULL, msg);
g_free (msg);
} else
- _set_hostname (policy, TRUE, hostname, "from address
lookup");
+ _set_hostname (self, TRUE, hostname, "from address
lookup");
}
hostname_thread_free (thread);
}
static void
-update_system_hostname (NMPolicy *policy, NMDevice *best4, NMDevice *best6)
+update_system_hostname (NMPolicy *self, NMDevice *best4, NMDevice *best6)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
char *configured_hostname = NULL;
NMActRequest *best_req4 = NULL;
NMActRequest *best_req6 = NULL;
const char *dhcp_hostname, *p;
- g_return_if_fail (policy != NULL);
+ g_return_if_fail (self != NULL);
- if (policy->lookup) {
- hostname_thread_kill (policy->lookup);
- policy->lookup = NULL;
+ if (priv->lookup) {
+ hostname_thread_kill (priv->lookup);
+ priv->lookup = NULL;
}
/* Hostname precedence order:
@@ -295,24 +305,24 @@ update_system_hostname (NMPolicy *policy, NMDevice
*best4, NMDevice *best6)
*/
/* Try a persistent hostname first */
- g_object_get (G_OBJECT (policy->manager), NM_MANAGER_HOSTNAME,
&configured_hostname, NULL);
+ g_object_get (G_OBJECT (priv->manager), NM_MANAGER_HOSTNAME,
&configured_hostname, NULL);
if (configured_hostname) {
- _set_hostname (policy, TRUE, configured_hostname, "from system
configuration");
+ _set_hostname (self, TRUE, configured_hostname, "from system
configuration");
g_free (configured_hostname);
return;
}
/* Try automatically determined hostname from the best device's IP
config */
if (!best4)
- best4 = get_best_ip4_device (policy->manager, &best_req4);
+ best4 = get_best_ip4_device (priv->manager, &best_req4);
if (!best6)
- best6 = get_best_ip6_device (policy->manager, &best_req6);
+ best6 = get_best_ip6_device (priv->manager, &best_req6);
if (!best4 && !best6) {
/* No best device; fall back to original hostname or if there
wasn't
* one, 'localhost.localdomain'
*/
- _set_hostname (policy, TRUE, policy->orig_hostname, "no default
device");
+ _set_hostname (self, TRUE, priv->orig_hostname, "no default
device");
return;
}
@@ -327,7 +337,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
/* Sanity check; strip leading spaces */
while (*p) {
if (!isblank (*p++)) {
- _set_hostname (policy, TRUE,
p-1, "from DHCPv4");
+ _set_hostname (self, TRUE, p-1,
"from DHCPv4");
return;
}
}
@@ -346,7 +356,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
/* Sanity check; strip leading spaces */
while (*p) {
if (!isblank (*p++)) {
- _set_hostname (policy, TRUE,
p-1, "from DHCPv6");
+ _set_hostname (self, TRUE, p-1,
"from DHCPv6");
return;
}
}
@@ -359,8 +369,8 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
/* If no automatically-configured hostname, try using the hostname from
* when NM started up.
*/
- if (policy->orig_hostname) {
- _set_hostname (policy, TRUE, policy->orig_hostname, "from
system startup");
+ if (priv->orig_hostname) {
+ _set_hostname (self, TRUE, priv->orig_hostname, "from system
startup");
return;
}
@@ -376,7 +386,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
|| (nm_ip4_config_get_num_nameservers (ip4_config) == 0)
|| (nm_ip4_config_get_num_addresses (ip4_config) == 0)) {
/* No valid IP4 config (!!); fall back to
localhost.localdomain */
- _set_hostname (policy, TRUE, NULL, "no IPv4 config");
+ _set_hostname (self, TRUE, NULL, "no IPv4 config");
return;
}
@@ -384,7 +394,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
g_assert (addr4); /* checked for > 1 address above */
/* Start the hostname lookup thread */
- policy->lookup = hostname4_thread_new
(nm_ip4_address_get_address (addr4), lookup_callback, policy);
+ priv->lookup = hostname4_thread_new (nm_ip4_address_get_address
(addr4), lookup_callback, self);
} else if (best6) {
NMIP6Config *ip6_config;
NMIP6Address *addr6;
@@ -394,7 +404,7 @@ update_system_hostname (NMPolicy *policy, NMDevice *best4,
NMDevice *best6)
|| (nm_ip6_config_get_num_nameservers (ip6_config) == 0)
|| (nm_ip6_config_get_num_addresses (ip6_config) == 0)) {
/* No valid IP6 config (!!); fall back to
localhost.localdomain */
- _set_hostname (policy, TRUE, NULL, "no IPv6 config");
+ _set_hostname (self, TRUE, NULL, "no IPv6 config");
return;
}
@@ -402,18 +412,19 @@ update_system_hostname (NMPolicy *policy, NMDevice
*best4, NMDevice *best6)
g_assert (addr6); /* checked for > 1 address above */
/* Start the hostname lookup thread */
- policy->lookup = hostname6_thread_new
(nm_ip6_address_get_address (addr6), lookup_callback, policy);
+ priv->lookup = hostname6_thread_new (nm_ip6_address_get_address
(addr6), lookup_callback, self);
}
- if (!policy->lookup) {
+ if (!priv->lookup) {
/* Fall back to 'localhost.localdomain' */
- _set_hostname (policy, TRUE, NULL, "error starting hostname
thread");
+ _set_hostname (self, TRUE, NULL, "error starting hostname
thread");
}
}
static void
-update_ip4_routing_and_dns (NMPolicy *policy, gboolean force_update)
+update_ip4_routing_and_dns (NMPolicy *self, gboolean force_update)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
NMDnsIPConfigType dns_type = NM_DNS_IP_CONFIG_TYPE_BEST_DEVICE;
NMDevice *best = NULL;
NMActRequest *best_req = NULL;
@@ -426,14 +437,14 @@ update_ip4_routing_and_dns (NMPolicy *policy, gboolean
force_update)
NMSettingConnection *s_con = NULL;
const char *connection_id;
- best = get_best_ip4_device (policy->manager, &best_req);
+ best = get_best_ip4_device (priv->manager, &best_req);
if (!best)
goto out;
- if (!force_update && (best == policy->default_device4))
+ if (!force_update && (best == priv->default_device4))
goto out;
/* If a VPN connection is active, it is preferred */
- vpns = nm_vpn_manager_get_active_connections (policy->vpn_manager);
+ vpns = nm_vpn_manager_get_active_connections (priv->vpn_manager);
for (iter = vpns; iter; iter = g_slist_next (iter)) {
NMVPNConnection *candidate = NM_VPN_CONNECTION (iter->data);
NMConnection *vpn_connection;
@@ -503,7 +514,7 @@ update_ip4_routing_and_dns (NMPolicy *policy, gboolean
force_update)
* first. The order is important, we don't want two connections marked
* default at the same time ever.
*/
- devices = nm_manager_get_devices (policy->manager);
+ devices = nm_manager_get_devices (priv->manager);
for (iter = devices; iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMActRequest *req;
@@ -534,12 +545,13 @@ update_ip4_routing_and_dns (NMPolicy *policy, gboolean
force_update)
}
out:
- policy->default_device4 = best;
+ priv->default_device4 = best;
}
static void
-update_ip6_routing_and_dns (NMPolicy *policy, gboolean force_update)
+update_ip6_routing_and_dns (NMPolicy *self, gboolean force_update)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
NMDnsIPConfigType dns_type = NM_DNS_IP_CONFIG_TYPE_BEST_DEVICE;
NMDevice *best = NULL;
NMActRequest *best_req = NULL;
@@ -555,15 +567,15 @@ update_ip6_routing_and_dns (NMPolicy *policy, gboolean
force_update)
NMSettingConnection *s_con = NULL;
const char *connection_id;
- best = get_best_ip6_device (policy->manager, &best_req);
+ best = get_best_ip6_device (priv->manager, &best_req);
if (!best)
goto out;
- if (!force_update && (best == policy->default_device6))
+ if (!force_update && (best == priv->default_device6))
goto out;
#if 0
/* If a VPN connection is active, it is preferred */
- vpns = nm_vpn_manager_get_active_connections (policy->vpn_manager);
+ vpns = nm_vpn_manager_get_active_connections (priv->vpn_manager);
for (iter = vpns; iter; iter = g_slist_next (iter)) {
NMVPNConnection *candidate = NM_VPN_CONNECTION (iter->data);
NMConnection *vpn_connection;
@@ -628,7 +640,7 @@ update_ip6_routing_and_dns (NMPolicy *policy, gboolean
force_update)
* first. The order is important, we don't want two connections marked
* default at the same time ever.
*/
- devices = nm_manager_get_devices (policy->manager);
+ devices = nm_manager_get_devices (priv->manager);
for (iter = devices; iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMActRequest *req;
@@ -659,17 +671,18 @@ update_ip6_routing_and_dns (NMPolicy *policy, gboolean
force_update)
}
out:
- policy->default_device6 = best;
+ priv->default_device6 = best;
}
static void
-update_routing_and_dns (NMPolicy *policy, gboolean force_update)
+update_routing_and_dns (NMPolicy *self, gboolean force_update)
{
- update_ip4_routing_and_dns (policy, force_update);
- update_ip6_routing_and_dns (policy, force_update);
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
+ update_ip4_routing_and_dns (self, force_update);
+ update_ip6_routing_and_dns (self, force_update);
/* Update the system hostname */
- update_system_hostname (policy, policy->default_device4,
policy->default_device6);
+ update_system_hostname (self, priv->default_device4,
priv->default_device6);
}
static void
@@ -706,16 +719,18 @@ static gboolean
auto_activate_device (gpointer user_data)
{
ActivateData *data = (ActivateData *) user_data;
- NMPolicy *policy;
+ NMPolicy *self;
+ NMPolicyPrivate *priv;
NMConnection *best_connection;
char *specific_object = NULL;
GSList *connections, *iter;
g_assert (data);
- policy = data->policy;
+ self = data->policy;
+ priv = NM_POLICY_GET_PRIVATE (self);
data->id = 0;
- policy->pending_activation_checks = g_slist_remove
(policy->pending_activation_checks, data);
+ priv->pending_activation_checks = g_slist_remove
(priv->pending_activation_checks, data);
// FIXME: if a device is already activating (or activated) with a
connection
// but another connection now overrides the current one for that device,
@@ -724,7 +739,7 @@ auto_activate_device (gpointer user_data)
if (nm_device_get_act_request (data->device))
goto out;
- iter = connections = nm_settings_get_connections (policy->settings);
+ iter = connections = nm_settings_get_connections (priv->settings);
/* Remove connections that shouldn't be auto-activated */
while (iter) {
@@ -760,7 +775,7 @@ auto_activate_device (gpointer user_data)
nm_log_info (LOGD_DEVICE, "Auto-activating connection '%s'.",
nm_connection_get_id (best_connection));
- if (!nm_manager_activate_connection (policy->manager,
+ if (!nm_manager_activate_connection (priv->manager,
best_connection,
specific_object,
nm_device_get_path
(data->device),
@@ -780,12 +795,12 @@ auto_activate_device (gpointer user_data)
}
static ActivateData *
-activate_data_new (NMPolicy *policy, NMDevice *device, guint delay_seconds)
+activate_data_new (NMPolicy *self, NMDevice *device, guint delay_seconds)
{
ActivateData *data;
data = g_malloc0 (sizeof (ActivateData));
- data->policy = policy;
+ data->policy = self;
data->device = g_object_ref (device);
if (delay_seconds > 0)
data->id = g_timeout_add_seconds (delay_seconds,
auto_activate_device, data);
@@ -872,7 +887,8 @@ reset_retries_for_failed_secrets (NMSettings *settings)
static void
sleeping_changed (NMManager *manager, GParamSpec *pspec, gpointer user_data)
{
- NMPolicy *policy = user_data;
+ NMPolicy *self = user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
gboolean sleeping = FALSE, enabled = FALSE;
g_object_get (G_OBJECT (manager), NM_MANAGER_SLEEPING, &sleeping, NULL);
@@ -880,16 +896,17 @@ sleeping_changed (NMManager *manager, GParamSpec *pspec,
gpointer user_data)
/* Reset retries on all connections so they'll checked on wakeup */
if (sleeping || !enabled)
- reset_retries_all (policy->settings, NULL);
+ reset_retries_all (priv->settings, NULL);
}
static void
-schedule_activate_check (NMPolicy *policy, NMDevice *device, guint
delay_seconds)
+schedule_activate_check (NMPolicy *self, NMDevice *device, guint delay_seconds)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
ActivateData *data;
NMDeviceState state;
- if (nm_manager_get_state (policy->manager) == NM_STATE_ASLEEP)
+ if (nm_manager_get_state (priv->manager) == NM_STATE_ASLEEP)
return;
state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (device));
@@ -900,23 +917,24 @@ schedule_activate_check (NMPolicy *policy, NMDevice
*device, guint delay_seconds
return;
/* Schedule an auto-activation if there isn't one already for this
device */
- if (find_pending_activation (policy->pending_activation_checks, device)
== NULL) {
- data = activate_data_new (policy, device, delay_seconds);
- policy->pending_activation_checks = g_slist_append
(policy->pending_activation_checks, data);
+ if (find_pending_activation (priv->pending_activation_checks, device)
== NULL) {
+ data = activate_data_new (self, device, delay_seconds);
+ priv->pending_activation_checks = g_slist_append
(priv->pending_activation_checks, data);
}
}
static gboolean
reset_connections_retries (gpointer user_data)
{
- NMPolicy *policy = (NMPolicy *) user_data;
+ NMPolicy *self = (NMPolicy *) user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
GSList *connections, *iter;
time_t con_stamp, min_stamp, now;
- policy->reset_retries_id = 0;
+ priv->reset_retries_id = 0;
min_stamp = now = time (NULL);
- connections = nm_settings_get_connections (policy->settings);
+ connections = nm_settings_get_connections (priv->settings);
for (iter = connections; iter; iter = g_slist_next (iter)) {
con_stamp = GPOINTER_TO_SIZE (g_object_get_data (G_OBJECT
(iter->data), RESET_RETRIES_TIMESTAMP_TAG));
if (con_stamp == 0)
@@ -933,7 +951,7 @@ reset_connections_retries (gpointer user_data)
/* Schedule the handler again if there are some stamps left */
if (min_stamp != now)
- policy->reset_retries_id = g_timeout_add_seconds
(RESET_RETRIES_TIMER - (now - min_stamp), reset_connections_retries, policy);
+ priv->reset_retries_id = g_timeout_add_seconds
(RESET_RETRIES_TIMER - (now - min_stamp), reset_connections_retries, self);
return FALSE;
}
@@ -956,7 +974,8 @@ device_state_changed (NMDevice *device,
NMDeviceStateReason reason,
gpointer user_data)
{
- NMPolicy *policy = (NMPolicy *) user_data;
+ NMPolicy *self = (NMPolicy *) user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
NMConnection *connection = get_device_connection (device);
if (connection)
@@ -993,12 +1012,12 @@ device_state_changed (NMDevice *device,
nm_log_info (LOGD_DEVICE, "Marking connection
'%s' invalid.", nm_connection_get_id (connection));
/* Schedule a handler to reset retries count */
g_object_set_data (G_OBJECT (connection),
RESET_RETRIES_TIMESTAMP_TAG, GSIZE_TO_POINTER ((gsize) time (NULL)));
- if (!policy->reset_retries_id)
- policy->reset_retries_id =
g_timeout_add_seconds (RESET_RETRIES_TIMER, reset_connections_retries, policy);
+ if (!priv->reset_retries_id)
+ priv->reset_retries_id =
g_timeout_add_seconds (RESET_RETRIES_TIMER, reset_connections_retries, self);
}
nm_connection_clear_secrets (connection);
}
- schedule_activate_check (policy, device, 3);
+ schedule_activate_check (self, device, 3);
break;
case NM_DEVICE_STATE_ACTIVATED:
if (connection) {
@@ -1011,21 +1030,21 @@ device_state_changed (NMDevice *device,
nm_connection_clear_secrets (connection);
}
- update_routing_and_dns (policy, FALSE);
+ update_routing_and_dns (self, FALSE);
break;
case NM_DEVICE_STATE_UNMANAGED:
case NM_DEVICE_STATE_UNAVAILABLE:
- update_routing_and_dns (policy, FALSE);
+ update_routing_and_dns (self, FALSE);
break;
case NM_DEVICE_STATE_DISCONNECTED:
/* Reset RETRIES_TAG when carrier on. If cable was unplugged
* and plugged again, we should try to reconnect */
if (reason == NM_DEVICE_STATE_REASON_CARRIER && old_state ==
NM_DEVICE_STATE_UNAVAILABLE)
- reset_retries_all (policy->settings, device);
+ reset_retries_all (priv->settings, device);
/* Device is now available for auto-activation */
- update_routing_and_dns (policy, FALSE);
- schedule_activate_check (policy, device, 0);
+ update_routing_and_dns (self, FALSE);
+ schedule_activate_check (self, device, 0);
break;
default:
break;
@@ -1060,33 +1079,34 @@ typedef struct {
} DeviceSignalId;
static void
-_connect_device_signal (NMPolicy *policy, NMDevice *device, const char *name,
gpointer callback)
+_connect_device_signal (NMPolicy *self, NMDevice *device, const char *name,
gpointer callback)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
DeviceSignalId *data;
data = g_slice_new0 (DeviceSignalId);
g_assert (data);
- data->id = g_signal_connect (device, name, callback, policy);
+ data->id = g_signal_connect (device, name, callback, self);
data->device = device;
- policy->dev_ids = g_slist_prepend (policy->dev_ids, data);
+ priv->dev_ids = g_slist_prepend (priv->dev_ids, data);
}
static void
device_added (NMManager *manager, NMDevice *device, gpointer user_data)
{
- NMPolicy *policy = (NMPolicy *) user_data;
+ NMPolicy *self = (NMPolicy *) user_data;
- _connect_device_signal (policy, device, "state-changed",
device_state_changed);
- _connect_device_signal (policy, device, "notify::"
NM_DEVICE_INTERFACE_IP4_CONFIG, device_ip_config_changed);
- _connect_device_signal (policy, device, "notify::"
NM_DEVICE_INTERFACE_IP6_CONFIG, device_ip_config_changed);
+ _connect_device_signal (self, device, "state-changed",
device_state_changed);
+ _connect_device_signal (self, device, "notify::"
NM_DEVICE_INTERFACE_IP4_CONFIG, device_ip_config_changed);
+ _connect_device_signal (self, device, "notify::"
NM_DEVICE_INTERFACE_IP6_CONFIG, device_ip_config_changed);
if (NM_IS_DEVICE_WIFI (device)) {
- _connect_device_signal (policy, device, "access-point-added",
wireless_networks_changed);
- _connect_device_signal (policy, device, "access-point-removed",
wireless_networks_changed);
+ _connect_device_signal (self, device, "access-point-added",
wireless_networks_changed);
+ _connect_device_signal (self, device, "access-point-removed",
wireless_networks_changed);
#if WITH_WIMAX
} else if (NM_IS_DEVICE_WIMAX (device)) {
- _connect_device_signal (policy, device, "nsp-added",
nsps_changed);
- _connect_device_signal (policy, device, "nsp-removed",
nsps_changed);
+ _connect_device_signal (self, device, "nsp-added",
nsps_changed);
+ _connect_device_signal (self, device, "nsp-removed",
nsps_changed);
#endif
}
}
@@ -1094,19 +1114,20 @@ device_added (NMManager *manager, NMDevice *device,
gpointer user_data)
static void
device_removed (NMManager *manager, NMDevice *device, gpointer user_data)
{
- NMPolicy *policy = (NMPolicy *) user_data;
+ NMPolicy *self = (NMPolicy *) user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
ActivateData *tmp;
GSList *iter;
/* Clear any idle callbacks for this device */
- tmp = find_pending_activation (policy->pending_activation_checks,
device);
+ tmp = find_pending_activation (priv->pending_activation_checks, device);
if (tmp) {
- policy->pending_activation_checks = g_slist_remove
(policy->pending_activation_checks, tmp);
+ priv->pending_activation_checks = g_slist_remove
(priv->pending_activation_checks, tmp);
activate_data_free (tmp);
}
/* Clear any signal handlers for this device */
- iter = policy->dev_ids;
+ iter = priv->dev_ids;
while (iter) {
DeviceSignalId *data = iter->data;
GSList *next = g_slist_next (iter);
@@ -1114,22 +1135,23 @@ device_removed (NMManager *manager, NMDevice *device,
gpointer user_data)
if (data->device == device) {
g_signal_handler_disconnect (data->device, data->id);
g_slice_free (DeviceSignalId, data);
- policy->dev_ids = g_slist_delete_link (policy->dev_ids,
iter);
+ priv->dev_ids = g_slist_delete_link (priv->dev_ids,
iter);
}
iter = next;
}
- update_routing_and_dns (policy, FALSE);
+ update_routing_and_dns (self, FALSE);
}
static void
-schedule_activate_all (NMPolicy *policy)
+schedule_activate_all (NMPolicy *self)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
GSList *iter, *devices;
- devices = nm_manager_get_devices (policy->manager);
+ devices = nm_manager_get_devices (priv->manager);
for (iter = devices; iter; iter = g_slist_next (iter))
- schedule_activate_check (policy, NM_DEVICE (iter->data), 0);
+ schedule_activate_check (self, NM_DEVICE (iter->data), 0);
}
static void
@@ -1194,9 +1216,10 @@ connection_removed (NMSettings *settings,
NMConnection *connection,
gpointer user_data)
{
- NMPolicy *policy = user_data;
+ NMPolicy *self = user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
- _deactivate_if_active (policy->manager, connection);
+ _deactivate_if_active (priv->manager, connection);
}
static void
@@ -1204,12 +1227,13 @@ connection_visibility_changed (NMSettings *settings,
NMSettingsConnection *connection,
gpointer user_data)
{
- NMPolicy *policy = user_data;
+ NMPolicy *self = user_data;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
if (nm_settings_connection_is_visible (connection))
- schedule_activate_all (policy);
+ schedule_activate_all (self);
else
- _deactivate_if_active (policy->manager, NM_CONNECTION
(connection));
+ _deactivate_if_active (priv->manager, NM_CONNECTION
(connection));
}
static void
@@ -1226,21 +1250,23 @@ secret_agent_registered (NMSettings *settings,
}
static void
-_connect_manager_signal (NMPolicy *policy, const char *name, gpointer callback)
+_connect_manager_signal (NMPolicy *self, const char *name, gpointer callback)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
guint id;
- id = g_signal_connect (policy->manager, name, callback, policy);
- policy->manager_ids = g_slist_prepend (policy->manager_ids,
GUINT_TO_POINTER (id));
+ id = g_signal_connect (priv->manager, name, callback, self);
+ priv->manager_ids = g_slist_prepend (priv->manager_ids,
GUINT_TO_POINTER (id));
}
static void
-_connect_settings_signal (NMPolicy *policy, const char *name, gpointer
callback)
+_connect_settings_signal (NMPolicy *self, const char *name, gpointer callback)
{
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
guint id;
- id = g_signal_connect (policy->settings, name, callback, policy);
- policy->settings_ids = g_slist_prepend (policy->settings_ids,
GUINT_TO_POINTER (id));
+ id = g_signal_connect (priv->settings, name, callback, self);
+ priv->settings_ids = g_slist_prepend (priv->settings_ids,
GUINT_TO_POINTER (id));
}
NMPolicy *
@@ -1248,7 +1274,8 @@ nm_policy_new (NMManager *manager,
NMVPNManager *vpn_manager,
NMSettings *settings)
{
- NMPolicy *policy;
+ NMPolicy *self;
+ NMPolicyPrivate *priv;
static gboolean initialized = FALSE;
gulong id;
char hostname[HOST_NAME_MAX + 2];
@@ -1256,10 +1283,15 @@ nm_policy_new (NMManager *manager,
g_return_val_if_fail (NM_IS_MANAGER (manager), NULL);
g_return_val_if_fail (initialized == FALSE, NULL);
- policy = g_malloc0 (sizeof (NMPolicy));
- policy->manager = g_object_ref (manager);
- policy->settings = g_object_ref (settings);
- policy->update_state_id = 0;
+ self = g_object_new (NM_TYPE_POLICY, NULL);
+ if (!self)
+ return NULL;
+
+ priv = NM_POLICY_GET_PRIVATE (self);
+
+ priv->manager = g_object_ref (manager);
+ priv->settings = g_object_ref (settings);
+ priv->update_state_id = 0;
/* Grab hostname on startup and use that if nothing provides one */
memset (hostname, 0, sizeof (hostname));
@@ -1269,85 +1301,118 @@ nm_policy_new (NMManager *manager,
&& strcmp (hostname, "localhost")
&& strcmp (hostname, "localhost.localdomain")
&& strcmp (hostname, "(none)"))
- policy->orig_hostname = g_strdup (hostname);
+ priv->orig_hostname = g_strdup (hostname);
}
- policy->vpn_manager = g_object_ref (vpn_manager);
- id = g_signal_connect (policy->vpn_manager, "connection-activated",
- G_CALLBACK (vpn_connection_activated), policy);
- policy->vpn_activated_id = id;
- id = g_signal_connect (policy->vpn_manager, "connection-deactivated",
- G_CALLBACK (vpn_connection_deactivated), policy);
- policy->vpn_deactivated_id = id;
-
- _connect_manager_signal (policy, "state-changed", global_state_changed);
- _connect_manager_signal (policy, "notify::" NM_MANAGER_HOSTNAME,
hostname_changed);
- _connect_manager_signal (policy, "notify::" NM_MANAGER_SLEEPING,
sleeping_changed);
- _connect_manager_signal (policy, "notify::"
NM_MANAGER_NETWORKING_ENABLED, sleeping_changed);
- _connect_manager_signal (policy, "device-added", device_added);
- _connect_manager_signal (policy, "device-removed", device_removed);
-
- _connect_settings_signal (policy,
NM_SETTINGS_SIGNAL_CONNECTIONS_LOADED, connections_loaded);
- _connect_settings_signal (policy, NM_SETTINGS_SIGNAL_CONNECTION_ADDED,
connection_added);
- _connect_settings_signal (policy,
NM_SETTINGS_SIGNAL_CONNECTION_UPDATED, connection_updated);
- _connect_settings_signal (policy,
NM_SETTINGS_SIGNAL_CONNECTION_REMOVED, connection_removed);
- _connect_settings_signal (policy,
NM_SETTINGS_SIGNAL_CONNECTION_VISIBILITY_CHANGED,
+ priv->vpn_manager = g_object_ref (vpn_manager);
+ id = g_signal_connect (priv->vpn_manager, "connection-activated",
+ G_CALLBACK (vpn_connection_activated), self);
+ priv->vpn_activated_id = id;
+ id = g_signal_connect (priv->vpn_manager, "connection-deactivated",
+ G_CALLBACK (vpn_connection_deactivated), self);
+ priv->vpn_deactivated_id = id;
+
+ _connect_manager_signal (self, "state-changed", global_state_changed);
+ _connect_manager_signal (self, "notify::" NM_MANAGER_HOSTNAME,
hostname_changed);
+ _connect_manager_signal (self, "notify::" NM_MANAGER_SLEEPING,
sleeping_changed);
+ _connect_manager_signal (self, "notify::"
NM_MANAGER_NETWORKING_ENABLED, sleeping_changed);
+ _connect_manager_signal (self, "device-added", device_added);
+ _connect_manager_signal (self, "device-removed", device_removed);
+
+ _connect_settings_signal (self, NM_SETTINGS_SIGNAL_CONNECTIONS_LOADED,
connections_loaded);
+ _connect_settings_signal (self, NM_SETTINGS_SIGNAL_CONNECTION_ADDED,
connection_added);
+ _connect_settings_signal (self, NM_SETTINGS_SIGNAL_CONNECTION_UPDATED,
connection_updated);
+ _connect_settings_signal (self, NM_SETTINGS_SIGNAL_CONNECTION_REMOVED,
connection_removed);
+ _connect_settings_signal (self,
NM_SETTINGS_SIGNAL_CONNECTION_VISIBILITY_CHANGED,
connection_visibility_changed);
- _connect_settings_signal (policy, NM_SETTINGS_SIGNAL_AGENT_REGISTERED,
secret_agent_registered);
+ _connect_settings_signal (self, NM_SETTINGS_SIGNAL_AGENT_REGISTERED,
secret_agent_registered);
/* Initialize connections' auto-retries */
- reset_retries_all (policy->settings, NULL);
+ reset_retries_all (priv->settings, NULL);
initialized = TRUE;
- return policy;
+ return self;
}
-void
-nm_policy_destroy (NMPolicy *policy)
+static void
+nm_policy_init (NMPolicy *self)
{
- GSList *iter;
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
+ priv->disposed = FALSE;
+}
- g_return_if_fail (policy != NULL);
+static void
+dispose (GObject *object)
+{
+ NMPolicy *self = NM_POLICY (object);
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
+
+ if (!priv->disposed) {
+ priv->disposed = TRUE;
+ g_object_unref (priv->manager);
+ g_object_unref (priv->vpn_manager);
+ g_object_unref (priv->settings);
+ }
+ G_OBJECT_CLASS (nm_policy_parent_class)->dispose (object);
+}
+
+static void
+finalize (GObject *object)
+{
+ NMPolicy *self = NM_POLICY (object);
+ NMPolicyPrivate *priv = NM_POLICY_GET_PRIVATE (self);
+
+ GSList *iter;
/* Tell any existing hostname lookup thread to die, it'll get cleaned up
* by the lookup thread callback.
*/
- if (policy->lookup) {
- hostname_thread_kill (policy->lookup);
- policy->lookup = NULL;
+ if (priv->lookup) {
+ hostname_thread_kill (priv->lookup);
+ priv->lookup = NULL;
}
- g_slist_foreach (policy->pending_activation_checks, (GFunc)
activate_data_free, NULL);
- g_slist_free (policy->pending_activation_checks);
+ g_slist_foreach (priv->pending_activation_checks, (GFunc)
activate_data_free, NULL);
+ g_slist_free (priv->pending_activation_checks);
- g_signal_handler_disconnect (policy->vpn_manager,
policy->vpn_activated_id);
- g_signal_handler_disconnect (policy->vpn_manager,
policy->vpn_deactivated_id);
- g_object_unref (policy->vpn_manager);
+ g_signal_handler_disconnect (priv->vpn_manager, priv->vpn_activated_id);
+ g_signal_handler_disconnect (priv->vpn_manager,
priv->vpn_deactivated_id);
- for (iter = policy->manager_ids; iter; iter = g_slist_next (iter))
- g_signal_handler_disconnect (policy->manager, GPOINTER_TO_UINT
(iter->data));
- g_slist_free (policy->manager_ids);
+ for (iter = priv->manager_ids; iter; iter = g_slist_next (iter))
+ g_signal_handler_disconnect (priv->manager, GPOINTER_TO_UINT
(iter->data));
+ g_slist_free (priv->manager_ids);
- for (iter = policy->settings_ids; iter; iter = g_slist_next (iter))
- g_signal_handler_disconnect (policy->settings, GPOINTER_TO_UINT
(iter->data));
- g_slist_free (policy->settings_ids);
+ for (iter = priv->settings_ids; iter; iter = g_slist_next (iter))
+ g_signal_handler_disconnect (priv->settings, GPOINTER_TO_UINT
(iter->data));
+ g_slist_free (priv->settings_ids);
- for (iter = policy->dev_ids; iter; iter = g_slist_next (iter)) {
+ for (iter = priv->dev_ids; iter; iter = g_slist_next (iter)) {
DeviceSignalId *data = iter->data;
g_signal_handler_disconnect (data->device, data->id);
g_slice_free (DeviceSignalId, data);
}
- g_slist_free (policy->dev_ids);
+ g_slist_free (priv->dev_ids);
- if (policy->reset_retries_id)
- g_source_remove (policy->reset_retries_id);
+ if (priv->reset_retries_id)
+ g_source_remove (priv->reset_retries_id);
- g_free (policy->orig_hostname);
- g_free (policy->cur_hostname);
+ g_free (priv->orig_hostname);
+ g_free (priv->cur_hostname);
- g_object_unref (policy->settings);
- g_object_unref (policy->manager);
- g_free (policy);
+ G_OBJECT_CLASS (nm_policy_parent_class)->finalize (object);
}
+
+static void
+nm_policy_class_init (NMPolicyClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ g_type_class_add_private (class, sizeof (NMPolicyPrivate));
+
+ /* virtual methods */
+ object_class->dispose = dispose;
+ object_class->finalize = finalize;
+
+}
diff --git a/src/nm-policy.h b/src/nm-policy.h
index 33796bc..6837103 100644
--- a/src/nm-policy.h
+++ b/src/nm-policy.h
@@ -15,7 +15,7 @@
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
- * Copyright (C) 2004 - 2010 Red Hat, Inc.
+ * Copyright (C) 2004 - 2011 Red Hat, Inc.
* Copyright (C) 2007 - 2008 Novell, Inc.
*/
@@ -26,11 +26,26 @@
#include "nm-vpn-manager.h"
#include "nm-settings.h"
-typedef struct NMPolicy NMPolicy;
+#define NM_TYPE_POLICY (nm_policy_get_type ())
+#define NM_POLICY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),
NM_TYPE_POLICY, NMPolicy))
+#define NM_POLICY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),
NM_TYPE_POLICY, NMPolicyClass))
+#define NM_IS_POLICY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),
NM_TYPE_POLICY))
+#define NM_IS_POLICY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),
NM_TYPE_POLICY))
+#define NM_POLICY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),
NM_TYPE_POLICY, NMPolicyClass))
+
+typedef struct {
+ GObject parent_instance;
+} NMPolicy;
+
+typedef struct {
+ GObjectClass parent_class;
+
+} NMPolicyClass;
+
+GType nm_policy_get_type (void);
NMPolicy *nm_policy_new (NMManager *manager,
NMVPNManager *vpn_manager,
NMSettings *settings);
-void nm_policy_destroy (NMPolicy *policy);
#endif /* NM_POLICY_H */
--
1.7.6
_______________________________________________
networkmanager-list mailing list
networkmanager-list@gnome.org
http://mail.gnome.org/mailman/listinfo/networkmanager-list
