src/nm-manager.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
   2 /* NetworkManager -- Network link manager
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Copyright (C) 2007 - 2009 Novell, Inc.
  19  * Copyright (C) 2007 - 2012 Red Hat, Inc.
  20  */
  21
  22 #include "nm-default.h"
  23
  24 #include <stdlib.h>
  25 #include <fcntl.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29
  30 #include "nm-manager.h"
  31 #include "nm-bus-manager.h"
  32 #include "nm-vpn-manager.h"
  33 #include "nm-device.h"
  34 #include "nm-device-generic.h"
  35 #include "nm-platform.h"
  36 #include "nm-rfkill-manager.h"
  37 #include "nm-dhcp-manager.h"
  38 #include "nm-settings.h"
  39 #include "nm-settings-connection.h"
  40 #include "nm-auth-utils.h"
  41 #include "nm-auth-manager.h"
  42 #include "NetworkManagerUtils.h"
  43 #include "nm-device-factory.h"
  44 #include "nm-enum-types.h"
  45 #include "nm-sleep-monitor.h"
  46 #include "nm-connectivity.h"
  47 #include "nm-policy.h"
  48 #include "nm-connection-provider.h"
  49 #include "nm-session-monitor.h"
  50 #include "nm-activation-request.h"
  51 #include "nm-core-internal.h"
  52 #include "nm-config.h"
  53 #include "nm-audit-manager.h"
  54 #include "nm-dbus-compat.h"
  55 #include "NetworkManagerUtils.h"
  56
  57 #include "nmdbus-manager.h"
  58 #include "nmdbus-device.h"
  59
  60 static gboolean add_device (NMManager *self, NMDevice *device, GError **error);
  61
  62 static NMActiveConnection *_new_active_connection (NMManager *self,
  63                                                    NMConnection *connection,
  64                                                    const char *specific_object,
  65                                                    NMDevice *device,
  66                                                    NMAuthSubject *subject,
  67                                                    GError **error);
  68
  69 static void policy_activating_device_changed (GObject *object, GParamSpec *pspec, gpointer user_data);
  70
  71 static void rfkill_change (const char *desc, RfKillType rtype, gboolean enabled);
  72
  73 static gboolean find_master (NMManager *self,
  74                              NMConnection *connection,
  75                              NMDevice *device,
  76                              NMSettingsConnection **out_master_connection,
  77                              NMDevice **out_master_device,
  78                              NMActiveConnection **out_master_ac,
  79                              GError **error);
  80
  81 static void nm_manager_update_state (NMManager *manager);
  82
  83 static void connection_changed (NMSettings *settings, NMConnection *connection,
  84                                 NMManager *manager);
  85
  86 #define TAG_ACTIVE_CONNETION_ADD_AND_ACTIVATE "act-con-add-and-activate"
  87
  88 typedef struct {
  89         gboolean user_enabled;
  90         gboolean sw_enabled;
  91         gboolean hw_enabled;
  92         RfKillType rtype;
  93         const char *desc;
  94         const char *key;
  95         const char *prop;
  96         const char *hw_prop;
  97 } RadioState;
  98
  99 typedef struct {
 100         char *state_file;
 101
 102         GSList *active_connections;
 103         GSList *authorizing_connections;
 104         guint ac_cleanup_id;
 105         NMActiveConnection *primary_connection;
 106         NMActiveConnection *activating_connection;
 107         NMMetered metered;
 108
 109         GSList *devices;
 110         NMState state;
 111         NMConfig *config;
 112         NMConnectivity *connectivity;
 113
 114         NMPolicy *policy;
 115
 116         NMBusManager  *dbus_mgr;
 117         struct {
 118                 GDBusConnection *connection;
 119                 guint            id;
 120         } prop_filter;
 121         NMRfkillManager *rfkill_mgr;
 122
 123         NMSettings *settings;
 124         char *hostname;
 125
 126         RadioState radio_states[RFKILL_TYPE_MAX];
 127         gboolean sleeping;
 128         gboolean net_enabled;
 129
 130         NMVpnManager *vpn_manager;
 131
 132         NMSleepMonitor *sleep_monitor;
 133
 134         GSList *auth_chains;
 135
 136         /* Firmware dir monitor */
 137         GFileMonitor *fw_monitor;
 138         guint fw_changed_id;
 139
 140         guint timestamp_update_id;
 141
 142         gboolean startup;
 143         gboolean devices_inited;
 144 } NMManagerPrivate;
 145
 146 #define NM_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_MANAGER, NMManagerPrivate))
 147
 148 G_DEFINE_TYPE (NMManager, nm_manager, NM_TYPE_EXPORTED_OBJECT)
 149
 150 enum {
 151         DEVICE_ADDED,
 152         INTERNAL_DEVICE_ADDED,
 153         DEVICE_REMOVED,
 154         INTERNAL_DEVICE_REMOVED,
 155         STATE_CHANGED,
 156         CHECK_PERMISSIONS,
 157         USER_PERMISSIONS_CHANGED,
 158         ACTIVE_CONNECTION_ADDED,
 159         ACTIVE_CONNECTION_REMOVED,
 160         CONFIGURE_QUIT,
 161
 162         LAST_SIGNAL
 163 };
 164
 165 static guint signals[LAST_SIGNAL] = { 0 };
 166
 167 enum {
 168         PROP_0,
 169         PROP_VERSION,
 170         PROP_STATE,
 171         PROP_STATE_FILE,
 172         PROP_STARTUP,
 173         PROP_NETWORKING_ENABLED,
 174         PROP_WIRELESS_ENABLED,
 175         PROP_WIRELESS_HARDWARE_ENABLED,
 176         PROP_WWAN_ENABLED,
 177         PROP_WWAN_HARDWARE_ENABLED,
 178         PROP_WIMAX_ENABLED,
 179         PROP_WIMAX_HARDWARE_ENABLED,
 180         PROP_ACTIVE_CONNECTIONS,
 181         PROP_CONNECTIVITY,
 182         PROP_PRIMARY_CONNECTION,
 183         PROP_PRIMARY_CONNECTION_TYPE,
 184         PROP_ACTIVATING_CONNECTION,
 185         PROP_DEVICES,
 186         PROP_METERED,
 187         PROP_GLOBAL_DNS_CONFIGURATION,
 188         PROP_ALL_DEVICES,
 189
 190         /* Not exported */
 191         PROP_HOSTNAME,
 192         PROP_SLEEPING,
 193
 194         LAST_PROP
 195 };
 196
 197 NM_DEFINE_SINGLETON_INSTANCE (NMManager);
 198
 199 /************************************************************************/
 200
 201 #define _NMLOG_PREFIX_NAME      "manager"
 202 #define _NMLOG(level, domain, ...) \
 203     G_STMT_START { \
 204         const NMLogLevel __level = (level); \
 205         const NMLogDomain __domain = (domain); \
 206         \
 207         if (nm_logging_enabled (__level, __domain)) { \
 208             const NMManager *const __self = (self); \
 209             char __sbuf[32]; \
 210             \
 211             _nm_log (__level, __domain, 0, \
 212                      "%s%s: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \
 213                      _NMLOG_PREFIX_NAME, \
 214                      (__self && __self != singleton_instance) \
 215                          ? nm_sprintf_buf (__sbuf, "[%p]", __self) \
 216                          : "" \
 217                      _NM_UTILS_MACRO_REST (__VA_ARGS__)); \
 218         } \
 219     } G_STMT_END
 220
 221 /************************************************************************/
 222
 223 static void active_connection_state_changed (NMActiveConnection *active,
 224                                              GParamSpec *pspec,
 225                                              NMManager *self);
 226 static void active_connection_default_changed (NMActiveConnection *active,
 227                                                GParamSpec *pspec,
 228                                                NMManager *self);
 229
 230 /* Returns: whether to notify D-Bus of the removal or not */
 231 static gboolean
 232 active_connection_remove (NMManager *self, NMActiveConnection *active)
 233 {
 234         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 235         gboolean notify = nm_exported_object_is_exported (NM_EXPORTED_OBJECT (active));
 236         GSList *found;
 237
 238         /* FIXME: switch to a GList for faster removal */
 239         found = g_slist_find (priv->active_connections, active);
 240         if (found) {
 241                 NMSettingsConnection *connection;
 242
 243                 priv->active_connections = g_slist_remove (priv->active_connections, active);
 244                 g_signal_emit (self, signals[ACTIVE_CONNECTION_REMOVED], 0, active);
 245                 g_signal_handlers_disconnect_by_func (active, active_connection_state_changed, self);
 246                 g_signal_handlers_disconnect_by_func (active, active_connection_default_changed, self);
 247
 248                 if (   nm_active_connection_get_assumed (active)
 249                     && (connection = nm_active_connection_get_settings_connection (active))
 250                     && nm_settings_connection_get_nm_generated_assumed (connection))
 251                         g_object_ref (connection);
 252                 else
 253                         connection = NULL;
 254
 255                 nm_exported_object_clear_and_unexport (&active);
 256
 257                 if (   connection
 258                     && nm_settings_has_connection (priv->settings, connection)) {
 259                         _LOGD (LOGD_DEVICE, "assumed connection disconnected. Deleting generated connection '%s' (%s)",
 260                                nm_settings_connection_get_id (connection), nm_settings_connection_get_uuid (connection));
 261                         nm_settings_connection_delete (NM_SETTINGS_CONNECTION (connection), NULL, NULL);
 262                         g_object_unref (connection);
 263                 }
 264         }
 265
 266         return found && notify;
 267 }
 268
 269 static gboolean
 270 _active_connection_cleanup (gpointer user_data)
 271 {
 272         NMManager *self = NM_MANAGER (user_data);
 273         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 274         GSList *iter;
 275
 276         priv->ac_cleanup_id = 0;
 277
 278         g_object_freeze_notify (G_OBJECT (self));
 279         iter = priv->active_connections;
 280         while (iter) {
 281                 NMActiveConnection *ac = iter->data;
 282
 283                 iter = iter->next;
 284                 if (nm_active_connection_get_state (ac) == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) {
 285                         if (active_connection_remove (self, ac))
 286                                 g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVE_CONNECTIONS);
 287                 }
 288         }
 289         g_object_thaw_notify (G_OBJECT (self));
 290
 291         return FALSE;
 292 }
 293
 294 static void
 295 active_connection_state_changed (NMActiveConnection *active,
 296                                  GParamSpec *pspec,
 297                                  NMManager *self)
 298 {
 299         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 300         NMActiveConnectionState state;
 301
 302         state = nm_active_connection_get_state (active);
 303         if (state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) {
 304                 /* Destroy active connections from an idle handler to ensure that
 305                  * their last property change notifications go out, which wouldn't
 306                  * happen if we destroyed them immediately when their state was set
 307                  * to DEACTIVATED.
 308                  */
 309                 if (!priv->ac_cleanup_id)
 310                         priv->ac_cleanup_id = g_idle_add (_active_connection_cleanup, self);
 311         }
 312
 313         nm_manager_update_state (self);
 314 }
 315
 316 static void
 317 active_connection_default_changed (NMActiveConnection *active,
 318                                    GParamSpec *pspec,
 319                                    NMManager *self)
 320 {
 321         nm_manager_update_state (self);
 322 }
 323
 324 /**
 325  * active_connection_add():
 326  * @self: the #NMManager
 327  * @active: the #NMActiveConnection to manage
 328  *
 329  * Begins to track and manage @active.  Increases the refcount of @active.
 330  */
 331 static void
 332 active_connection_add (NMManager *self, NMActiveConnection *active)
 333 {
 334         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 335
 336         g_return_if_fail (g_slist_find (priv->active_connections, active) == FALSE);
 337
 338         priv->active_connections = g_slist_prepend (priv->active_connections,
 339                                                     g_object_ref (active));
 340
 341         g_signal_connect (active,
 342                           "notify::" NM_ACTIVE_CONNECTION_STATE,
 343                           G_CALLBACK (active_connection_state_changed),
 344                           self);
 345         g_signal_connect (active,
 346                           "notify::" NM_ACTIVE_CONNECTION_DEFAULT,
 347                           G_CALLBACK (active_connection_default_changed),
 348                           self);
 349         g_signal_connect (active,
 350                           "notify::" NM_ACTIVE_CONNECTION_DEFAULT6,
 351                           G_CALLBACK (active_connection_default_changed),
 352                           self);
 353
 354         g_signal_emit (self, signals[ACTIVE_CONNECTION_ADDED], 0, active);
 355
 356         /* Only notify D-Bus if the active connection is actually exported */
 357         if (nm_exported_object_is_exported (NM_EXPORTED_OBJECT (active)))
 358                 g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVE_CONNECTIONS);
 359 }
 360
 361 const GSList *
 362 nm_manager_get_active_connections (NMManager *manager)
 363 {
 364         return NM_MANAGER_GET_PRIVATE (manager)->active_connections;
 365 }
 366
 367 static NMActiveConnection *
 368 find_ac_for_connection (NMManager *manager, NMConnection *connection)
 369 {
 370         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 371         GSList *iter;
 372         const char *uuid = NULL;
 373         gboolean is_settings_connection;
 374
 375         is_settings_connection = NM_IS_SETTINGS_CONNECTION (connection);
 376
 377         if (!is_settings_connection)
 378                 uuid = nm_connection_get_uuid (connection);
 379
 380         for (iter = priv->active_connections; iter; iter = iter->next) {
 381                 NMActiveConnection *ac = iter->data;
 382                 NMSettingsConnection *con;
 383
 384                 con = nm_active_connection_get_settings_connection (ac);
 385
 386                 /* depending on whether we have a NMSettingsConnection or a NMConnection,
 387                  * we lookup by UUID or by reference. */
 388                 if (is_settings_connection) {
 389                         if (con != (NMSettingsConnection *) connection)
 390                                 continue;
 391                 } else {
 392                         if (strcmp (uuid, nm_connection_get_uuid (NM_CONNECTION (con))) != 0)
 393                                 continue;
 394                 }
 395                 if (nm_active_connection_get_state (ac) < NM_ACTIVE_CONNECTION_STATE_DEACTIVATED)
 396                         return ac;
 397         }
 398
 399         return NULL;
 400 }
 401
 402 /* Filter out connections that are already active.
 403  * nm_settings_get_connections() returns sorted list. We need to preserve the
 404  * order so that we didn't change auto-activation order (recent timestamps
 405  * are first).
 406  * Caller is responsible for freeing the returned list with g_slist_free().
 407  */
 408 GSList *
 409 nm_manager_get_activatable_connections (NMManager *manager)
 410 {
 411         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 412         GSList *all_connections = nm_settings_get_connections (priv->settings);
 413         GSList *connections = NULL, *iter;
 414         NMSettingsConnection *connection;
 415
 416         for (iter = all_connections; iter; iter = iter->next) {
 417                 connection = iter->data;
 418
 419                 if (!find_ac_for_connection (manager, NM_CONNECTION (connection)))
 420                         connections = g_slist_prepend (connections, connection);
 421         }
 422
 423         g_slist_free (all_connections);
 424         return g_slist_reverse (connections);
 425 }
 426
 427 static NMActiveConnection *
 428 active_connection_get_by_path (NMManager *manager, const char *path)
 429 {
 430         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 431         GSList *iter;
 432
 433         g_return_val_if_fail (manager != NULL, NULL);
 434         g_return_val_if_fail (path != NULL, NULL);
 435
 436         for (iter = priv->active_connections; iter; iter = g_slist_next (iter)) {
 437                 NMActiveConnection *candidate = iter->data;
 438
 439                 if (g_strcmp0 (path, nm_exported_object_get_path (NM_EXPORTED_OBJECT (candidate))) == 0)
 440                         return candidate;
 441         }
 442         return NULL;
 443 }
 444
 445 /************************************************************************/
 446
 447 static void
 448 _config_changed_cb (NMConfig *config, NMConfigData *config_data, NMConfigChangeFlags changes, NMConfigData *old_data, NMManager *self)
 449 {
 450         g_object_set (NM_MANAGER_GET_PRIVATE (self)->connectivity,
 451                       NM_CONNECTIVITY_URI, nm_config_data_get_connectivity_uri (config_data),
 452                       NM_CONNECTIVITY_INTERVAL, nm_config_data_get_connectivity_interval (config_data),
 453                       NM_CONNECTIVITY_RESPONSE, nm_config_data_get_connectivity_response (config_data),
 454                       NULL);
 455
 456         if (NM_FLAGS_HAS (changes, NM_CONFIG_CHANGE_GLOBAL_DNS_CONFIG))
 457                 g_object_notify (G_OBJECT (self), NM_MANAGER_GLOBAL_DNS_CONFIGURATION);
 458 }
 459
 460 /************************************************************************/
 461
 462 static NMDevice *
 463 nm_manager_get_device_by_path (NMManager *manager, const char *path)
 464 {
 465         GSList *iter;
 466
 467         g_return_val_if_fail (path != NULL, NULL);
 468
 469         for (iter = NM_MANAGER_GET_PRIVATE (manager)->devices; iter; iter = iter->next) {
 470                 if (!strcmp (nm_exported_object_get_path (NM_EXPORTED_OBJECT (iter->data)), path))
 471                         return NM_DEVICE (iter->data);
 472         }
 473         return NULL;
 474 }
 475
 476 NMDevice *
 477 nm_manager_get_device_by_ifindex (NMManager *manager, int ifindex)
 478 {
 479         GSList *iter;
 480
 481         for (iter = NM_MANAGER_GET_PRIVATE (manager)->devices; iter; iter = iter->next) {
 482                 NMDevice *device = NM_DEVICE (iter->data);
 483
 484                 if (nm_device_get_ifindex (device) == ifindex)
 485                         return device;
 486         }
 487
 488         return NULL;
 489 }
 490
 491 static NMDevice *
 492 find_device_by_hw_addr (NMManager *manager, const char *hwaddr)
 493 {
 494         GSList *iter;
 495         const char *device_addr;
 496
 497         g_return_val_if_fail (hwaddr != NULL, NULL);
 498
 499         if (nm_utils_hwaddr_valid (hwaddr, -1)) {
 500                 for (iter = NM_MANAGER_GET_PRIVATE (manager)->devices; iter; iter = iter->next) {
 501                         device_addr = nm_device_get_hw_address (NM_DEVICE (iter->data));
 502                         if (device_addr && nm_utils_hwaddr_matches (hwaddr, -1, device_addr, -1))
 503                                 return NM_DEVICE (iter->data);
 504                 }
 505         }
 506         return NULL;
 507 }
 508
 509 static NMDevice *
 510 find_device_by_ip_iface (NMManager *self, const gchar *iface)
 511 {
 512         GSList *iter;
 513
 514         g_return_val_if_fail (iface != NULL, NULL);
 515
 516         for (iter = NM_MANAGER_GET_PRIVATE (self)->devices; iter; iter = g_slist_next (iter)) {
 517                 NMDevice *candidate = iter->data;
 518
 519                 if (   nm_device_is_real (candidate)
 520                     && g_strcmp0 (nm_device_get_ip_iface (candidate), iface) == 0)
 521                         return candidate;
 522         }
 523         return NULL;
 524 }
 525
 526 /**
 527  * find_device_by_iface:
 528  * @self: the #NMManager
 529  * @iface: the device interface to find
 530  * @connection: a connection to ensure the returned device is compatible with
 531  * @slave: a slave connection to ensure a master is compatible with
 532  *
 533  * Finds a device by interface name, preferring realized devices.  If @slave
 534  * is given, this function will only return master devices and will ensure
 535  * @slave, when activated, can be a slave of the returned master device.  If
 536  * @connection is given, this function will only consider devices that are
 537  * compatible with @connection.
 538  *
 539  * Returns: the matching #NMDevice
 540  */
 541 static NMDevice *
 542 find_device_by_iface (NMManager *self,
 543                       const char *iface,
 544                       NMConnection *connection,
 545                       NMConnection *slave)
 546 {
 547         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 548         NMDevice *fallback = NULL;
 549         GSList *iter;
 550
 551         g_return_val_if_fail (iface != NULL, NULL);
 552
 553         for (iter = priv->devices; iter; iter = iter->next) {
 554                 NMDevice *candidate = iter->data;
 555
 556                 if (strcmp (nm_device_get_iface (candidate), iface))
 557                         continue;
 558                 if (connection && !nm_device_check_connection_compatible (candidate, connection))
 559                         continue;
 560                 if (slave) {
 561                         if (!nm_device_is_master (candidate))
 562                                 continue;
 563                         if (!nm_device_check_slave_connection_compatible (candidate, slave))
 564                                 continue;
 565                 }
 566
 567                 if (nm_device_is_real (candidate))
 568                         return candidate;
 569                 else if (!fallback)
 570                         fallback = candidate;
 571         }
 572         return fallback;
 573 }
 574
 575 static gboolean
 576 manager_sleeping (NMManager *self)
 577 {
 578         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 579
 580         if (priv->sleeping || !priv->net_enabled)
 581                 return TRUE;
 582         return FALSE;
 583 }
 584
 585 static const char *
 586 _nm_state_to_string (NMState state)
 587 {
 588         switch (state) {
 589         case NM_STATE_ASLEEP:
 590                 return "ASLEEP";
 591         case NM_STATE_DISCONNECTED:
 592                 return "DISCONNECTED";
 593         case NM_STATE_DISCONNECTING:
 594                 return "DISCONNECTING";
 595         case NM_STATE_CONNECTING:
 596                 return "CONNECTING";
 597         case NM_STATE_CONNECTED_LOCAL:
 598                 return "CONNECTED_LOCAL";
 599         case NM_STATE_CONNECTED_SITE:
 600                 return "CONNECTED_SITE";
 601         case NM_STATE_CONNECTED_GLOBAL:
 602                 return "CONNECTED_GLOBAL";
 603         case NM_STATE_UNKNOWN:
 604         default:
 605                 return "UNKNOWN";
 606         }
 607 }
 608
 609 static void
 610 set_state (NMManager *self, NMState state)
 611 {
 612         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 613
 614         if (priv->state == state)
 615                 return;
 616
 617         priv->state = state;
 618
 619         _LOGI (LOGD_CORE, "NetworkManager state is now %s", _nm_state_to_string (state));
 620
 621         g_object_notify (G_OBJECT (self), NM_MANAGER_STATE);
 622         g_signal_emit (self, signals[STATE_CHANGED], 0, priv->state);
 623 }
 624
 625 static void
 626 checked_connectivity (GObject *object, GAsyncResult *result, gpointer user_data)
 627 {
 628         NMManager *manager = user_data;
 629         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 630         NMConnectivityState connectivity;
 631
 632         if (priv->state == NM_STATE_CONNECTING || priv->state == NM_STATE_CONNECTED_SITE) {
 633                 connectivity = nm_connectivity_check_finish (priv->connectivity, result, NULL);
 634
 635                 if (connectivity == NM_CONNECTIVITY_FULL)
 636                         set_state (manager, NM_STATE_CONNECTED_GLOBAL);
 637                 else if (   connectivity == NM_CONNECTIVITY_PORTAL
 638                          || connectivity == NM_CONNECTIVITY_LIMITED)
 639                         set_state (manager, NM_STATE_CONNECTED_SITE);
 640                 g_object_notify (G_OBJECT (manager), NM_MANAGER_CONNECTIVITY);
 641         }
 642
 643         g_object_unref (manager);
 644 }
 645
 646 static NMState
 647 find_best_device_state (NMManager *manager)
 648 {
 649         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 650         NMState best_state = NM_STATE_DISCONNECTED;
 651         GSList *iter;
 652
 653         for (iter = priv->active_connections; iter; iter = iter->next) {
 654                 NMActiveConnection *ac = NM_ACTIVE_CONNECTION (iter->data);
 655                 NMActiveConnectionState ac_state = nm_active_connection_get_state (ac);
 656
 657                 switch (ac_state) {
 658                 case NM_ACTIVE_CONNECTION_STATE_ACTIVATED:
 659                         if (   nm_active_connection_get_default (ac)
 660                             || nm_active_connection_get_default6 (ac)) {
 661                                 if (nm_connectivity_get_state (priv->connectivity) == NM_CONNECTIVITY_FULL)
 662                                         return NM_STATE_CONNECTED_GLOBAL;
 663
 664                                 best_state = NM_STATE_CONNECTED_SITE;
 665                         } else {
 666                                 if (best_state < NM_STATE_CONNECTING)
 667                                         best_state = NM_STATE_CONNECTED_LOCAL;
 668                         }
 669                         break;
 670                 case NM_ACTIVE_CONNECTION_STATE_ACTIVATING:
 671                         if (!nm_active_connection_get_assumed (ac)) {
 672                                 if (best_state != NM_STATE_CONNECTED_GLOBAL)
 673                                         best_state = NM_STATE_CONNECTING;
 674                         }
 675                         break;
 676                 case NM_ACTIVE_CONNECTION_STATE_DEACTIVATING:
 677                         if (!nm_active_connection_get_assumed (ac)) {
 678                                 if (best_state < NM_STATE_DISCONNECTING)
 679                                         best_state = NM_STATE_DISCONNECTING;
 680                         }
 681                         break;
 682                 default:
 683                         break;
 684                 }
 685         }
 686
 687         return best_state;
 688 }
 689
 690 static void
 691 nm_manager_update_metered (NMManager *self)
 692 {
 693         NMManagerPrivate *priv;
 694         NMDevice *device;
 695         NMMetered value = NM_METERED_UNKNOWN;
 696
 697         g_return_if_fail (NM_IS_MANAGER (self));
 698         priv = NM_MANAGER_GET_PRIVATE (self);
 699
 700         if (priv->primary_connection) {
 701                 device =  nm_active_connection_get_device (priv->primary_connection);
 702                 if (device)
 703                         value = nm_device_get_metered (device);
 704         }
 705
 706         if (value != priv->metered) {
 707                 priv->metered = value;
 708                 _LOGD (LOGD_CORE, "new metered value: %d", (int) priv->metered);
 709                 g_object_notify (G_OBJECT (self), NM_MANAGER_METERED);
 710         }
 711 }
 712
 713 static void
 714 nm_manager_update_state (NMManager *manager)
 715 {
 716         NMManagerPrivate *priv;
 717         NMState new_state = NM_STATE_DISCONNECTED;
 718
 719         g_return_if_fail (NM_IS_MANAGER (manager));
 720
 721         priv = NM_MANAGER_GET_PRIVATE (manager);
 722
 723         if (manager_sleeping (manager))
 724                 new_state = NM_STATE_ASLEEP;
 725         else
 726                 new_state = find_best_device_state (manager);
 727
 728         nm_connectivity_set_online (priv->connectivity, new_state >= NM_STATE_CONNECTED_LOCAL);
 729
 730         if (new_state == NM_STATE_CONNECTED_SITE) {
 731                 nm_connectivity_check_async (priv->connectivity,
 732                                              checked_connectivity,
 733                                              g_object_ref (manager));
 734         }
 735
 736         set_state (manager, new_state);
 737 }
 738
 739 static void
 740 manager_device_state_changed (NMDevice *device,
 741                               NMDeviceState new_state,
 742                               NMDeviceState old_state,
 743                               NMDeviceStateReason reason,
 744                               gpointer user_data)
 745 {
 746         NMManager *self = NM_MANAGER (user_data);
 747         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 748
 749         switch (new_state) {
 750         case NM_DEVICE_STATE_UNMANAGED:
 751         case NM_DEVICE_STATE_UNAVAILABLE:
 752         case NM_DEVICE_STATE_DISCONNECTED:
 753         case NM_DEVICE_STATE_PREPARE:
 754         case NM_DEVICE_STATE_FAILED:
 755                 g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVE_CONNECTIONS);
 756                 break;
 757         default:
 758                 break;
 759         }
 760
 761         if (   new_state == NM_DEVICE_STATE_UNAVAILABLE
 762             || new_state == NM_DEVICE_STATE_DISCONNECTED)
 763                 nm_settings_device_added (priv->settings, device);
 764 }
 765
 766 static void device_has_pending_action_changed (NMDevice *device,
 767                                                GParamSpec *pspec,
 768                                                NMManager *self);
 769
 770 static void
 771 check_if_startup_complete (NMManager *self)
 772 {
 773         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 774         GSList *iter;
 775
 776         if (!priv->startup)
 777                 return;
 778
 779         if (!priv->devices_inited)
 780                 return;
 781
 782         if (!nm_settings_get_startup_complete (priv->settings)) {
 783                 _LOGD (LOGD_CORE, "check_if_startup_complete returns FALSE because of NMSettings");
 784                 return;
 785         }
 786
 787         for (iter = priv->devices; iter; iter = iter->next) {
 788                 NMDevice *dev = iter->data;
 789
 790                 if (nm_device_has_pending_action (dev)) {
 791                         _LOGD (LOGD_CORE, "check_if_startup_complete returns FALSE because of %s",
 792                                nm_device_get_iface (dev));
 793                         return;
 794                 }
 795         }
 796
 797         _LOGI (LOGD_CORE, "startup complete");
 798
 799         priv->startup = FALSE;
 800         g_object_notify (G_OBJECT (self), "startup");
 801
 802         /* We don't have to watch notify::has-pending-action any more. */
 803         for (iter = priv->devices; iter; iter = iter->next) {
 804                 NMDevice *dev = iter->data;
 805
 806                 g_signal_handlers_disconnect_by_func (dev, G_CALLBACK (device_has_pending_action_changed), self);
 807         }
 808
 809         if (nm_config_get_configure_and_quit (nm_config_get ()))
 810                 g_signal_emit (self, signals[CONFIGURE_QUIT], 0);
 811 }
 812
 813 static void
 814 device_has_pending_action_changed (NMDevice *device,
 815                                    GParamSpec *pspec,
 816                                    NMManager *self)
 817 {
 818         check_if_startup_complete (self);
 819 }
 820
 821 static void
 822 settings_startup_complete_changed (NMSettings *settings,
 823                                    GParamSpec *pspec,
 824                                    NMManager *self)
 825 {
 826         check_if_startup_complete (self);
 827 }
 828
 829 static void
 830 remove_device (NMManager *self,
 831                NMDevice *device,
 832                gboolean quitting,
 833                gboolean allow_unmanage)
 834 {
 835         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 836
 837         _LOGD (LOGD_DEVICE, "(%s): removing device (allow_unmanage %d, managed %d)",
 838                nm_device_get_iface (device), allow_unmanage, nm_device_get_managed (device, FALSE));
 839
 840         if (allow_unmanage && nm_device_get_managed (device, FALSE)) {
 841                 NMActRequest *req = nm_device_get_act_request (device);
 842                 gboolean unmanage = FALSE;
 843
 844                 /* Leave activated interfaces up when quitting so their configuration
 845                  * can be taken over when NM restarts.  This ensures connectivity while
 846                  * NM is stopped. Devices which do not support connection assumption
 847                  * cannot be left up.
 848                  */
 849                 if (!quitting)  /* Forced removal; device already gone */
 850                         unmanage = TRUE;
 851                 else if (!nm_device_can_assume_active_connection (device))
 852                         unmanage = TRUE;
 853                 else if (!req)
 854                         unmanage = TRUE;
 855
 856                 if (unmanage) {
 857                         if (quitting)
 858                                 nm_device_set_unmanaged_by_quitting (device);
 859                         else
 860                                 nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_PLATFORM_INIT, TRUE, NM_DEVICE_STATE_REASON_REMOVED);
 861                 } else if (quitting && nm_config_get_configure_and_quit (nm_config_get ())) {
 862                         nm_device_spawn_iface_helper (device);
 863                 }
 864         }
 865
 866         g_signal_handlers_disconnect_matched (device, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
 867
 868         nm_settings_device_removed (priv->settings, device, quitting);
 869         priv->devices = g_slist_remove (priv->devices, device);
 870
 871         if (nm_device_is_real (device)) {
 872                 g_signal_emit (self, signals[DEVICE_REMOVED], 0, device);
 873                 g_object_notify (G_OBJECT (self), NM_MANAGER_DEVICES);
 874                 nm_device_removed (device);
 875         }
 876         g_signal_emit (self, signals[INTERNAL_DEVICE_REMOVED], 0, device);
 877         g_object_notify (G_OBJECT (self), NM_MANAGER_ALL_DEVICES);
 878
 879         nm_exported_object_clear_and_unexport (&device);
 880
 881         check_if_startup_complete (self);
 882 }
 883
 884 static void
 885 device_removed_cb (NMDevice *device, gpointer user_data)
 886 {
 887         remove_device (NM_MANAGER (user_data), device, FALSE, TRUE);
 888 }
 889
 890 NMState
 891 nm_manager_get_state (NMManager *manager)
 892 {
 893         g_return_val_if_fail (NM_IS_MANAGER (manager), NM_STATE_UNKNOWN);
 894
 895         return NM_MANAGER_GET_PRIVATE (manager)->state;
 896 }
 897
 898 /***************************/
 899
 900 static NMDevice *
 901 find_parent_device_for_connection (NMManager *self, NMConnection *connection, NMDeviceFactory *cached_factory)
 902 {
 903         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
 904         NMDeviceFactory *factory;
 905         const char *parent_name = NULL;
 906         NMSettingsConnection *parent_connection;
 907         NMDevice *parent, *first_compatible = NULL;
 908         GSList *iter;
 909
 910         g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
 911
 912         if (!cached_factory) {
 913                 factory = nm_device_factory_manager_find_factory_for_connection (connection);
 914                 if (!factory)
 915                         return NULL;
 916         } else
 917                 factory = cached_factory;
 918
 919         parent_name = nm_device_factory_get_connection_parent (factory, connection);
 920         if (!parent_name)
 921                 return NULL;
 922
 923         /* Try as an interface name of a parent device */
 924         parent = find_device_by_iface (self, parent_name, NULL, NULL);
 925         if (parent)
 926                 return parent;
 927
 928         /* Maybe a hardware address */
 929         parent = find_device_by_hw_addr (self, parent_name);
 930         if (parent)
 931                 return parent;
 932
 933         /* Maybe a connection UUID */
 934         parent_connection = nm_settings_get_connection_by_uuid (priv->settings, parent_name);
 935         if (!parent_connection)
 936                 return NULL;
 937
 938         /* Check if the parent connection is currently activated or is comaptible
 939          * with some known device.
 940          */
 941         for (iter = priv->devices; iter; iter = iter->next) {
 942                 NMDevice *candidate = iter->data;
 943
 944                 if (nm_device_get_settings_connection (candidate) == parent_connection)
 945                         return candidate;
 946
 947                 if (   !first_compatible
 948                     && nm_device_check_connection_compatible (candidate, NM_CONNECTION (parent_connection)))
 949                         first_compatible = candidate;
 950         }
 951
 952         return first_compatible;
 953 }
 954
 955 /**
 956  * nm_manager_get_connection_iface:
 957  * @self: the #NMManager
 958  * @connection: the #NMConnection to get the interface for
 959  * @out_parent: on success, the parent device if any
 960  * @error: an error if determining the virtual interface name failed
 961  *
 962  * Given @connection, returns the interface name that the connection
 963  * would need to use when activated. %NULL is returned if the name
 964  * is not specified in connection or a the name for a virtual device
 965  * could not be generated.
 966  *
 967  * Returns: the expected interface name (caller takes ownership), or %NULL
 968  */
 969 char *
 970 nm_manager_get_connection_iface (NMManager *self,
 971                                  NMConnection *connection,
 972                                  NMDevice **out_parent,
 973                                  GError **error)
 974 {
 975         NMDeviceFactory *factory;
 976         char *iface = NULL;
 977         NMDevice *parent = NULL;
 978
 979         if (out_parent)
 980                 *out_parent = NULL;
 981
 982         factory = nm_device_factory_manager_find_factory_for_connection (connection);
 983         if (!factory) {
 984                 g_set_error (error,
 985                              NM_MANAGER_ERROR,
 986                              NM_MANAGER_ERROR_FAILED,
 987                              "NetworkManager plugin for '%s' unavailable",
 988                              nm_connection_get_connection_type (connection));
 989                 return NULL;
 990         }
 991
 992         if (   !out_parent
 993             && !NM_DEVICE_FACTORY_GET_INTERFACE (factory)->get_connection_iface) {
 994                 /* optimization. Shortcut lookup of the partent device. */
 995                 iface = g_strdup (nm_connection_get_interface_name (connection));
 996                 if (!iface) {
 997                         g_set_error (error,
 998                                      NM_MANAGER_ERROR,
 999                                      NM_MANAGER_ERROR_FAILED,
1000                                      "failed to determine interface name: error determine name for %s",
1001                                      nm_connection_get_connection_type (connection));
1002                 }
1003                 return iface;
1004         }
1005
1006         parent = find_parent_device_for_connection (self, connection, factory);
1007         iface = nm_device_factory_get_connection_iface (factory,
1008                                                         connection,
1009                                                         parent ? nm_device_get_ip_iface (parent) : NULL,
1010                                                         error);
1011         if (!iface)
1012                 return NULL;
1013
1014         if (out_parent)
1015                 *out_parent = parent;
1016         return iface;
1017 }
1018
1019 /**
1020  * system_create_virtual_device:
1021  * @self: the #NMManager
1022  * @connection: the connection which might require a virtual device
1023  *
1024  * If @connection requires a virtual device and one does not yet exist for it,
1025  * creates that device.
1026  *
1027  * Returns: A #NMDevice that was just realized; %NULL if none
1028  */
1029 static NMDevice *
1030 system_create_virtual_device (NMManager *self, NMConnection *connection)
1031 {
1032         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1033         NMDeviceFactory *factory;
1034         gs_free_slist GSList *connections = NULL;
1035         GSList *iter;
1036         gs_free char *iface = NULL;
1037         NMDevice *device = NULL, *parent = NULL;
1038         GError *error = NULL;
1039
1040         g_return_val_if_fail (NM_IS_MANAGER (self), NULL);
1041         g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
1042
1043         iface = nm_manager_get_connection_iface (self, connection, &parent, &error);
1044         if (!iface) {
1045                 _LOGW (LOGD_DEVICE, "(%s) can't get a name of a virtual device: %s",
1046                        nm_connection_get_id (connection), error->message);
1047                 g_error_free (error);
1048                 return NULL;
1049         }
1050
1051         /* See if there's a device that is already compatible with this connection */
1052         for (iter = priv->devices; iter; iter = g_slist_next (iter)) {
1053                 NMDevice *candidate = iter->data;
1054
1055                 if (nm_device_check_connection_compatible (candidate, connection)) {
1056                         if (nm_device_is_real (candidate)) {
1057                                 _LOGD (LOGD_DEVICE, "(%s) already created virtual interface name %s",
1058                                        nm_connection_get_id (connection), iface);
1059                                 return NULL;
1060                         }
1061
1062                         device = candidate;
1063                         break;
1064                 }
1065         }
1066
1067         if (!device) {
1068                 /* No matching device found. Proceed creating a new one. */
1069
1070                 factory = nm_device_factory_manager_find_factory_for_connection (connection);
1071                 if (!factory) {
1072                         _LOGE (LOGD_DEVICE, "(%s:%s) NetworkManager plugin for '%s' unavailable",
1073                                nm_connection_get_id (connection), iface,
1074                                nm_connection_get_connection_type (connection));
1075                         return NULL;
1076                 }
1077
1078                 device = nm_device_factory_create_device (factory, iface, NULL, connection, NULL, &error);
1079                 if (!device) {
1080                         _LOGW (LOGD_DEVICE, "(%s) factory can't create the device: %s",
1081                                nm_connection_get_id (connection), error->message);
1082                         g_error_free (error);
1083                         return NULL;
1084                 }
1085
1086                 if (!add_device (self, device, &error)) {
1087                         _LOGW (LOGD_DEVICE, "(%s) can't register the device with manager: %s",
1088                                nm_connection_get_id (connection), error->message);
1089                         g_error_free (error);
1090                         g_object_unref (device);
1091                         return NULL;
1092                 }
1093
1094                 /* Add device takes a reference that NMManager still owns, so it's
1095                  * safe to unref here and still return @device.
1096                  */
1097                 g_object_unref (device);
1098         }
1099
1100         /* Create backing resources if the device has any autoconnect connections */
1101         connections = nm_settings_get_connections (priv->settings);
1102         for (iter = connections; iter; iter = g_slist_next (iter)) {
1103                 NMConnection *candidate = iter->data;
1104                 NMSettingConnection *s_con;
1105
1106                 if (!nm_device_check_connection_compatible (device, candidate))
1107                         continue;
1108
1109                 s_con = nm_connection_get_setting_connection (candidate);
1110                 g_assert (s_con);
1111                 if (!nm_setting_connection_get_autoconnect (s_con))
1112                         continue;
1113
1114                 /* Create any backing resources the device needs */
1115                 if (!nm_device_create_and_realize (device, connection, parent, &error)) {
1116                         _LOGW (LOGD_DEVICE, "(%s) couldn't create the device: %s",
1117                                nm_connection_get_id (connection), error->message);
1118                         g_error_free (error);
1119                         remove_device (self, device, FALSE, TRUE);
1120                         return NULL;
1121                 }
1122                 break;
1123         }
1124
1125         return device;
1126 }
1127
1128 static void
1129 retry_connections_for_parent_device (NMManager *self, NMDevice *device)
1130 {
1131         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1132         GSList *connections, *iter;
1133
1134         g_return_if_fail (device);
1135
1136         connections = nm_settings_get_connections (priv->settings);
1137         for (iter = connections; iter; iter = g_slist_next (iter)) {
1138                 NMConnection *candidate = iter->data;
1139                 gs_free_error GError *error = NULL;
1140                 gs_free char *ifname = NULL;
1141                 NMDevice *parent;
1142
1143                 parent = find_parent_device_for_connection (self, candidate, NULL);
1144                 if (parent == device) {
1145                         /* Only try to activate devices that don't already exist */
1146                         ifname = nm_manager_get_connection_iface (self, candidate, &parent, &error);
1147                         if (ifname) {
1148                                 if (!nm_platform_link_get_by_ifname (NM_PLATFORM_GET, ifname))
1149                                         connection_changed (priv->settings, candidate, self);
1150                         }
1151                 }
1152         }
1153
1154         g_slist_free (connections);
1155 }
1156
1157 static void
1158 connection_changed (NMSettings *settings,
1159                     NMConnection *connection,
1160                     NMManager *manager)
1161 {
1162         NMDevice *device;
1163
1164         if (!nm_connection_is_virtual (connection))
1165                 return;
1166
1167         device = system_create_virtual_device (manager, connection);
1168         if (!device)
1169                 return;
1170
1171         /* Maybe the device that was created was needed by some other
1172          * connection's device (parent of a VLAN). Let the connections
1173          * can use the newly created device as a parent know. */
1174         retry_connections_for_parent_device (manager, device);
1175 }
1176
1177 static void
1178 connection_removed (NMSettings *settings,
1179                     NMSettingsConnection *connection,
1180                     NMManager *manager)
1181 {
1182         /*
1183          * Do not delete existing virtual devices to keep connectivity up.
1184          * Virtual devices are reused when NetworkManager is restarted.
1185          */
1186 }
1187
1188 static void
1189 system_unmanaged_devices_changed_cb (NMSettings *settings,
1190                                      GParamSpec *pspec,
1191                                      gpointer user_data)
1192 {
1193         NMManager *self = NM_MANAGER (user_data);
1194         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1195         const GSList *unmanaged_specs, *iter;
1196
1197         unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
1198         for (iter = priv->devices; iter; iter = g_slist_next (iter))
1199                 nm_device_set_unmanaged_by_user_config (NM_DEVICE (iter->data), unmanaged_specs);
1200 }
1201
1202 static void
1203 system_hostname_changed_cb (NMSettings *settings,
1204                             GParamSpec *pspec,
1205                             gpointer user_data)
1206 {
1207         NMManager *self = NM_MANAGER (user_data);
1208         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1209         char *hostname;
1210
1211         hostname = nm_settings_get_hostname (priv->settings);
1212
1213         /* nm_settings_get_hostname() does not return an empty hostname. */
1214         nm_assert (!hostname || *hostname);
1215
1216         if (!hostname && !priv->hostname)
1217                 return;
1218         if (hostname && priv->hostname && !strcmp (hostname, priv->hostname)) {
1219                 g_free (hostname);
1220                 return;
1221         }
1222
1223         /* realloc, to free possibly trailing data after NUL. */
1224         if (hostname)
1225                 hostname = g_realloc (hostname, strlen (hostname) + 1);
1226
1227         g_free (priv->hostname);
1228         priv->hostname = hostname;
1229         g_object_notify (G_OBJECT (self), NM_MANAGER_HOSTNAME);
1230
1231         nm_dhcp_manager_set_default_hostname (nm_dhcp_manager_get (), priv->hostname);
1232 }
1233
1234 /*******************************************************************/
1235 /* General NMManager stuff                                         */
1236 /*******************************************************************/
1237
1238 /* Store value into key-file; supported types: boolean, int, string */
1239 static gboolean
1240 write_value_to_state_file (const char *filename,
1241                            const char *group,
1242                            const char *key,
1243                            GType value_type,
1244                            gpointer value,
1245                            GError **error)
1246 {
1247         GKeyFile *key_file;
1248         char *data;
1249         gsize len = 0;
1250         gboolean ret = FALSE;
1251
1252         g_return_val_if_fail (filename != NULL, FALSE);
1253         g_return_val_if_fail (group != NULL, FALSE);
1254         g_return_val_if_fail (key != NULL, FALSE);
1255         g_return_val_if_fail (value_type == G_TYPE_BOOLEAN ||
1256                               value_type == G_TYPE_INT ||
1257                               value_type == G_TYPE_STRING,
1258                               FALSE);
1259
1260         key_file = g_key_file_new ();
1261
1262         g_key_file_set_list_separator (key_file, ',');
1263         g_key_file_load_from_file (key_file, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
1264         switch (value_type) {
1265         case G_TYPE_BOOLEAN:
1266                 g_key_file_set_boolean (key_file, group, key, *((gboolean *) value));
1267                 break;
1268         case G_TYPE_INT:
1269                 g_key_file_set_integer (key_file, group, key, *((gint *) value));
1270                 break;
1271         case G_TYPE_STRING:
1272                 g_key_file_set_string (key_file, group, key, *((const gchar **) value));
1273                 break;
1274         }
1275
1276         data = g_key_file_to_data (key_file, &len, NULL);
1277         if (data) {
1278                 ret = g_file_set_contents (filename, data, len, error);
1279                 g_free (data);
1280         }
1281         g_key_file_free (key_file);
1282
1283         return ret;
1284 }
1285
1286 static gboolean
1287 radio_enabled_for_rstate (RadioState *rstate, gboolean check_changeable)
1288 {
1289         gboolean enabled;
1290
1291         enabled = rstate->user_enabled && rstate->hw_enabled;
1292         if (check_changeable)
1293                 enabled &= rstate->sw_enabled;
1294         return enabled;
1295 }
1296
1297 static gboolean
1298 radio_enabled_for_type (NMManager *self, RfKillType rtype, gboolean check_changeable)
1299 {
1300         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1301
1302         return radio_enabled_for_rstate (&priv->radio_states[rtype], check_changeable);
1303 }
1304
1305 static void
1306 manager_update_radio_enabled (NMManager *self,
1307                               RadioState *rstate,
1308                               gboolean enabled)
1309 {
1310         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1311         GSList *iter;
1312
1313         /* Do nothing for radio types not yet implemented */
1314         if (!rstate->prop)
1315                 return;
1316
1317         g_object_notify (G_OBJECT (self), rstate->prop);
1318
1319         /* Don't touch devices if asleep/networking disabled */
1320         if (manager_sleeping (self))
1321                 return;
1322
1323         /* enable/disable wireless devices as required */
1324         for (iter = priv->devices; iter; iter = iter->next) {
1325                 NMDevice *device = NM_DEVICE (iter->data);
1326
1327                 if (nm_device_get_rfkill_type (device) == rstate->rtype) {
1328                         _LOGD (LOGD_RFKILL, "(%s): setting radio %s",
1329                                nm_device_get_iface (device),
1330                                enabled ? "enabled" : "disabled");
1331                         nm_device_set_enabled (device, enabled);
1332                 }
1333         }
1334 }
1335
1336 static void
1337 update_rstate_from_rfkill (NMRfkillManager *rfkill_mgr, RadioState *rstate)
1338 {
1339         switch (nm_rfkill_manager_get_rfkill_state (rfkill_mgr, rstate->rtype)) {
1340         case RFKILL_UNBLOCKED:
1341                 rstate->sw_enabled = TRUE;
1342                 rstate->hw_enabled = TRUE;
1343                 break;
1344         case RFKILL_SOFT_BLOCKED:
1345                 rstate->sw_enabled = FALSE;
1346                 rstate->hw_enabled = TRUE;
1347                 break;
1348         case RFKILL_HARD_BLOCKED:
1349                 rstate->sw_enabled = FALSE;
1350                 rstate->hw_enabled = FALSE;
1351                 break;
1352         default:
1353                 g_warn_if_reached ();
1354                 break;
1355         }
1356 }
1357
1358 static void
1359 manager_rfkill_update_one_type (NMManager *self,
1360                                 RadioState *rstate,
1361                                 RfKillType rtype)
1362 {
1363         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1364         gboolean old_enabled, new_enabled, old_rfkilled, new_rfkilled, old_hwe;
1365
1366         old_enabled = radio_enabled_for_rstate (rstate, TRUE);
1367         old_rfkilled = rstate->hw_enabled && rstate->sw_enabled;
1368         old_hwe = rstate->hw_enabled;
1369
1370         /* recheck kernel rfkill state */
1371         update_rstate_from_rfkill (priv->rfkill_mgr, rstate);
1372
1373         /* Print out all states affecting device enablement */
1374         if (rstate->desc) {
1375                 _LOGD (LOGD_RFKILL, "%s hw-enabled %d sw-enabled %d",
1376                        rstate->desc, rstate->hw_enabled, rstate->sw_enabled);
1377         }
1378
1379         /* Log new killswitch state */
1380         new_rfkilled = rstate->hw_enabled && rstate->sw_enabled;
1381         if (old_rfkilled != new_rfkilled) {
1382                 _LOGI (LOGD_RFKILL, "%s now %s by radio killswitch",
1383                        rstate->desc,
1384                        new_rfkilled ? "enabled" : "disabled");
1385         }
1386
1387         /* Send out property changed signal for HW enabled */
1388         if (rstate->hw_enabled != old_hwe) {
1389                 if (rstate->hw_prop)
1390                         g_object_notify (G_OBJECT (self), rstate->hw_prop);
1391         }
1392
1393         /* And finally update the actual device radio state itself; respect the
1394          * daemon state here because this is never called from user-triggered
1395          * radio changes and we only want to ignore the daemon enabled state when
1396          * handling user radio change requests.
1397          */
1398         new_enabled = radio_enabled_for_rstate (rstate, TRUE);
1399         if (new_enabled != old_enabled)
1400                 manager_update_radio_enabled (self, rstate, new_enabled);
1401 }
1402
1403 static void
1404 nm_manager_rfkill_update (NMManager *self, RfKillType rtype)
1405 {
1406         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1407         guint i;
1408
1409         if (rtype != RFKILL_TYPE_UNKNOWN)
1410                 manager_rfkill_update_one_type (self, &priv->radio_states[rtype], rtype);
1411         else {
1412                 /* Otherwise sync all radio types */
1413                 for (i = 0; i < RFKILL_TYPE_MAX; i++)
1414                         manager_rfkill_update_one_type (self, &priv->radio_states[i], i);
1415         }
1416 }
1417
1418 static void
1419 device_auth_done_cb (NMAuthChain *chain,
1420                      GError *auth_error,
1421                      GDBusMethodInvocation *context,
1422                      gpointer user_data)
1423 {
1424         NMManager *self = NM_MANAGER (user_data);
1425         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1426         GError *error = NULL;
1427         NMAuthCallResult result;
1428         NMDevice *device;
1429         const char *permission;
1430         NMDeviceAuthRequestFunc callback;
1431         NMAuthSubject *subject;
1432
1433         g_assert (context);
1434
1435         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
1436
1437         permission = nm_auth_chain_get_data (chain, "requested-permission");
1438         g_assert (permission);
1439         callback = nm_auth_chain_get_data (chain, "callback");
1440         g_assert (callback);
1441         device = nm_auth_chain_get_data (chain, "device");
1442         g_assert (device);
1443
1444         result = nm_auth_chain_get_result (chain, permission);
1445         subject = nm_auth_chain_get_subject (chain);
1446
1447         if (auth_error) {
1448                 /* translate the auth error into a manager permission denied error */
1449                 _LOGD (LOGD_CORE, "%s request failed: %s", permission, auth_error->message);
1450                 error = g_error_new (NM_MANAGER_ERROR,
1451                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
1452                                      "%s request failed: %s",
1453                                      permission, auth_error->message);
1454         } else if (result != NM_AUTH_CALL_RESULT_YES) {
1455                 _LOGD (LOGD_CORE, "%s request failed: not authorized", permission);
1456                 error = g_error_new (NM_MANAGER_ERROR,
1457                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
1458                                      "%s request failed: not authorized",
1459                                      permission);
1460         }
1461
1462         g_assert (error || (result == NM_AUTH_CALL_RESULT_YES));
1463
1464         callback (device,
1465                   context,
1466                   subject,
1467                   error,
1468                   nm_auth_chain_get_data (chain, "user-data"));
1469
1470         g_clear_error (&error);
1471         nm_auth_chain_unref (chain);
1472 }
1473
1474 static void
1475 device_auth_request_cb (NMDevice *device,
1476                         GDBusMethodInvocation *context,
1477                         NMConnection *connection,
1478                         const char *permission,
1479                         gboolean allow_interaction,
1480                         NMDeviceAuthRequestFunc callback,
1481                         gpointer user_data,
1482                         NMManager *self)
1483 {
1484         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1485         GError *error = NULL;
1486         NMAuthSubject *subject = NULL;
1487         char *error_desc = NULL;
1488         NMAuthChain *chain;
1489
1490         /* Validate the caller */
1491         subject = nm_auth_subject_new_unix_process_from_context (context);
1492         if (!subject) {
1493                 error = g_error_new_literal (NM_MANAGER_ERROR,
1494                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
1495                                              "Failed to get request UID.");
1496                 goto done;
1497         }
1498
1499         /* Ensure the subject has permissions for this connection */
1500         if (connection && !nm_auth_is_subject_in_acl (connection,
1501                                                       subject,
1502                                                       &error_desc)) {
1503                 error = g_error_new_literal (NM_MANAGER_ERROR,
1504                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
1505                                              error_desc);
1506                 g_free (error_desc);
1507                 goto done;
1508         }
1509
1510         /* Validate the request */
1511         chain = nm_auth_chain_new_subject (subject, context, device_auth_done_cb, self);
1512         if (!chain) {
1513                 error = g_error_new_literal (NM_MANAGER_ERROR,
1514                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
1515                                              "Unable to authenticate request.");
1516                 goto done;
1517         }
1518
1519         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
1520         nm_auth_chain_set_data (chain, "device", g_object_ref (device), g_object_unref);
1521         nm_auth_chain_set_data (chain, "requested-permission", g_strdup (permission), g_free);
1522         nm_auth_chain_set_data (chain, "callback", callback, NULL);
1523         nm_auth_chain_set_data (chain, "user-data", user_data, NULL);
1524         nm_auth_chain_add_call (chain, permission, allow_interaction);
1525
1526 done:
1527         if (error)
1528                 callback (device, context, subject, error, user_data);
1529
1530         g_clear_object (&subject);
1531         g_clear_error (&error);
1532 }
1533
1534 static gboolean
1535 match_connection_filter (NMConnection *connection, gpointer user_data)
1536 {
1537         if (nm_settings_connection_get_nm_generated_assumed (NM_SETTINGS_CONNECTION (connection)))
1538                 return FALSE;
1539
1540         return nm_device_check_connection_compatible (NM_DEVICE (user_data), connection);
1541 }
1542
1543 /**
1544  * get_existing_connection:
1545  * @manager: #NMManager instance
1546  * @device: #NMDevice instance
1547  * @out_generated: (allow-none): return TRUE, if the connection was generated.
1548  *
1549  * Returns: a #NMSettingsConnection to be assumed by the device, or %NULL if
1550  *   the device does not support assuming existing connections.
1551  */
1552 static NMSettingsConnection *
1553 get_existing_connection (NMManager *self, NMDevice *device, gboolean *out_generated)
1554 {
1555         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1556         gs_free_slist GSList *connections = nm_manager_get_activatable_connections (self);
1557         NMConnection *connection = NULL;
1558         NMSettingsConnection *matched;
1559         NMSettingsConnection *added = NULL;
1560         GError *error = NULL;
1561         NMDevice *master = NULL;
1562         int ifindex = nm_device_get_ifindex (device);
1563
1564         if (out_generated)
1565                 *out_generated = FALSE;
1566
1567         nm_device_capture_initial_config (device);
1568
1569         if (ifindex) {
1570                 int master_ifindex = nm_platform_link_get_master (NM_PLATFORM_GET, ifindex);
1571
1572                 if (master_ifindex) {
1573                         master = nm_manager_get_device_by_ifindex (self, master_ifindex);
1574                         if (!master) {
1575                                 _LOGD (LOGD_DEVICE, "(%s): cannot generate connection for slave before its master (%s/%d)",
1576                                        nm_device_get_iface (device), nm_platform_link_get_name (NM_PLATFORM_GET, master_ifindex), master_ifindex);
1577                                 return NULL;
1578                         }
1579                         if (!nm_device_get_act_request (master)) {
1580                                 _LOGD (LOGD_DEVICE, "(%s): cannot generate connection for slave before master %s activates",
1581                                        nm_device_get_iface (device), nm_device_get_iface (master));
1582                                 return NULL;
1583                         }
1584                 }
1585         }
1586
1587         /* The core of the API is nm_device_generate_connection() function and
1588          * update_connection() virtual method and the convenient connection_type
1589          * class attribute. Subclasses supporting the new API must have
1590          * update_connection() implemented, otherwise nm_device_generate_connection()
1591          * returns NULL.
1592          */
1593         connection = nm_device_generate_connection (device, master);
1594         if (!connection)
1595                 return NULL;
1596
1597         /* Now we need to compare the generated connection to each configured
1598          * connection. The comparison function is the heart of the connection
1599          * assumption implementation and it must compare the connections very
1600          * carefully to sort out various corner cases. Also, the comparison is
1601          * not entirely symmetric.
1602          *
1603          * When no configured connection matches the generated connection, we keep
1604          * the generated connection instead.
1605          */
1606         connections = g_slist_reverse (g_slist_sort (connections, nm_settings_sort_connections));
1607         matched = NM_SETTINGS_CONNECTION (nm_utils_match_connection (connections,
1608                                                                      connection,
1609                                                                      nm_device_has_carrier (device),
1610                                                                      nm_device_get_ip4_route_metric (device),
1611                                                                      nm_device_get_ip6_route_metric (device),
1612                                                                      match_connection_filter,
1613                                                                      device));
1614         if (matched) {
1615                 _LOGI (LOGD_DEVICE, "(%s): found matching connection '%s'",
1616                        nm_device_get_iface (device),
1617                        nm_settings_connection_get_id (matched));
1618                 g_object_unref (connection);
1619                 return matched;
1620         }
1621
1622         _LOGD (LOGD_DEVICE, "(%s): generated connection '%s'",
1623                nm_device_get_iface (device),
1624                nm_connection_get_id (connection));
1625
1626         added = nm_settings_add_connection (priv->settings, connection, FALSE, &error);
1627         if (added) {
1628                 nm_settings_connection_set_flags (NM_SETTINGS_CONNECTION (added),
1629                                                   NM_SETTINGS_CONNECTION_FLAGS_NM_GENERATED |
1630                                                   NM_SETTINGS_CONNECTION_FLAGS_NM_GENERATED_ASSUMED,
1631                                                   TRUE);
1632                 if (out_generated)
1633                         *out_generated = TRUE;
1634         } else {
1635                 _LOGW (LOGD_SETTINGS, "(%s) Couldn't save generated connection '%s': %s",
1636                        nm_device_get_iface (device),
1637                        nm_connection_get_id (connection),
1638                        error->message);
1639                 g_clear_error (&error);
1640         }
1641         g_object_unref (connection);
1642
1643         return added ? added : NULL;
1644 }
1645
1646 static gboolean
1647 assume_connection (NMManager *self, NMDevice *device, NMSettingsConnection *connection)
1648 {
1649         NMActiveConnection *active, *master_ac;
1650         NMAuthSubject *subject;
1651         GError *error = NULL;
1652
1653         _LOGD (LOGD_DEVICE, "(%s): will attempt to assume connection",
1654                nm_device_get_iface (device));
1655
1656         /* Move device to DISCONNECTED to activate the connection */
1657         if (nm_device_get_state (device) == NM_DEVICE_STATE_UNAVAILABLE) {
1658                 nm_device_state_changed (device,
1659                                          NM_DEVICE_STATE_DISCONNECTED,
1660                                          NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED);
1661         }
1662         g_return_val_if_fail (nm_device_get_state (device) >= NM_DEVICE_STATE_DISCONNECTED, FALSE);
1663
1664         subject = nm_auth_subject_new_internal ();
1665         active = _new_active_connection (self, NM_CONNECTION (connection), NULL, device, subject, &error);
1666         g_object_unref (subject);
1667
1668         if (!active) {
1669                 _LOGW (LOGD_DEVICE, "assumed connection %s failed to activate: %s",
1670                        nm_connection_get_path (NM_CONNECTION (connection)),
1671                        error->message);
1672                 g_error_free (error);
1673                 return FALSE;
1674         }
1675
1676         /* If the device is a slave or VLAN, find the master ActiveConnection */
1677         master_ac = NULL;
1678         if (find_master (self, NM_CONNECTION (connection), device, NULL, NULL, &master_ac, NULL) && master_ac)
1679                 nm_active_connection_set_master (active, master_ac);
1680
1681         nm_active_connection_set_assumed (active, TRUE);
1682         nm_exported_object_export (NM_EXPORTED_OBJECT (active));
1683         active_connection_add (self, active);
1684         nm_device_queue_activation (device, NM_ACT_REQUEST (active));
1685         g_object_unref (active);
1686
1687         return TRUE;
1688 }
1689
1690 static gboolean
1691 recheck_assume_connection (NMManager *self, NMDevice *device)
1692 {
1693         NMSettingsConnection *connection;
1694         gboolean was_unmanaged = FALSE, success, generated = FALSE;
1695         NMDeviceState state;
1696
1697         g_return_val_if_fail (NM_IS_MANAGER (self), FALSE);
1698         g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
1699
1700         if (nm_device_get_is_nm_owned (device))
1701                 return FALSE;
1702
1703         if (!nm_device_get_managed (device, FALSE))
1704                 return FALSE;
1705
1706         state = nm_device_get_state (device);
1707         if (state > NM_DEVICE_STATE_DISCONNECTED)
1708                 return FALSE;
1709
1710         connection = get_existing_connection (self, device, &generated);
1711         if (!connection) {
1712                 _LOGD (LOGD_DEVICE, "(%s): can't assume; no connection",
1713                        nm_device_get_iface (device));
1714                 return FALSE;
1715         }
1716
1717         if (state == NM_DEVICE_STATE_UNMANAGED) {
1718                 was_unmanaged = TRUE;
1719                 nm_device_state_changed (device,
1720                                          NM_DEVICE_STATE_UNAVAILABLE,
1721                                          NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED);
1722         }
1723
1724         success = assume_connection (self, device, connection);
1725         if (!success) {
1726                 if (was_unmanaged) {
1727                         nm_device_state_changed (device,
1728                                                  NM_DEVICE_STATE_UNAVAILABLE,
1729                                                  NM_DEVICE_STATE_REASON_CONFIG_FAILED);
1730                 }
1731
1732                 if (generated) {
1733                         _LOGD (LOGD_DEVICE, "(%s): connection assumption failed. Deleting generated connection",
1734                                nm_device_get_iface (device));
1735
1736                         nm_settings_connection_delete (connection, NULL, NULL);
1737                 }
1738         }
1739
1740         return success;
1741 }
1742
1743 static void
1744 recheck_assume_connection_cb (NMDevice *device, gpointer user_data)
1745 {
1746         recheck_assume_connection (user_data, device);
1747 }
1748
1749 static void
1750 device_ip_iface_changed (NMDevice *device,
1751                          GParamSpec *pspec,
1752                          NMManager *self)
1753 {
1754         const char *ip_iface = nm_device_get_ip_iface (device);
1755         GSList *iter;
1756
1757         /* Remove NMDevice objects that are actually child devices of others,
1758          * when the other device finally knows its IP interface name.  For example,
1759          * remove the PPP interface that's a child of a WWAN device, since it's
1760          * not really a standalone NMDevice.
1761          */
1762         for (iter = NM_MANAGER_GET_PRIVATE (self)->devices; iter; iter = iter->next) {
1763                 NMDevice *candidate = NM_DEVICE (iter->data);
1764
1765                 if (   candidate != device
1766                     && g_strcmp0 (nm_device_get_iface (candidate), ip_iface) == 0
1767                     && nm_device_is_real (candidate)) {
1768                         remove_device (self, candidate, FALSE, FALSE);
1769                         break;
1770                 }
1771         }
1772 }
1773
1774 static void
1775 device_iface_changed (NMDevice *device,
1776                       GParamSpec *pspec,
1777                       NMManager *self)
1778 {
1779         /* Virtual connections may refer to the new device name as
1780          * parent device, retry to activate them.
1781          */
1782         retry_connections_for_parent_device (self, device);
1783 }
1784
1785
1786 static void
1787 device_realized (NMDevice *device,
1788                  GParamSpec *pspec,
1789                  NMManager *self)
1790 {
1791         /* Emit D-Bus signals */
1792         g_signal_emit (self, signals[DEVICE_ADDED], 0, device);
1793         g_object_notify (G_OBJECT (self), NM_MANAGER_DEVICES);
1794 }
1795
1796 static void
1797 _device_realize_finish (NMManager *self, NMDevice *device, const NMPlatformLink *plink)
1798 {
1799         g_return_if_fail (NM_IS_MANAGER (self));
1800         g_return_if_fail (NM_IS_DEVICE (device));
1801
1802         nm_device_realize_finish (device, plink);
1803
1804         if (!nm_device_get_managed (device, FALSE))
1805                 return;
1806
1807         if (recheck_assume_connection (self, device))
1808                 return;
1809
1810         /* if we failed to assume a connection for the managed device, but the device
1811          * is still unavailable. Set UNAVAILABLE state again, this time with NOW_MANAGED. */
1812         nm_device_state_changed (device,
1813                                  NM_DEVICE_STATE_UNAVAILABLE,
1814                                  NM_DEVICE_STATE_REASON_NOW_MANAGED);
1815         nm_device_emit_recheck_auto_activate (device);
1816 }
1817
1818 /**
1819  * add_device:
1820  * @self: the #NMManager
1821  * @device: the #NMDevice to add
1822  * @error: (out): the #GError
1823  *
1824  * If successful, this function will increase the references count of @device.
1825  * Callers should decrease the reference count.
1826  */
1827 static gboolean
1828 add_device (NMManager *self, NMDevice *device, GError **error)
1829 {
1830         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
1831         const char *iface, *type_desc;
1832         RfKillType rtype;
1833         GSList *iter, *remove = NULL;
1834         int ifindex;
1835         const char *dbus_path;
1836
1837         /* No duplicates */
1838         ifindex = nm_device_get_ifindex (device);
1839         if (ifindex > 0 && nm_manager_get_device_by_ifindex (self, ifindex)) {
1840                 g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED,
1841                              "A device with ifindex %d already exists", ifindex);
1842                 return FALSE;
1843         }
1844
1845         /* Remove existing devices owned by the new device; eg remove ethernet
1846          * ports that are owned by a WWAN modem, since udev may announce them
1847          * before the modem is fully discovered.
1848          *
1849          * FIXME: use parent/child device relationships instead of removing
1850          * the child NMDevice entirely
1851          */
1852         for (iter = priv->devices; iter; iter = iter->next) {
1853                 NMDevice *candidate = iter->data;
1854
1855                 iface = nm_device_get_ip_iface (candidate);
1856                 if (nm_device_is_real (candidate) && nm_device_owns_iface (device, iface))
1857                         remove = g_slist_prepend (remove, candidate);
1858         }
1859         for (iter = remove; iter; iter = iter->next)
1860                 remove_device (self, NM_DEVICE (iter->data), FALSE, FALSE);
1861         g_slist_free (remove);
1862
1863         priv->devices = g_slist_append (priv->devices, g_object_ref (device));
1864
1865         g_signal_connect (device, NM_DEVICE_STATE_CHANGED,
1866                           G_CALLBACK (manager_device_state_changed),
1867                           self);
1868
1869         g_signal_connect (device, NM_DEVICE_AUTH_REQUEST,
1870                           G_CALLBACK (device_auth_request_cb),
1871                           self);
1872
1873         g_signal_connect (device, NM_DEVICE_REMOVED,
1874                           G_CALLBACK (device_removed_cb),
1875                           self);
1876
1877         g_signal_connect (device, NM_DEVICE_RECHECK_ASSUME,
1878                           G_CALLBACK (recheck_assume_connection_cb),
1879                           self);
1880
1881         g_signal_connect (device, "notify::" NM_DEVICE_IP_IFACE,
1882                           G_CALLBACK (device_ip_iface_changed),
1883                           self);
1884
1885         g_signal_connect (device, "notify::" NM_DEVICE_IFACE,
1886                           G_CALLBACK (device_iface_changed),
1887                           self);
1888
1889         g_signal_connect (device, "notify::" NM_DEVICE_REAL,
1890                           G_CALLBACK (device_realized),
1891                           self);
1892
1893         if (priv->startup) {
1894                 g_signal_connect (device, "notify::" NM_DEVICE_HAS_PENDING_ACTION,
1895                                   G_CALLBACK (device_has_pending_action_changed),
1896                                   self);
1897         }
1898
1899         /* Update global rfkill state for this device type with the device's
1900          * rfkill state, and then set this device's rfkill state based on the
1901          * global state.
1902          */
1903         rtype = nm_device_get_rfkill_type (device);
1904         if (rtype != RFKILL_TYPE_UNKNOWN) {
1905                 nm_manager_rfkill_update (self, rtype);
1906                 nm_device_set_enabled (device, radio_enabled_for_type (self, rtype, TRUE));
1907         }
1908
1909         iface = nm_device_get_iface (device);
1910         g_assert (iface);
1911         type_desc = nm_device_get_type_desc (device);
1912         g_assert (type_desc);
1913
1914         nm_device_set_unmanaged_by_user_config (device, nm_settings_get_unmanaged_specs (priv->settings));
1915
1916         nm_device_set_unmanaged_flags (device,
1917                                        NM_UNMANAGED_SLEEPING,
1918                                        manager_sleeping (self));
1919
1920         dbus_path = nm_exported_object_export (NM_EXPORTED_OBJECT (device));
1921         _LOGI (LOGD_DEVICE, "(%s): new %s device (%s)", iface, type_desc, dbus_path);
1922
1923         nm_settings_device_added (priv->settings, device);
1924         g_signal_emit (self, signals[INTERNAL_DEVICE_ADDED], 0, device);
1925         g_object_notify (G_OBJECT (self), NM_MANAGER_ALL_DEVICES);
1926
1927         for (iter = priv->devices; iter; iter = iter->next) {
1928                 NMDevice *d = iter->data;
1929
1930                 if (d != device)
1931                         nm_device_notify_new_device_added (d, device);
1932         }
1933
1934         /* Virtual connections may refer to the new device as
1935          * parent device, retry to activate them.
1936          */
1937         retry_connections_for_parent_device (self, device);
1938
1939         return TRUE;
1940 }
1941
1942 /*******************************************************************/
1943
1944 static void
1945 factory_device_added_cb (NMDeviceFactory *factory,
1946                          NMDevice *device,
1947                          gpointer user_data)
1948 {
1949         NMManager *self = user_data;
1950         GError *error = NULL;
1951
1952         g_return_if_fail (NM_IS_MANAGER (self));
1953
1954         if (nm_device_realize_start (device, NULL, NULL, &error)) {
1955                 add_device (self, device, NULL);
1956                 _device_realize_finish (self, device, NULL);
1957         } else {
1958                 _LOGW (LOGD_DEVICE, "(%s): failed to realize device: %s",
1959                        nm_device_get_iface (device), error->message);
1960                 g_error_free (error);
1961         }
1962 }
1963
1964 static gboolean
1965 factory_component_added_cb (NMDeviceFactory *factory,
1966                             GObject *component,
1967                             gpointer user_data)
1968 {
1969         GSList *iter;
1970
1971         g_return_val_if_fail (NM_IS_MANAGER (user_data), FALSE);
1972
1973         for (iter = NM_MANAGER_GET_PRIVATE (user_data)->devices; iter; iter = iter->next) {
1974                 if (nm_device_notify_component_added ((NMDevice *) iter->data, component))
1975                         return TRUE;
1976         }
1977         return FALSE;
1978 }
1979
1980 static void
1981 _register_device_factory (NMDeviceFactory *factory, gpointer user_data)
1982 {
1983         NMManager *self = NM_MANAGER (user_data);
1984
1985         g_signal_connect (factory,
1986                           NM_DEVICE_FACTORY_DEVICE_ADDED,
1987                           G_CALLBACK (factory_device_added_cb),
1988                           self);
1989         g_signal_connect (factory,
1990                           NM_DEVICE_FACTORY_COMPONENT_ADDED,
1991                           G_CALLBACK (factory_component_added_cb),
1992                           self);
1993 }
1994
1995 /*******************************************************************/
1996
1997 static void
1998 platform_link_added (NMManager *self,
1999                      int ifindex,
2000                      const NMPlatformLink *plink)
2001 {
2002         NMDeviceFactory *factory;
2003         NMDevice *device = NULL;
2004         GError *error = NULL;
2005         gboolean nm_plugin_missing = FALSE;
2006         GSList *iter;
2007
2008         g_return_if_fail (ifindex > 0);
2009
2010         if (nm_manager_get_device_by_ifindex (self, ifindex))
2011                 return;
2012
2013         /* Let unrealized devices try to realize themselves with the link */
2014         for (iter = NM_MANAGER_GET_PRIVATE (self)->devices; iter; iter = iter->next) {
2015                 NMDevice *candidate = iter->data;
2016                 gboolean compatible = TRUE;
2017
2018                 if (strcmp (nm_device_get_iface (candidate), plink->name))
2019                         continue;
2020
2021                 if (nm_device_is_real (candidate)) {
2022                         /* Ignore the link added event since there's already a realized
2023                          * device with the link's name.
2024                          */
2025                         return;
2026                 } else if (nm_device_realize_start (candidate, plink, &compatible, &error)) {
2027                         /* Success */
2028                         _device_realize_finish (self, candidate, plink);
2029                         return;
2030                 }
2031
2032                 _LOGD (LOGD_DEVICE, "(%s): failed to realize from plink: '%s'",
2033                        plink->name, error->message);
2034                 g_clear_error (&error);
2035
2036                 /* Try next unrealized device */
2037         }
2038
2039         /* Try registered device factories */
2040         factory = nm_device_factory_manager_find_factory_for_link_type (plink->type);
2041         if (factory) {
2042                 gboolean ignore = FALSE;
2043
2044                 device = nm_device_factory_create_device (factory, plink->name, plink, NULL, &ignore, &error);
2045                 if (!device) {
2046                         if (!ignore) {
2047                                 _LOGW (LOGD_HW, "%s: factory failed to create device: %s",
2048                                        plink->name, error->message);
2049                                 g_clear_error (&error);
2050                         }
2051                         return;
2052                 }
2053         }
2054
2055         if (device == NULL) {
2056                 switch (plink->type) {
2057                 case NM_LINK_TYPE_WWAN_ETHERNET:
2058                 case NM_LINK_TYPE_BNEP:
2059                 case NM_LINK_TYPE_OLPC_MESH:
2060                 case NM_LINK_TYPE_TEAM:
2061                 case NM_LINK_TYPE_WIFI:
2062                         _LOGI (LOGD_HW, "(%s): '%s' plugin not available; creating generic device",
2063                                plink->name, nm_link_type_to_string (plink->type));
2064                         nm_plugin_missing = TRUE;
2065                         /* fall through */
2066                 default:
2067                         device = nm_device_generic_new (plink);
2068                         break;
2069                 }
2070         }
2071
2072         if (device) {
2073                 if (nm_plugin_missing)
2074                         nm_device_set_nm_plugin_missing (device, TRUE);
2075                 if (nm_device_realize_start (device, plink, NULL, &error)) {
2076                         add_device (self, device, NULL);
2077                         _device_realize_finish (self, device, plink);
2078                 } else {
2079                         _LOGW (LOGD_DEVICE, "%s: failed to realize device: %s",
2080                                plink->name, error->message);
2081                         g_clear_error (&error);
2082                 }
2083                 g_object_unref (device);
2084         }
2085 }
2086
2087 typedef struct {
2088         NMManager *self;
2089         int ifindex;
2090 } PlatformLinkCbData;
2091
2092 static gboolean
2093 _platform_link_cb_idle (PlatformLinkCbData *data)
2094 {
2095         NMManager *self = data->self;
2096         const NMPlatformLink *l;
2097
2098         if (!self)
2099                 goto out;
2100
2101         g_object_remove_weak_pointer (G_OBJECT (self), (gpointer *) &data->self);
2102
2103         l = nm_platform_link_get (NM_PLATFORM_GET, data->ifindex);
2104         if (l) {
2105                 NMPlatformLink pllink;
2106
2107                 pllink = *l; /* make a copy of the link instance */
2108                 platform_link_added (self, data->ifindex, &pllink);
2109         } else {
2110                 NMDevice *device;
2111                 GError *error = NULL;
2112
2113                 device = nm_manager_get_device_by_ifindex (self, data->ifindex);
2114                 if (device) {
2115                         if (nm_device_is_software (device)) {
2116                                 /* Our software devices stick around until their connection is removed */
2117                                 if (!nm_device_unrealize (device, FALSE, &error)) {
2118                                         _LOGW (LOGD_DEVICE, "(%s): failed to unrealize: %s",
2119                                                nm_device_get_iface (device),
2120                                                error->message);
2121                                         g_clear_error (&error);
2122                                         remove_device (self, device, FALSE, TRUE);
2123                                 }
2124                         } else {
2125                                 /* Hardware and external devices always get removed when their kernel link is gone */
2126                                 remove_device (self, device, FALSE, TRUE);
2127                         }
2128                 }
2129         }
2130
2131 out:
2132         g_slice_free (PlatformLinkCbData, data);
2133         return G_SOURCE_REMOVE;
2134 }
2135
2136 static void
2137 platform_link_cb (NMPlatform *platform,
2138                   NMPObjectType obj_type,
2139                   int ifindex,
2140                   NMPlatformLink *plink,
2141                   NMPlatformSignalChangeType change_type,
2142                   gpointer user_data)
2143 {
2144         PlatformLinkCbData *data;
2145
2146         switch (change_type) {
2147         case NM_PLATFORM_SIGNAL_ADDED:
2148         case NM_PLATFORM_SIGNAL_REMOVED:
2149                 data = g_slice_new (PlatformLinkCbData);
2150                 data->self = NM_MANAGER (user_data);
2151                 data->ifindex = ifindex;
2152                 g_object_add_weak_pointer (G_OBJECT (data->self), (gpointer *) &data->self);
2153                 g_idle_add ((GSourceFunc) _platform_link_cb_idle, data);
2154                 break;
2155         default:
2156                 break;
2157         }
2158 }
2159
2160 static void
2161 platform_query_devices (NMManager *self)
2162 {
2163         GArray *links_array;
2164         NMPlatformLink *links;
2165         int i;
2166
2167         links_array = nm_platform_link_get_all (NM_PLATFORM_GET);
2168         links = (NMPlatformLink *) links_array->data;
2169         for (i = 0; i < links_array->len; i++)
2170                 platform_link_added (self, links[i].ifindex, &links[i]);
2171
2172         g_array_unref (links_array);
2173 }
2174
2175 static void
2176 rfkill_manager_rfkill_changed_cb (NMRfkillManager *rfkill_mgr,
2177                                   RfKillType rtype,
2178                                   RfKillState udev_state,
2179                                   gpointer user_data)
2180 {
2181         nm_manager_rfkill_update (NM_MANAGER (user_data), rtype);
2182 }
2183
2184 const GSList *
2185 nm_manager_get_devices (NMManager *manager)
2186 {
2187         g_return_val_if_fail (NM_IS_MANAGER (manager), NULL);
2188
2189         return NM_MANAGER_GET_PRIVATE (manager)->devices;
2190 }
2191
2192 static NMDevice *
2193 nm_manager_get_connection_device (NMManager *self,
2194                                   NMConnection *connection)
2195 {
2196         NMActiveConnection *ac = find_ac_for_connection (self, connection);
2197         if (ac == NULL)
2198                 return NULL;
2199
2200         return nm_active_connection_get_device (ac);
2201 }
2202
2203 static NMDevice *
2204 nm_manager_get_best_device_for_connection (NMManager *self,
2205                                            NMConnection *connection,
2206                                            gboolean for_user_request)
2207 {
2208         const GSList *devices, *iter;
2209         NMDevice *act_device = nm_manager_get_connection_device (self, connection);
2210         NMDeviceCheckConAvailableFlags flags;
2211
2212         if (act_device)
2213                 return act_device;
2214
2215         flags = for_user_request ? NM_DEVICE_CHECK_CON_AVAILABLE_FOR_USER_REQUEST : NM_DEVICE_CHECK_CON_AVAILABLE_NONE;
2216
2217         /* Pick the first device that's compatible with the connection. */
2218         devices = nm_manager_get_devices (self);
2219         for (iter = devices; iter; iter = g_slist_next (iter)) {
2220                 NMDevice *device = NM_DEVICE (iter->data);
2221
2222                 if (nm_device_check_connection_available (device, connection, flags, NULL))
2223                         return device;
2224         }
2225
2226         /* No luck. :( */
2227         return NULL;
2228 }
2229
2230 static void
2231 _get_devices (NMManager *self,
2232               GDBusMethodInvocation *context,
2233               gboolean all_devices)
2234 {
2235         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
2236         gs_free const char **paths = NULL;
2237         guint i;
2238         GSList *iter;
2239
2240         paths = g_new (const char *, g_slist_length (priv->devices) + 1);
2241
2242         for (i = 0, iter = priv->devices; iter; iter = iter->next) {
2243                 const char *path;
2244
2245                 path = nm_exported_object_get_path (NM_EXPORTED_OBJECT (iter->data));
2246                 if (   path
2247                     && (all_devices || nm_device_is_real (iter->data)))
2248                         paths[i++] = path;
2249         }
2250         paths[i++] = NULL;
2251
2252         g_dbus_method_invocation_return_value (context,
2253                                                g_variant_new ("(^ao)", (char **) paths));
2254 }
2255
2256 static void
2257 impl_manager_get_devices (NMManager *self,
2258                           GDBusMethodInvocation *context)
2259 {
2260         _get_devices (self, context, FALSE);
2261 }
2262
2263 static void
2264 impl_manager_get_all_devices (NMManager *self,
2265                               GDBusMethodInvocation *context)
2266 {
2267         _get_devices (self, context, TRUE);
2268 }
2269
2270 static void
2271 impl_manager_get_device_by_ip_iface (NMManager *self,
2272                                      GDBusMethodInvocation *context,
2273                                      const char *iface)
2274 {
2275         NMDevice *device;
2276         const char *path = NULL;
2277
2278         device = find_device_by_ip_iface (self, iface);
2279         if (device)
2280                 path = nm_exported_object_get_path (NM_EXPORTED_OBJECT (device));
2281
2282         if (path == NULL) {
2283                 g_dbus_method_invocation_return_error (context,
2284                                                        NM_MANAGER_ERROR,
2285                                                        NM_MANAGER_ERROR_UNKNOWN_DEVICE,
2286                                                        "No device found for the requested iface.");
2287         } else {
2288                 g_dbus_method_invocation_return_value (context,
2289                                                        g_variant_new ("(o)", path));
2290         }
2291 }
2292
2293 static gboolean
2294 is_compatible_with_slave (NMConnection *master, NMConnection *slave)
2295 {
2296         NMSettingConnection *s_con;
2297
2298         g_return_val_if_fail (master, FALSE);
2299         g_return_val_if_fail (slave, FALSE);
2300
2301         s_con = nm_connection_get_setting_connection (slave);
2302         g_assert (s_con);
2303
2304         return nm_connection_is_type (master, nm_setting_connection_get_slave_type (s_con));
2305 }
2306
2307 /**
2308  * find_master:
2309  * @self: #NMManager object
2310  * @connection: the #NMConnection to find the master connection and device for
2311  * @device: the #NMDevice, if any, which will activate @connection
2312  * @out_master_connection: on success, the master connection of @connection if
2313  *   that master connection was found
2314  * @out_master_device: on success, the master device of @connection if that
2315  *   master device was found
2316  * @out_master_ac: on success, the master ActiveConnection of @connection if
2317  *   there already is one
2318  * @error: the error, if an error occurred
2319  *
2320  * Given an #NMConnection, attempts to find its master. If @connection has
2321  * no master, this will return %TRUE and @out_master_connection and
2322  * @out_master_device will be untouched.
2323  *
2324  * If @connection does have a master, then the outputs depend on what is in its
2325  * #NMSettingConnection:master property:
2326  *
2327  * If "master" is the ifname of an existing #NMDevice, and that device has a
2328  * compatible master connection activated or activating on it, then
2329  * @out_master_device, @out_master_connection, and @out_master_ac will all be
2330  * set. If the device exists and is idle, only @out_master_device will be set.
2331  * If the device exists and has an incompatible connection on it, an error
2332  * will be returned.
2333  *
2334  * If "master" is the ifname of a non-existent device, then @out_master_device
2335  * will be %NULL, and @out_master_connection will be a connection whose
2336  * activation would cause the creation of that device. @out_master_ac MAY be
2337  * set in this case as well (if the connection has started activating, but has
2338  * not yet created its device).
2339  *
2340  * If "master" is the UUID of a compatible master connection, then
2341  * @out_master_connection will be the identified connection, and @out_master_device
2342  * and/or @out_master_ac will be set if the connection is currently activating.
2343  * (@out_master_device will not be set if the device exists but does not have
2344  * @out_master_connection active/activating on it.)
2345  *
2346  * Returns: %TRUE if the master device and/or connection could be found or if
2347  *  the connection did not require a master, %FALSE otherwise
2348  **/
2349 static gboolean
2350 find_master (NMManager *self,
2351              NMConnection *connection,
2352              NMDevice *device,
2353              NMSettingsConnection **out_master_connection,
2354              NMDevice **out_master_device,
2355              NMActiveConnection **out_master_ac,
2356              GError **error)
2357 {
2358         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
2359         NMSettingConnection *s_con;
2360         const char *master;
2361         NMDevice *master_device = NULL;
2362         NMSettingsConnection *master_connection = NULL;
2363         GSList *iter;
2364
2365         s_con = nm_connection_get_setting_connection (connection);
2366         g_assert (s_con);
2367         master = nm_setting_connection_get_master (s_con);
2368
2369         if (master == NULL)
2370                 return TRUE;  /* success, but no master */
2371
2372         /* Try as an interface name first */
2373         master_device = find_device_by_iface (self, master, NULL, connection);
2374         if (master_device) {
2375                 if (master_device == device) {
2376                         g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2377                                              "Device cannot be its own master");
2378                         return FALSE;
2379                 }
2380
2381                 master_connection = nm_device_get_settings_connection (master_device);
2382                 if (master_connection && !is_compatible_with_slave (NM_CONNECTION (master_connection), connection)) {
2383                         g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2384                                      "The active connection on %s is not a valid master for '%s'",
2385                                      nm_device_get_iface (master_device),
2386                                      nm_connection_get_id (connection));
2387                         return FALSE;
2388                 }
2389         } else {
2390                 /* Try master as a connection UUID */
2391                 master_connection = nm_settings_get_connection_by_uuid (priv->settings, master);
2392                 if (master_connection) {
2393                         /* Check if the master connection is activated on some device already */
2394                         for (iter = priv->devices; iter; iter = g_slist_next (iter)) {
2395                                 NMDevice *candidate = NM_DEVICE (iter->data);
2396
2397                                 if (candidate == device)
2398                                         continue;
2399
2400                                 if (nm_device_get_settings_connection (candidate) == master_connection) {
2401                                         master_device = candidate;
2402                                         break;
2403                                 }
2404                         }
2405                 }
2406         }
2407
2408         if (out_master_connection)
2409                 *out_master_connection = master_connection;
2410         if (out_master_device)
2411                 *out_master_device = master_device;
2412         if (out_master_ac && master_connection)
2413                 *out_master_ac = find_ac_for_connection (self, NM_CONNECTION (master_connection));
2414
2415         if (master_device || master_connection)
2416                 return TRUE;
2417         else {
2418                 g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_DEVICE,
2419                                      "Master connection not found or invalid");
2420                 return FALSE;
2421         }
2422 }
2423
2424 /**
2425  * ensure_master_active_connection:
2426  * @self: the #NMManager
2427  * @subject: the #NMAuthSubject representing the requestor of this activation
2428  * @connection: the connection that should depend on @master_connection
2429  * @device: the #NMDevice, if any, which will activate @connection
2430  * @master_connection: the master connection, or %NULL
2431  * @master_device: the master device, or %NULL
2432  * @error: the error, if an error occurred
2433  *
2434  * Determines whether a given #NMConnection depends on another connection to
2435  * be activated, and if so, finds that master connection or creates it.
2436  *
2437  * If @master_device and @master_connection are both set then @master_connection
2438  * MUST already be activated or activating on @master_device, and the function will
2439  * return the existing #NMActiveConnection.
2440  *
2441  * If only @master_device is set, and it has an #NMActiveConnection, then the
2442  * function will return it if it is a compatible master, or an error if not. If it
2443  * doesn't have an AC, then the function will create one if a compatible master
2444  * connection exists, or return an error if not.
2445  *
2446  * If only @master_connection is set, then this will try to find or create a compatible
2447  * #NMDevice, and either activate @master_connection on that device or return an error.
2448  *
2449  * Returns: the master #NMActiveConnection that the caller should depend on, or
2450  * %NULL if an error occurred
2451  */
2452 static NMActiveConnection *
2453 ensure_master_active_connection (NMManager *self,
2454                                  NMAuthSubject *subject,
2455                                  NMConnection *connection,
2456                                  NMDevice *device,
2457                                  NMSettingsConnection *master_connection,
2458                                  NMDevice *master_device,
2459                                  GError **error)
2460 {
2461         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
2462         NMActiveConnection *master_ac = NULL;
2463         NMDeviceState master_state;
2464         GSList *iter;
2465
2466         g_assert (connection);
2467         g_assert (master_connection || master_device);
2468
2469         /* If the master device isn't activated then we need to activate it using
2470          * compatible connection.  If it's already activating we can just proceed.
2471          */
2472         if (master_device) {
2473                 NMSettingsConnection *device_connection = nm_device_get_settings_connection (master_device);
2474
2475                 /* If we're passed a connection and a device, we require that connection
2476                  * be already activated on the device, eg returned from find_master().
2477                  */
2478                 g_assert (!master_connection || master_connection == device_connection);
2479                 if (device_connection && !is_compatible_with_slave (NM_CONNECTION (device_connection), connection)) {
2480                         g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2481                                      "The active connection on %s is not a valid master for '%s'",
2482                                      nm_device_get_iface (master_device),
2483                                      nm_connection_get_id (connection));
2484                         return NULL;
2485                 }
2486
2487                 master_state = nm_device_get_state (master_device);
2488                 if (   (master_state == NM_DEVICE_STATE_ACTIVATED)
2489                     || nm_device_is_activating (master_device)) {
2490                         /* Device already using master_connection */
2491                         g_assert (device_connection);
2492                         return NM_ACTIVE_CONNECTION (nm_device_get_act_request (master_device));
2493                 }
2494
2495                 /* If the device is disconnected, find a compatible connection and
2496                  * activate it on the device.
2497                  */
2498                 if (master_state == NM_DEVICE_STATE_DISCONNECTED || !nm_device_is_real (master_device)) {
2499                         GSList *connections;
2500
2501                         g_assert (master_connection == NULL);
2502
2503                         /* Find a compatible connection and activate this device using it */
2504                         connections = nm_manager_get_activatable_connections (self);
2505                         for (iter = connections; iter; iter = g_slist_next (iter)) {
2506                                 NMSettingsConnection *candidate = NM_SETTINGS_CONNECTION (iter->data);
2507
2508                                 /* Ensure eg bond/team slave and the candidate master is a
2509                                  * bond/team master
2510                                  */
2511                                 if (!is_compatible_with_slave (NM_CONNECTION (candidate), connection))
2512                                         continue;
2513
2514                                 if (nm_device_check_connection_available (master_device, NM_CONNECTION (candidate), NM_DEVICE_CHECK_CON_AVAILABLE_FOR_USER_REQUEST, NULL)) {
2515                                         master_ac = nm_manager_activate_connection (self,
2516                                                                                     candidate,
2517                                                                                     NULL,
2518                                                                                     master_device,
2519                                                                                     subject,
2520                                                                                     error);
2521                                         if (!master_ac)
2522                                                 g_prefix_error (error, "%s", "Master device activation failed: ");
2523                                         g_slist_free (connections);
2524                                         return master_ac;
2525                                 }
2526                         }
2527                         g_slist_free (connections);
2528
2529                         g_set_error (error,
2530                                      NM_MANAGER_ERROR,
2531                                      NM_MANAGER_ERROR_UNKNOWN_CONNECTION,
2532                                      "No compatible connection found for master device %s.",
2533                                      nm_device_get_iface (master_device));
2534                         return NULL;
2535                 }
2536
2537                 /* Otherwise, the device is unmanaged, unavailable, or disconnecting */
2538                 g_set_error (error,
2539                              NM_MANAGER_ERROR,
2540                              NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2541                              "Master device %s unmanaged or not available for activation",
2542                              nm_device_get_iface (master_device));
2543         } else if (master_connection) {
2544                 gboolean found_device = FALSE;
2545
2546                 /* Find a compatible device and activate it using this connection */
2547                 for (iter = priv->devices; iter; iter = g_slist_next (iter)) {
2548                         NMDevice *candidate = NM_DEVICE (iter->data);
2549
2550                         if (candidate == device) {
2551                                 /* A device obviously can't be its own master */
2552                                 continue;
2553                         }
2554
2555                         if (!nm_device_check_connection_available (candidate, NM_CONNECTION (master_connection), NM_DEVICE_CHECK_CON_AVAILABLE_FOR_USER_REQUEST, NULL))
2556                                 continue;
2557
2558                         found_device = TRUE;
2559                         if (!nm_device_is_software (candidate)) {
2560                                 master_state = nm_device_get_state (candidate);
2561                                 if (nm_device_is_real (candidate) && master_state != NM_DEVICE_STATE_DISCONNECTED)
2562                                         continue;
2563                         }
2564
2565                         master_ac = nm_manager_activate_connection (self,
2566                                                                     master_connection,
2567                                                                     NULL,
2568                                                                     candidate,
2569                                                                     subject,
2570                                                                     error);
2571                         if (!master_ac)
2572                                 g_prefix_error (error, "%s", "Master device activation failed: ");
2573                         return master_ac;
2574                 }
2575
2576                 g_set_error (error,
2577                              NM_MANAGER_ERROR,
2578                              NM_MANAGER_ERROR_UNKNOWN_DEVICE,
2579                              "No compatible disconnected device found for master connection %s.",
2580                              nm_settings_connection_get_uuid (master_connection));
2581         } else
2582                 g_assert_not_reached ();
2583
2584         return NULL;
2585 }
2586
2587 /**
2588  * find_slaves:
2589  * @manager: #NMManager object
2590  * @connection: the master #NMSettingsConnection to find slave connections for
2591  * @device: the master #NMDevice for the @connection
2592  *
2593  * Given an #NMSettingsConnection, attempts to find its slaves. If @connection is not
2594  * master, or has not any slaves, this will return %NULL.
2595  *
2596  * Returns: list of slave connections for given master @connection, or %NULL
2597  **/
2598 static GSList *
2599 find_slaves (NMManager *manager,
2600              NMSettingsConnection *connection,
2601              NMDevice *device)
2602 {
2603         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
2604         GSList *all_connections, *iter;
2605         GSList *slaves = NULL;
2606         NMSettingConnection *s_con;
2607         const char *master;
2608
2609         s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));
2610         g_assert (s_con);
2611         master = nm_setting_connection_get_master (s_con);
2612
2613         if (master != NULL)
2614                 return NULL;  /* connection is not master */
2615
2616         /* Search through all connections, not only inactive ones, because
2617          * even if a slave was already active, it might be deactivated during
2618          * master reactivation.
2619          */
2620         all_connections = nm_settings_get_connections (priv->settings);
2621         for (iter = all_connections; iter; iter = iter->next) {
2622                 NMSettingsConnection *master_connection = NULL;
2623                 NMDevice *master_device = NULL;
2624                 NMConnection *candidate = iter->data;
2625
2626                 find_master (manager, candidate, NULL, &master_connection, &master_device, NULL, NULL);
2627                 if (   (master_connection && master_connection == connection)
2628                     || (master_device && master_device == device)) {
2629                         slaves = g_slist_prepend (slaves, candidate);
2630                 }
2631         }
2632         g_slist_free (all_connections);
2633
2634         return g_slist_reverse (slaves);
2635 }
2636
2637 static gboolean
2638 should_connect_slaves (NMConnection *connection, NMDevice *device)
2639 {
2640         NMSettingConnection *s_con;
2641         NMSettingConnectionAutoconnectSlaves autoconnect_slaves;
2642         gs_free char *value = NULL;
2643
2644         s_con = nm_connection_get_setting_connection (connection);
2645         g_assert (s_con);
2646
2647         /* Check autoconnect-slaves property */
2648         autoconnect_slaves = nm_setting_connection_get_autoconnect_slaves (s_con);
2649         if (autoconnect_slaves != NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT)
2650                 goto out;
2651
2652         /* Check configuration default for autoconnect-slaves property */
2653         value = nm_config_data_get_connection_default (NM_CONFIG_GET_DATA,
2654                                                        "connection.autoconnect-slaves", device);
2655         if (value)
2656                 autoconnect_slaves = _nm_utils_ascii_str_to_int64 (value, 10, 0, 1, -1);
2657
2658 out:
2659         if (autoconnect_slaves == NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_NO)
2660                 return FALSE;
2661         if (autoconnect_slaves == NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_YES)
2662                 return TRUE;
2663         return FALSE;
2664 }
2665
2666 static gboolean
2667 autoconnect_slaves (NMManager *self,
2668                     NMSettingsConnection *master_connection,
2669                     NMDevice *master_device,
2670                     NMAuthSubject *subject)
2671 {
2672         GError *local_err = NULL;
2673         gboolean ret = FALSE;
2674
2675         if (should_connect_slaves (NM_CONNECTION (master_connection), master_device)) {
2676                 GSList *slaves, *iter;
2677
2678                 iter = slaves = find_slaves (self, master_connection, master_device);
2679                 ret = slaves != NULL;
2680
2681                 while (iter) {
2682                         NMSettingsConnection *slave_connection = iter->data;
2683
2684                         iter = iter->next;
2685                         _LOGD (LOGD_CORE, "will activate slave connection '%s' (%s) as a dependency for master '%s' (%s)",
2686                                nm_settings_connection_get_id (slave_connection),
2687                                nm_settings_connection_get_uuid (slave_connection),
2688                                nm_settings_connection_get_id (master_connection),
2689                                nm_settings_connection_get_uuid (master_connection));
2690
2691                         /* Schedule slave activation */
2692                         nm_manager_activate_connection (self,
2693                                                         slave_connection,
2694                                                         NULL,
2695                                                         nm_manager_get_best_device_for_connection (self, NM_CONNECTION (slave_connection), FALSE),
2696                                                         subject,
2697                                                         &local_err);
2698                         if (local_err) {
2699                                 _LOGW (LOGD_CORE, "Slave connection activation failed: %s", local_err->message);
2700                                 g_error_free (local_err);
2701                         }
2702                 }
2703                 g_slist_free (slaves);
2704         }
2705         return ret;
2706 }
2707
2708 static gboolean
2709 _internal_activate_vpn (NMManager *self, NMActiveConnection *active, GError **error)
2710 {
2711         gboolean success;
2712
2713         g_assert (NM_IS_VPN_CONNECTION (active));
2714
2715         nm_exported_object_export (NM_EXPORTED_OBJECT (active));
2716         success = nm_vpn_manager_activate_connection (NM_MANAGER_GET_PRIVATE (self)->vpn_manager,
2717                                                       NM_VPN_CONNECTION (active),
2718                                                       error);
2719         if (success)
2720                 g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVE_CONNECTIONS);
2721         else
2722                 nm_exported_object_unexport (NM_EXPORTED_OBJECT (active));
2723         return success;
2724 }
2725
2726 static gboolean
2727 _internal_activate_device (NMManager *self, NMActiveConnection *active, GError **error)
2728 {
2729         NMDevice *device, *existing, *master_device = NULL;
2730         NMConnection *applied;
2731         NMSettingsConnection *connection;
2732         NMSettingsConnection *master_connection = NULL;
2733         NMConnection *existing_connection = NULL;
2734         NMActiveConnection *master_ac = NULL;
2735         NMAuthSubject *subject;
2736         char *error_desc = NULL;
2737
2738         g_return_val_if_fail (NM_IS_MANAGER (self), FALSE);
2739         g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (active), FALSE);
2740         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
2741
2742         g_assert (NM_IS_VPN_CONNECTION (active) == FALSE);
2743
2744         connection = nm_active_connection_get_settings_connection (active);
2745         g_assert (connection);
2746
2747         applied = nm_active_connection_get_applied_connection (active);
2748
2749         device = nm_active_connection_get_device (active);
2750         g_return_val_if_fail (device != NULL, FALSE);
2751
2752         /* If the device is active and its connection is not visible to the
2753          * user that's requesting this new activation, fail, since other users
2754          * should not be allowed to implicitly deactivate private connections
2755          * by activating a connection of their own.
2756          */
2757         existing_connection = nm_device_get_applied_connection (device);
2758         subject = nm_active_connection_get_subject (active);
2759         if (existing_connection &&
2760             !nm_auth_is_subject_in_acl (existing_connection,
2761                                         subject,
2762                                         &error_desc)) {
2763                 g_set_error (error,
2764                              NM_MANAGER_ERROR,
2765                              NM_MANAGER_ERROR_PERMISSION_DENIED,
2766                              "Private connection already active on the device: %s",
2767                              error_desc);
2768                 g_free (error_desc);
2769                 return FALSE;
2770         }
2771
2772         /* Final connection must be available on device */
2773         if (!nm_device_check_connection_available (device, applied, NM_DEVICE_CHECK_CON_AVAILABLE_FOR_USER_REQUEST, NULL)) {
2774                 g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_CONNECTION,
2775                              "Connection '%s' is not available on the device %s at this time.",
2776                              nm_settings_connection_get_id (connection), nm_device_get_iface (device));
2777                 return FALSE;
2778         }
2779
2780         /* Create any backing resources the device needs */
2781         if (!nm_device_is_real (device)) {
2782                 NMDevice *parent;
2783
2784                 parent = find_parent_device_for_connection (self, (NMConnection *) connection, NULL);
2785                 if (!nm_device_create_and_realize (device, (NMConnection *) connection, parent, error)) {
2786                         g_prefix_error (error, "%s failed to create resources: ", nm_device_get_iface (device));
2787                         return FALSE;
2788                 }
2789         }
2790
2791         /* Try to find the master connection/device if the connection has a dependency */
2792         if (!find_master (self, applied, device,
2793                           &master_connection, &master_device, &master_ac,
2794                           error))
2795                 return FALSE;
2796
2797         /* Ensure there's a master active connection the new connection we're
2798          * activating can depend on.
2799          */
2800         if (master_connection || master_device) {
2801                 if (master_connection) {
2802                         _LOGD (LOGD_CORE, "Activation of '%s' requires master connection '%s'",
2803                                nm_settings_connection_get_id (connection),
2804                                nm_settings_connection_get_id (master_connection));
2805                 }
2806                 if (master_device) {
2807                         _LOGD (LOGD_CORE, "Activation of '%s' requires master device '%s'",
2808                                nm_settings_connection_get_id (connection),
2809                                nm_device_get_ip_iface (master_device));
2810                 }
2811
2812                 /* Ensure eg bond slave and the candidate master is a bond master */
2813                 if (master_connection && !is_compatible_with_slave (NM_CONNECTION (master_connection), applied)) {
2814                         g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2815                                              "The master connection was not compatible");
2816                         return FALSE;
2817                 }
2818
2819                 if (!master_ac) {
2820                         master_ac = ensure_master_active_connection (self,
2821                                                                      nm_active_connection_get_subject (active),
2822                                                                      applied,
2823                                                                      device,
2824                                                                      master_connection,
2825                                                                      master_device,
2826                                                                      error);
2827                         if (!master_ac) {
2828                                 if (error)
2829                                         g_assert (*error);
2830                                 return FALSE;
2831                         }
2832                 }
2833
2834                 nm_active_connection_set_master (active, master_ac);
2835                 _LOGD (LOGD_CORE, "Activation of '%s' depends on active connection %p %s",
2836                        nm_settings_connection_get_id (connection),
2837                        master_ac,
2838                        nm_exported_object_get_path (NM_EXPORTED_OBJECT  (master_ac)) ?: "");
2839         }
2840
2841         /* Check slaves for master connection and possibly activate them */
2842         autoconnect_slaves (self, connection, device, nm_active_connection_get_subject (active));
2843
2844         /* Disconnect the connection if connected or queued on another device */
2845         existing = nm_manager_get_connection_device (self, NM_CONNECTION (connection));
2846         if (existing)
2847                 nm_device_steal_connection (existing, connection);
2848
2849         /* when creating the software device, it can happen that the device is
2850          * still unmanaged by NM_UNMANAGED_PLATFORM_INIT because we didn't yet
2851          * get the udev event. At this point, we can no longer delay the activation
2852          * and force the device to be managed. */
2853         nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_PLATFORM_INIT, FALSE, NM_DEVICE_STATE_REASON_USER_REQUESTED);
2854
2855         nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_USER_EXPLICIT, FALSE, NM_DEVICE_STATE_REASON_USER_REQUESTED);
2856
2857         g_return_val_if_fail (nm_device_get_managed (device, FALSE), FALSE);
2858
2859         if (nm_device_get_state (device) == NM_DEVICE_STATE_UNMANAGED) {
2860                 nm_device_state_changed (device,
2861                                          NM_DEVICE_STATE_UNAVAILABLE,
2862                                          NM_DEVICE_STATE_REASON_USER_REQUESTED);
2863         }
2864
2865         if (   nm_device_is_available (device, NM_DEVICE_CHECK_DEV_AVAILABLE_FOR_USER_REQUEST)
2866             && (nm_device_get_state (device) == NM_DEVICE_STATE_UNAVAILABLE)) {
2867                 nm_device_state_changed (device,
2868                                          NM_DEVICE_STATE_DISCONNECTED,
2869                                          NM_DEVICE_STATE_REASON_USER_REQUESTED);
2870         }
2871
2872         /* Export the new ActiveConnection to clients and start it on the device */
2873         nm_exported_object_export (NM_EXPORTED_OBJECT (active));
2874         g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVE_CONNECTIONS);
2875         nm_device_queue_activation (device, NM_ACT_REQUEST (active));
2876         return TRUE;
2877 }
2878
2879 static gboolean
2880 _internal_activate_generic (NMManager *self, NMActiveConnection *active, GError **error)
2881 {
2882         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
2883         gboolean success = FALSE;
2884
2885         /* Ensure activation request is still valid, eg that its device hasn't gone
2886          * away or that some other dependency has not failed.
2887          */
2888         if (nm_active_connection_get_state (active) >= NM_ACTIVE_CONNECTION_STATE_DEACTIVATING) {
2889                 g_set_error_literal (error,
2890                                      NM_MANAGER_ERROR,
2891                                      NM_MANAGER_ERROR_DEPENDENCY_FAILED,
2892                                      "Activation failed because dependencies failed.");
2893                 return FALSE;
2894         }
2895
2896         if (NM_IS_VPN_CONNECTION (active))
2897                 success = _internal_activate_vpn (self, active, error);
2898         else
2899                 success = _internal_activate_device (self, active, error);
2900
2901         if (success) {
2902                 /* Force an update of the Manager's activating-connection property.
2903                  * The device changes state before the AC gets exported, which causes
2904                  * the manager's 'activating-connection' property to be NULL since the
2905                  * AC only gets a D-Bus path when it's exported.  So now that the AC
2906                  * is exported, make sure the manager's activating-connection property
2907                  * is up-to-date.
2908                  */
2909                 active_connection_add (self, active);
2910                 policy_activating_device_changed (G_OBJECT (priv->policy), NULL, self);
2911         }
2912
2913         return success;
2914 }
2915
2916 static NMActiveConnection *
2917 _new_vpn_active_connection (NMManager *self,
2918                             NMSettingsConnection *settings_connection,
2919                             const char *specific_object,
2920                             NMAuthSubject *subject,
2921                             GError **error)
2922 {
2923         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
2924         NMActiveConnection *parent = NULL;
2925         NMDevice *device = NULL;
2926
2927         g_return_val_if_fail (!settings_connection || NM_IS_SETTINGS_CONNECTION (settings_connection), NULL);
2928
2929         if (specific_object) {
2930                 /* Find the specific connection the client requested we use */
2931                 parent = active_connection_get_by_path (self, specific_object);
2932                 if (!parent) {
2933                         g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE,
2934                                              "Base connection for VPN connection not active.");
2935                         return NULL;
2936                 }
2937         } else
2938                 parent = priv->primary_connection;
2939
2940         if (!parent) {
2941                 g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_CONNECTION,
2942                                      "Could not find source connection.");
2943                 return NULL;
2944         }
2945
2946         device = nm_active_connection_get_device (parent);
2947         if (!device) {
2948                 g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_DEVICE,
2949                                      "Source connection had no active device.");
2950                 return NULL;
2951         }
2952
2953         return (NMActiveConnection *) nm_vpn_connection_new (settings_connection,
2954                                                              device,
2955                                                              nm_exported_object_get_path (NM_EXPORTED_OBJECT (parent)),
2956                                                              subject);
2957 }
2958
2959 static NMActiveConnection *
2960 _new_active_connection (NMManager *self,
2961                         NMConnection *connection,
2962                         const char *specific_object,
2963                         NMDevice *device,
2964                         NMAuthSubject *subject,
2965                         GError **error)
2966 {
2967         NMSettingsConnection *settings_connection = NULL;
2968         NMActiveConnection *existing_ac;
2969         gboolean is_vpn;
2970
2971         g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
2972         g_return_val_if_fail (NM_IS_AUTH_SUBJECT (subject), NULL);
2973
2974         /* Can't create new AC for already-active connection */
2975         existing_ac = find_ac_for_connection (self, connection);
2976         if (NM_IS_VPN_CONNECTION (existing_ac)) {
2977                 g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_CONNECTION_ALREADY_ACTIVE,
2978                              "Connection '%s' is already active",
2979                              nm_connection_get_id (connection));
2980                 return NULL;
2981         }
2982
2983         /* Normalize the specific object */
2984         if (specific_object && g_strcmp0 (specific_object, "/") == 0)
2985                 specific_object = NULL;
2986
2987         is_vpn = nm_connection_is_type (NM_CONNECTION (connection), NM_SETTING_VPN_SETTING_NAME);
2988
2989         if (NM_IS_SETTINGS_CONNECTION (connection))
2990                 settings_connection = (NMSettingsConnection *) connection;
2991
2992         if (is_vpn) {
2993                 return _new_vpn_active_connection (self,
2994                                                    settings_connection,
2995                                                    specific_object,
2996                                                    subject,
2997                                                    error);
2998         }
2999
3000         return (NMActiveConnection *) nm_act_request_new (settings_connection,
3001                                                           specific_object,
3002                                                           subject,
3003                                                           device);
3004 }
3005
3006 static void
3007 _internal_activation_failed (NMManager *self,
3008                              NMActiveConnection *active,
3009                              const char *error_desc)
3010 {
3011         _LOGD (LOGD_CORE, "Failed to activate '%s': %s",
3012                nm_active_connection_get_settings_connection_id (active),
3013                error_desc);
3014
3015         if (nm_active_connection_get_state (active) <= NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
3016                 nm_active_connection_set_state (active, NM_ACTIVE_CONNECTION_STATE_DEACTIVATING);
3017                 nm_active_connection_set_state (active, NM_ACTIVE_CONNECTION_STATE_DEACTIVATED);
3018         }
3019 }
3020
3021 static void
3022 _internal_activation_auth_done (NMActiveConnection *active,
3023                                 gboolean success,
3024                                 const char *error_desc,
3025                                 gpointer user_data1,
3026                                 gpointer user_data2)
3027 {
3028         NMManager *self = user_data1;
3029         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3030         GError *error = NULL;
3031
3032         priv->authorizing_connections = g_slist_remove (priv->authorizing_connections, active);
3033
3034         if (success) {
3035                 if (_internal_activate_generic (self, active, &error)) {
3036                         g_object_unref (active);
3037                         return;
3038                 }
3039         }
3040
3041         g_assert (error_desc || error);
3042         _internal_activation_failed (self, active, error_desc ? error_desc : error->message);
3043         g_object_unref (active);
3044         g_clear_error (&error);
3045 }
3046
3047 /**
3048  * nm_manager_activate_connection():
3049  * @self: the #NMManager
3050  * @connection: the #NMSettingsConnection to activate on @device
3051  * @specific_object: the specific object path, if any, for the activation
3052  * @device: the #NMDevice to activate @connection on
3053  * @subject: the subject which requested activation
3054  * @error: return location for an error
3055  *
3056  * Begins a new internally-initiated activation of @connection on @device.
3057  * @subject should be the subject of the activation that triggered this
3058  * one, or if this is an autoconnect request, a new internal subject.
3059  * The returned #NMActiveConnection is owned by the Manager and should be
3060  * referenced by the caller if the caller continues to use it.
3061  *
3062  * Returns: (transfer none): the new #NMActiveConnection that tracks
3063  * activation of @connection on @device
3064  */
3065 NMActiveConnection *
3066 nm_manager_activate_connection (NMManager *self,
3067                                 NMSettingsConnection *connection,
3068                                 const char *specific_object,
3069                                 NMDevice *device,
3070                                 NMAuthSubject *subject,
3071                                 GError **error)
3072 {
3073         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3074         NMActiveConnection *active;
3075         char *error_desc = NULL;
3076         GSList *iter;
3077
3078         g_return_val_if_fail (self != NULL, NULL);
3079         g_return_val_if_fail (connection != NULL, NULL);
3080         g_return_val_if_fail (error != NULL, NULL);
3081         g_return_val_if_fail (*error == NULL, NULL);
3082
3083         /* Ensure the subject has permissions for this connection */
3084         if (!nm_auth_is_subject_in_acl (NM_CONNECTION (connection),
3085                                         subject,
3086                                         &error_desc)) {
3087                 g_set_error_literal (error,
3088                                      NM_MANAGER_ERROR,
3089                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
3090                                      error_desc);
3091                 g_free (error_desc);
3092                 return NULL;
3093         }
3094
3095         /* Look for a active connection that's equivalent and is already pending authorization
3096          * and eventual activation. This is used to de-duplicate concurrent activations which would
3097          * otherwise race and cause the device to disconnect and reconnect repeatedly.
3098          * In particular, this allows the master and multiple slaves to concurrently auto-activate
3099          * while all the slaves would use the same active-connection. */
3100         for (iter = priv->authorizing_connections; iter; iter = g_slist_next (iter)) {
3101                 active = iter->data;
3102
3103                 if (   connection == nm_active_connection_get_settings_connection (active)
3104                     && g_strcmp0 (nm_active_connection_get_specific_object (active), specific_object) == 0
3105                     && nm_active_connection_get_device (active) == device
3106                     && nm_auth_subject_is_internal (nm_active_connection_get_subject (active))
3107                     && nm_auth_subject_is_internal (subject))
3108                         return active;
3109         }
3110
3111         active = _new_active_connection (self,
3112                                          NM_CONNECTION (connection),
3113                                          specific_object,
3114                                          device,
3115                                          subject,
3116                                          error);
3117         if (active) {
3118                 priv->authorizing_connections = g_slist_prepend (priv->authorizing_connections, active);
3119                 nm_active_connection_authorize (active, NULL, _internal_activation_auth_done, self, NULL);
3120         }
3121         return active;
3122 }
3123
3124 /**
3125  * validate_activation_request:
3126  * @self: the #NMManager
3127  * @context: the D-Bus context of the requestor
3128  * @connection: the partial or complete #NMConnection to be activated
3129  * @device_path: the object path of the device to be activated, or "/"
3130  * @out_device: on successful reutrn, the #NMDevice to be activated with @connection
3131  * @out_vpn: on successful return, %TRUE if @connection is a VPN connection
3132  * @error: location to store an error on failure
3133  *
3134  * Performs basic validation on an activation request, including ensuring that
3135  * the requestor is a valid Unix process, is not disallowed in @connection
3136  * permissions, and that a device exists that can activate @connection.
3137  *
3138  * Returns: on success, the #NMAuthSubject representing the requestor, or
3139  *   %NULL on error
3140  */
3141 static NMAuthSubject *
3142 validate_activation_request (NMManager *self,
3143                              GDBusMethodInvocation *context,
3144                              NMConnection *connection,
3145                              const char *device_path,
3146                              NMDevice **out_device,
3147                              gboolean *out_vpn,
3148                              GError **error)
3149 {
3150         NMDevice *device = NULL;
3151         gboolean vpn = FALSE;
3152         NMAuthSubject *subject = NULL;
3153         char *error_desc = NULL;
3154
3155         g_assert (connection);
3156         g_assert (out_device);
3157         g_assert (out_vpn);
3158
3159         /* Validate the caller */
3160         subject = nm_auth_subject_new_unix_process_from_context (context);
3161         if (!subject) {
3162                 g_set_error_literal (error,
3163                                      NM_MANAGER_ERROR,
3164                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
3165                                      "Failed to get request UID.");
3166                 return NULL;
3167         }
3168
3169         /* Ensure the subject has permissions for this connection */
3170         if (!nm_auth_is_subject_in_acl (connection,
3171                                         subject,
3172                                         &error_desc)) {
3173                 g_set_error_literal (error,
3174                                      NM_MANAGER_ERROR,
3175                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
3176                                      error_desc);
3177                 g_free (error_desc);
3178                 goto error;
3179         }
3180
3181         /* Not implemented yet, we want to fail early */
3182         if (   nm_connection_get_setting_connection (connection)
3183             && nm_connection_get_setting_ip6_config (connection)
3184             && !strcmp (nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP6_CONFIG),
3185                         NM_SETTING_IP6_CONFIG_METHOD_SHARED)) {
3186                 g_set_error_literal (error,
3187                                      NM_MANAGER_ERROR,
3188                                      NM_MANAGER_ERROR_CONNECTION_NOT_AVAILABLE,
3189                                      "Sharing IPv6 connections is not supported yet.");
3190                 return NULL;
3191         }
3192
3193         /* Check whether it's a VPN or not */
3194         if (   nm_connection_get_setting_vpn (connection)
3195             || nm_connection_is_type (connection, NM_SETTING_VPN_SETTING_NAME))
3196                 vpn = TRUE;
3197
3198         /* Normalize device path */
3199         if (device_path && g_strcmp0 (device_path, "/") == 0)
3200                 device_path = NULL;
3201
3202         /* And validate it */
3203         if (device_path) {
3204                 device = nm_manager_get_device_by_path (self, device_path);
3205                 if (!device) {
3206                         g_set_error_literal (error,
3207                                              NM_MANAGER_ERROR,
3208                                              NM_MANAGER_ERROR_UNKNOWN_DEVICE,
3209                                              "Device not found");
3210                         goto error;
3211                 }
3212         } else
3213                 device = nm_manager_get_best_device_for_connection (self, connection, TRUE);
3214
3215         if (!device && !vpn) {
3216                 gboolean is_software = nm_connection_is_virtual (connection);
3217
3218                 /* VPN and software-device connections don't need a device yet */
3219                 if (!is_software) {
3220                         g_set_error_literal (error,
3221                                              NM_MANAGER_ERROR,
3222                                              NM_MANAGER_ERROR_UNKNOWN_DEVICE,
3223                                              "No suitable device found for this connection.");
3224                         goto error;
3225                 }
3226
3227                 if (is_software) {
3228                         char *iface;
3229
3230                         /* Look for an existing device with the connection's interface name */
3231                         iface = nm_manager_get_connection_iface (self, connection, NULL, error);
3232                         if (!iface)
3233                                 goto error;
3234
3235                         device = find_device_by_iface (self, iface, connection, NULL);
3236                         g_free (iface);
3237                 }
3238         }
3239
3240         if ((!vpn || device_path) && !device) {
3241                 g_set_error_literal (error,
3242                                      NM_MANAGER_ERROR,
3243                                      NM_MANAGER_ERROR_UNKNOWN_DEVICE,
3244                                      "Failed to find a compatible device for this connection");
3245                 goto error;
3246         }
3247
3248         *out_device = device;
3249         *out_vpn = vpn;
3250         return subject;
3251
3252 error:
3253         g_object_unref (subject);
3254         return NULL;
3255 }
3256
3257 /***********************************************************************/
3258
3259 static void
3260 _activation_auth_done (NMActiveConnection *active,
3261                        gboolean success,
3262                        const char *error_desc,
3263                        gpointer user_data1,
3264                        gpointer user_data2)
3265 {
3266         NMManager *self = user_data1;
3267         GDBusMethodInvocation *context = user_data2;
3268         GError *error = NULL;
3269         NMAuthSubject *subject;
3270         NMSettingsConnection *connection;
3271
3272         subject = nm_active_connection_get_subject (active);
3273         connection = nm_active_connection_get_settings_connection (active);
3274
3275         if (success) {
3276                 if (_internal_activate_generic (self, active, &error)) {
3277                         g_dbus_method_invocation_return_value (context,
3278                                                                g_variant_new ("(o)",
3279                                                                nm_exported_object_get_path (NM_EXPORTED_OBJECT (active))));
3280                         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ACTIVATE, connection, TRUE,
3281                                                     subject, NULL);
3282                         g_object_unref (active);
3283                         return;
3284                 }
3285         } else {
3286                 error = g_error_new_literal (NM_MANAGER_ERROR,
3287                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3288                                              error_desc);
3289         }
3290
3291         g_assert (error);
3292         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ACTIVATE, connection, FALSE,
3293                                     subject, error->message);
3294         _internal_activation_failed (self, active, error->message);
3295
3296         g_object_unref (active);
3297         g_dbus_method_invocation_take_error (context, error);
3298 }
3299
3300 static void
3301 impl_manager_activate_connection (NMManager *self,
3302                                   GDBusMethodInvocation *context,
3303                                   const char *connection_path,
3304                                   const char *device_path,
3305                                   const char *specific_object_path)
3306 {
3307         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3308         NMActiveConnection *active = NULL;
3309         NMAuthSubject *subject = NULL;
3310         NMSettingsConnection *connection = NULL;
3311         NMDevice *device = NULL;
3312         gboolean is_vpn = FALSE;
3313         GError *error = NULL;
3314
3315         /* Normalize object paths */
3316         if (g_strcmp0 (connection_path, "/") == 0)
3317                 connection_path = NULL;
3318         if (g_strcmp0 (specific_object_path, "/") == 0)
3319                 specific_object_path = NULL;
3320         if (g_strcmp0 (device_path, "/") == 0)
3321                 device_path = NULL;
3322
3323         /* If the connection path is given and valid, that connection is activated.
3324          * Otherwise the "best" connection for the device is chosen and activated,
3325          * regardless of whether that connection is autoconnect-enabled or not
3326          * (since this is an explicit request, not an auto-activation request).
3327          */
3328         if (connection_path) {
3329                 connection = nm_settings_get_connection_by_path (priv->settings, connection_path);
3330                 if (!connection) {
3331                         error = g_error_new_literal (NM_MANAGER_ERROR,
3332                                                      NM_MANAGER_ERROR_UNKNOWN_CONNECTION,
3333                                                      "Connection could not be found.");
3334                         goto error;
3335                 }
3336         } else {
3337                 /* If no connection is given, find a suitable connection for the given device path */
3338                 if (!device_path) {
3339                         error = g_error_new_literal (NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_DEVICE,
3340                                                      "Only devices may be activated without a specifying a connection");
3341                         goto error;
3342                 }
3343                 device = nm_manager_get_device_by_path (self, device_path);
3344                 if (!device) {
3345                         error = g_error_new (NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_DEVICE,
3346                                              "Cannot activate unknown device %s", device_path);
3347                         goto error;
3348                 }
3349
3350                 connection = nm_device_get_best_connection (device, specific_object_path, &error);
3351                 if (!connection)
3352                         goto error;
3353         }
3354
3355         subject = validate_activation_request (self,
3356                                                context,
3357                                                NM_CONNECTION (connection),
3358                                                device_path,
3359                                                &device,
3360                                                &is_vpn,
3361                                                &error);
3362         if (!subject)
3363                 goto error;
3364
3365         active = _new_active_connection (self,
3366                                          NM_CONNECTION (connection),
3367                                          specific_object_path,
3368                                          device,
3369                                          subject,
3370                                          &error);
3371         if (!active)
3372                 goto error;
3373
3374         nm_active_connection_authorize (active, NULL, _activation_auth_done, self, context);
3375         g_clear_object (&subject);
3376         return;
3377
3378 error:
3379         if (connection) {
3380                 nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ACTIVATE, connection, FALSE,
3381                                             subject, error->message);
3382         }
3383         g_clear_object (&active);
3384         g_clear_object (&subject);
3385
3386         g_assert (error);
3387         g_dbus_method_invocation_take_error (context, error);
3388 }
3389
3390 /***********************************************************************/
3391
3392 typedef struct {
3393         NMManager *manager;
3394         NMActiveConnection *active;
3395 } AddAndActivateInfo;
3396
3397 static void
3398 activation_add_done (NMSettings *settings,
3399                      NMSettingsConnection *new_connection,
3400                      GError *error,
3401                      GDBusMethodInvocation *context,
3402                      NMAuthSubject *subject,
3403                      gpointer user_data)
3404 {
3405         AddAndActivateInfo *info = user_data;
3406         NMManager *self;
3407         gs_unref_object NMActiveConnection *active = NULL;
3408         GError *local = NULL;
3409
3410         self = info->manager;
3411         active = info->active;
3412         g_slice_free (AddAndActivateInfo, info);
3413
3414         if (!error) {
3415                 nm_active_connection_set_settings_connection (active, new_connection);
3416
3417                 if (_internal_activate_generic (self, active, &local)) {
3418                         nm_settings_connection_commit_changes (new_connection,
3419                                                                NM_SETTINGS_CONNECTION_COMMIT_REASON_USER_ACTION | NM_SETTINGS_CONNECTION_COMMIT_REASON_ID_CHANGED,
3420                                                                NULL, NULL);
3421                         g_dbus_method_invocation_return_value (
3422                             context,
3423                             g_variant_new ("(oo)",
3424                                            nm_connection_get_path (NM_CONNECTION (new_connection)),
3425                                            nm_exported_object_get_path (NM_EXPORTED_OBJECT (active))));
3426                         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ADD_ACTIVATE,
3427                                                     nm_active_connection_get_settings_connection (active),
3428                                                     TRUE,
3429                                                     nm_active_connection_get_subject (active),
3430                                                     NULL);
3431                         return;
3432                 }
3433                 error = local;
3434         }
3435
3436         g_assert (error);
3437         _internal_activation_failed (self, active, error->message);
3438         nm_settings_connection_delete (new_connection, NULL, NULL);
3439         g_dbus_method_invocation_return_gerror (context, error);
3440         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ADD_ACTIVATE,
3441                                     NULL,
3442                                     FALSE,
3443                                     nm_active_connection_get_subject (active),
3444                                     error->message);
3445         g_clear_error (&local);
3446 }
3447
3448 static void
3449 _add_and_activate_auth_done (NMActiveConnection *active,
3450                              gboolean success,
3451                              const char *error_desc,
3452                              gpointer user_data1,
3453                              gpointer user_data2)
3454 {
3455         NMManager *self = user_data1;
3456         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3457         GDBusMethodInvocation *context = user_data2;
3458         AddAndActivateInfo *info;
3459         GError *error = NULL;
3460
3461         if (success) {
3462                 NMConnection *connection;
3463
3464                 connection = g_object_steal_data (G_OBJECT (active),
3465                                                   TAG_ACTIVE_CONNETION_ADD_AND_ACTIVATE);
3466
3467                 info = g_slice_new (AddAndActivateInfo);
3468                 info->manager = self;
3469                 info->active = g_object_ref (active);
3470
3471                 /* Basic sender auth checks performed; try to add the connection */
3472                 nm_settings_add_connection_dbus (priv->settings,
3473                                                  connection,
3474                                                  FALSE,
3475                                                  context,
3476                                                  activation_add_done,
3477                                                  info);
3478                 g_object_unref (connection);
3479         } else {
3480                 g_assert (error_desc);
3481                 error = g_error_new_literal (NM_MANAGER_ERROR,
3482                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3483                                              error_desc);
3484                 nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ADD_ACTIVATE,
3485                                             NULL,
3486                                             FALSE,
3487                                             nm_active_connection_get_subject (active),
3488                                             error->message);
3489                 g_dbus_method_invocation_take_error (context, error);
3490         }
3491
3492         g_object_unref (active);
3493 }
3494
3495 static void
3496 impl_manager_add_and_activate_connection (NMManager *self,
3497                                           GDBusMethodInvocation *context,
3498                                           GVariant *settings,
3499                                           const char *device_path,
3500                                           const char *specific_object_path)
3501 {
3502         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3503         NMConnection *connection = NULL;
3504         GSList *all_connections = NULL;
3505         NMActiveConnection *active = NULL;
3506         NMAuthSubject *subject = NULL;
3507         GError *error = NULL;
3508         NMDevice *device = NULL;
3509         gboolean vpn = FALSE;
3510
3511         /* Normalize object paths */
3512         if (g_strcmp0 (specific_object_path, "/") == 0)
3513                 specific_object_path = NULL;
3514         if (g_strcmp0 (device_path, "/") == 0)
3515                 device_path = NULL;
3516
3517         /* Try to create a new connection with the given settings.
3518          * We allow empty settings for AddAndActivateConnection(). In that case,
3519          * the connection will be completed in nm_utils_complete_generic() or
3520          * nm_device_complete_connection() below. Just make sure we don't expect
3521          * specific data being in the connection till then (especially in
3522          * validate_activation_request()).
3523          */
3524         connection = nm_simple_connection_new ();
3525         if (settings && g_variant_n_children (settings))
3526                 nm_connection_replace_settings (connection, settings, NULL);
3527
3528         subject = validate_activation_request (self,
3529                                                context,
3530                                                connection,
3531                                                device_path,
3532                                                &device,
3533                                                &vpn,
3534                                                &error);
3535         if (!subject)
3536                 goto error;
3537
3538         all_connections = nm_settings_get_connections (priv->settings);
3539         if (vpn) {
3540                 /* Try to fill the VPN's connection setting and name at least */
3541                 if (!nm_connection_get_setting_vpn (connection)) {
3542                         error = g_error_new_literal (NM_CONNECTION_ERROR,
3543                                                      NM_CONNECTION_ERROR_MISSING_SETTING,
3544                                                      "VPN connections require a 'vpn' setting");
3545                         g_prefix_error (&error, "%s: ", NM_SETTING_VPN_SETTING_NAME);
3546                         goto error;
3547                 }
3548
3549                 nm_utils_complete_generic (NM_PLATFORM_GET,
3550                                            connection,
3551                                            NM_SETTING_VPN_SETTING_NAME,
3552                                            all_connections,
3553                                            NULL,
3554                                            _("VPN connection"),
3555                                            NULL,
3556                                            FALSE); /* No IPv6 by default for now */
3557         } else {
3558                 /* Let each device subclass complete the connection */
3559                 if (!nm_device_complete_connection (device,
3560                                                     connection,
3561                                                     specific_object_path,
3562                                                     all_connections,
3563                                                     &error))
3564                         goto error;
3565         }
3566         g_slist_free (all_connections);
3567         all_connections = NULL;
3568
3569         active = _new_active_connection (self,
3570                                          connection,
3571                                          specific_object_path,
3572                                          device,
3573                                          subject,
3574                                          &error);
3575         if (!active)
3576                 goto error;
3577
3578         g_object_set_data_full (G_OBJECT (active),
3579                                 TAG_ACTIVE_CONNETION_ADD_AND_ACTIVATE,
3580                                 connection,
3581                                 g_object_unref);
3582
3583         nm_active_connection_authorize (active, connection, _add_and_activate_auth_done, self, context);
3584         g_object_unref (subject);
3585         return;
3586
3587 error:
3588         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_ADD_ACTIVATE, NULL, FALSE, subject, error->message);
3589         g_clear_object (&connection);
3590         g_slist_free (all_connections);
3591         g_clear_object (&subject);
3592         g_clear_object (&active);
3593
3594         g_assert (error);
3595         g_dbus_method_invocation_take_error (context, error);
3596 }
3597
3598 /***********************************************************************/
3599
3600 gboolean
3601 nm_manager_deactivate_connection (NMManager *manager,
3602                                   const char *connection_path,
3603                                   NMDeviceStateReason reason,
3604                                   GError **error)
3605 {
3606         NMActiveConnection *active;
3607         gboolean success = FALSE;
3608
3609         active = active_connection_get_by_path (manager, connection_path);
3610         if (!active) {
3611                 g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE,
3612                                      "The connection was not active.");
3613                 return FALSE;
3614         }
3615
3616         if (NM_IS_VPN_CONNECTION (active)) {
3617                 NMVpnConnectionStateReason vpn_reason = NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED;
3618
3619                 if (reason == NM_DEVICE_STATE_REASON_CONNECTION_REMOVED)
3620                         vpn_reason = NM_VPN_CONNECTION_STATE_REASON_CONNECTION_REMOVED;
3621                 if (nm_vpn_connection_deactivate (NM_VPN_CONNECTION (active), vpn_reason, FALSE))
3622                         success = TRUE;
3623                 else
3624                         g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE,
3625                                              "The VPN connection was not active.");
3626         } else {
3627                 g_assert (NM_IS_ACT_REQUEST (active));
3628                 nm_device_state_changed (nm_active_connection_get_device (active),
3629                                          NM_DEVICE_STATE_DEACTIVATING,
3630                                          reason);
3631                 success = TRUE;
3632         }
3633
3634         if (success)
3635                 g_object_notify (G_OBJECT (manager), NM_MANAGER_ACTIVE_CONNECTIONS);
3636
3637         return success;
3638 }
3639
3640 static void
3641 deactivate_net_auth_done_cb (NMAuthChain *chain,
3642                              GError *auth_error,
3643                              GDBusMethodInvocation *context,
3644                              gpointer user_data)
3645 {
3646         NMManager *self = NM_MANAGER (user_data);
3647         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3648         GError *error = NULL;
3649         NMAuthCallResult result;
3650         NMActiveConnection *active;
3651         char *path;
3652
3653         g_assert (context);
3654
3655         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
3656
3657         path = nm_auth_chain_get_data (chain, "path");
3658         result = nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_NETWORK_CONTROL);
3659
3660         if (auth_error) {
3661                 _LOGD (LOGD_CORE, "Disconnect request failed: %s", auth_error->message);
3662                 error = g_error_new (NM_MANAGER_ERROR,
3663                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
3664                                      "Deactivate request failed: %s",
3665                                      auth_error->message);
3666         } else if (result != NM_AUTH_CALL_RESULT_YES) {
3667                 error = g_error_new_literal (NM_MANAGER_ERROR,
3668                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3669                                              "Not authorized to deactivate connections");
3670         } else {
3671                 /* success; deactivation allowed */
3672                 if (!nm_manager_deactivate_connection (self,
3673                                                        path,
3674                                                        NM_DEVICE_STATE_REASON_USER_REQUESTED,
3675                                                        &error))
3676                         nm_assert (error);
3677         }
3678
3679         active = active_connection_get_by_path (self, path);
3680         if (active) {
3681                 nm_audit_log_connection_op (NM_AUDIT_OP_CONN_DEACTIVATE,
3682                                             nm_active_connection_get_settings_connection (active),
3683                                             !error,
3684                                             nm_auth_chain_get_subject (chain),
3685                                             error ? error->message : NULL);
3686         }
3687
3688         if (error)
3689                 g_dbus_method_invocation_take_error (context, error);
3690         else
3691                 g_dbus_method_invocation_return_value (context, NULL);
3692
3693         nm_auth_chain_unref (chain);
3694 }
3695
3696 static void
3697 impl_manager_deactivate_connection (NMManager *self,
3698                                     GDBusMethodInvocation *context,
3699                                     const char *active_path)
3700 {
3701         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3702         NMActiveConnection *ac;
3703         NMSettingsConnection *connection = NULL;
3704         GError *error = NULL;
3705         NMAuthSubject *subject = NULL;
3706         NMAuthChain *chain;
3707         char *error_desc = NULL;
3708
3709         /* Find the connection by its object path */
3710         ac = active_connection_get_by_path (self, active_path);
3711         if (ac)
3712                 connection = nm_active_connection_get_settings_connection (ac);
3713
3714         if (!connection) {
3715                 error = g_error_new_literal (NM_MANAGER_ERROR,
3716                                              NM_MANAGER_ERROR_CONNECTION_NOT_ACTIVE,
3717                                              "The connection was not active.");
3718                 goto done;
3719         }
3720
3721         /* Validate the caller */
3722         subject = nm_auth_subject_new_unix_process_from_context (context);
3723         if (!subject) {
3724                 error = g_error_new_literal (NM_MANAGER_ERROR,
3725                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3726                                              "Failed to get request UID.");
3727                 goto done;
3728         }
3729
3730         /* Ensure the subject has permissions for this connection */
3731         if (!nm_auth_is_subject_in_acl (NM_CONNECTION (connection),
3732                                         subject,
3733                                         &error_desc)) {
3734                 error = g_error_new_literal (NM_MANAGER_ERROR,
3735                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3736                                              error_desc);
3737                 g_free (error_desc);
3738                 goto done;
3739         }
3740
3741         /* Validate the user request */
3742         chain = nm_auth_chain_new_subject (subject, context, deactivate_net_auth_done_cb, self);
3743         if (!chain) {
3744                 error = g_error_new_literal (NM_MANAGER_ERROR,
3745                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3746                                              "Unable to authenticate request.");
3747                 goto done;
3748         }
3749
3750         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
3751         nm_auth_chain_set_data (chain, "path", g_strdup (active_path), g_free);
3752         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_NETWORK_CONTROL, TRUE);
3753
3754 done:
3755         if (error) {
3756                 if (connection) {
3757                         nm_audit_log_connection_op (NM_AUDIT_OP_CONN_DEACTIVATE, connection, FALSE,
3758                                                     subject, error->message);
3759                 }
3760                 g_dbus_method_invocation_take_error (context, error);
3761         }
3762         g_clear_object (&subject);
3763 }
3764
3765 static gboolean
3766 device_is_wake_on_lan (NMDevice *device)
3767 {
3768         return nm_platform_link_get_wake_on_lan (NM_PLATFORM_GET, nm_device_get_ip_ifindex (device));
3769 }
3770
3771 static void
3772 do_sleep_wake (NMManager *self, gboolean sleeping_changed)
3773 {
3774         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3775         gboolean suspending, waking_from_suspend;
3776         GSList *iter;
3777
3778         suspending = sleeping_changed && priv->sleeping;
3779         waking_from_suspend = sleeping_changed && !priv->sleeping;
3780
3781         if (manager_sleeping (self)) {
3782                 _LOGI (LOGD_SUSPEND, "%s...", suspending ? "sleeping" : "disabling");
3783
3784                 /* FIXME: are there still hardware devices that need to be disabled around
3785                  * suspend/resume?
3786                  */
3787                 for (iter = priv->devices; iter; iter = iter->next) {
3788                         NMDevice *device = iter->data;
3789
3790                         /* FIXME: shouldn't we be unmanaging software devices if !suspending? */
3791                         if (nm_device_is_software (device))
3792                                 continue;
3793                         /* Wake-on-LAN devices will be taken down post-suspend rather than pre- */
3794                         if (suspending && device_is_wake_on_lan (device))
3795                                 continue;
3796
3797                         nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_SLEEPING, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
3798                 }
3799         } else {
3800                 _LOGI (LOGD_SUSPEND, "%s...", waking_from_suspend ? "waking up" : "re-enabling");
3801
3802                 if (waking_from_suspend) {
3803                         /* Belatedly take down Wake-on-LAN devices; ideally we wouldn't have to do this
3804                          * but for now it's the only way to make sure we re-check their connectivity.
3805                          */
3806                         for (iter = priv->devices; iter; iter = iter->next) {
3807                                 NMDevice *device = iter->data;
3808
3809                                 if (nm_device_is_software (device))
3810                                         continue;
3811                                 if (device_is_wake_on_lan (device))
3812                                         nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_SLEEPING, TRUE, NM_DEVICE_STATE_REASON_SLEEPING);
3813                         }
3814                 }
3815
3816                 /* Ensure rfkill state is up-to-date since we don't respond to state
3817                  * changes during sleep.
3818                  */
3819                 nm_manager_rfkill_update (self, RFKILL_TYPE_UNKNOWN);
3820
3821                 /* Re-manage managed devices */
3822                 for (iter = priv->devices; iter; iter = iter->next) {
3823                         NMDevice *device = NM_DEVICE (iter->data);
3824                         guint i;
3825
3826                         if (nm_device_is_software (device))
3827                                 continue;
3828
3829                         /* enable/disable wireless devices since that we don't respond
3830                          * to killswitch changes during sleep.
3831                          */
3832                         for (i = 0; i < RFKILL_TYPE_MAX; i++) {
3833                                 RadioState *rstate = &priv->radio_states[i];
3834                                 gboolean enabled = radio_enabled_for_rstate (rstate, TRUE);
3835
3836                                 if (rstate->desc) {
3837                                         _LOGD (LOGD_RFKILL, "%s %s devices (hw_enabled %d, sw_enabled %d, user_enabled %d)",
3838                                                enabled ? "enabling" : "disabling",
3839                                                rstate->desc, rstate->hw_enabled, rstate->sw_enabled, rstate->user_enabled);
3840                                 }
3841
3842                                 if (nm_device_get_rfkill_type (device) == rstate->rtype)
3843                                         nm_device_set_enabled (device, enabled);
3844                         }
3845
3846                         nm_device_set_autoconnect (device, TRUE);
3847
3848                         nm_device_set_unmanaged_by_flags (device, NM_UNMANAGED_SLEEPING, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED);
3849                 }
3850         }
3851
3852         nm_manager_update_state (self);
3853 }
3854
3855 static void
3856 _internal_sleep (NMManager *self, gboolean do_sleep)
3857 {
3858         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3859
3860         if (priv->sleeping == do_sleep)
3861                 return;
3862
3863         _LOGI (LOGD_SUSPEND, "%s requested (sleeping: %s  enabled: %s)",
3864                do_sleep ? "sleep" : "wake",
3865                priv->sleeping ? "yes" : "no",
3866                priv->net_enabled ? "yes" : "no");
3867
3868         priv->sleeping = do_sleep;
3869
3870         do_sleep_wake (self, TRUE);
3871
3872         g_object_notify (G_OBJECT (self), NM_MANAGER_SLEEPING);
3873 }
3874
3875 #if 0
3876 static void
3877 sleep_auth_done_cb (NMAuthChain *chain,
3878                     GError *error,
3879                     GDBusMethodInvocation *context,
3880                     gpointer user_data)
3881 {
3882         NMManager *self = NM_MANAGER (user_data);
3883         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3884         GError *ret_error;
3885         NMAuthCallResult result;
3886         gboolean do_sleep;
3887
3888         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
3889
3890         result = nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_SLEEP_WAKE);
3891         if (error) {
3892                 _LOGD (LOGD_SUSPEND, "Sleep/wake request failed: %s", error->message);
3893                 ret_error = g_error_new (NM_MANAGER_ERROR,
3894                                          NM_MANAGER_ERROR_PERMISSION_DENIED,
3895                                          "Sleep/wake request failed: %s",
3896                                          error->message);
3897                 g_dbus_method_invocation_take_error (context, ret_error);
3898         } else if (result != NM_AUTH_CALL_RESULT_YES) {
3899                 ret_error = g_error_new_literal (NM_MANAGER_ERROR,
3900                                                  NM_MANAGER_ERROR_PERMISSION_DENIED,
3901                                                  "Not authorized to sleep/wake");
3902                 g_dbus_method_invocation_take_error (context, ret_error);
3903         } else {
3904                 /* Auth success */
3905                 do_sleep = GPOINTER_TO_UINT (nm_auth_chain_get_data (chain, "sleep"));
3906                 _internal_sleep (self, do_sleep);
3907                 g_dbus_method_invocation_return_value (context, NULL);
3908         }
3909
3910         nm_auth_chain_unref (chain);
3911 }
3912 #endif
3913
3914 static void
3915 impl_manager_sleep (NMManager *self,
3916                     GDBusMethodInvocation *context,
3917                     gboolean do_sleep)
3918 {
3919         NMManagerPrivate *priv;
3920         GError *error = NULL;
3921         gs_unref_object NMAuthSubject *subject = NULL;
3922 #if 0
3923         NMAuthChain *chain;
3924         const char *error_desc = NULL;
3925 #endif
3926
3927         g_return_if_fail (NM_IS_MANAGER (self));
3928
3929         priv = NM_MANAGER_GET_PRIVATE (self);
3930         subject = nm_auth_subject_new_unix_process_from_context (context);
3931
3932         if (priv->sleeping == do_sleep) {
3933                 error = g_error_new (NM_MANAGER_ERROR,
3934                                      NM_MANAGER_ERROR_ALREADY_ASLEEP_OR_AWAKE,
3935                                      "Already %s", do_sleep ? "asleep" : "awake");
3936                 nm_audit_log_control_op (NM_AUDIT_OP_SLEEP_CONTROL, do_sleep ? "on" : "off", FALSE, subject,
3937                                          error->message);
3938                 g_dbus_method_invocation_take_error (context, error);
3939                 return;
3940         }
3941
3942         /* Unconditionally allow the request.  Previously it was polkit protected
3943          * but unfortunately that doesn't work for short-lived processes like
3944          * pm-utils.  It uses dbus-send without --print-reply, which quits
3945          * immediately after sending the request, and NM is unable to obtain the
3946          * sender's UID as dbus-send has already dropped off the bus.  Thus NM
3947          * fails the request.  Instead, don't validate the request, but rely on
3948          * D-Bus permissions to restrict the call to root.
3949          */
3950         _internal_sleep (self, do_sleep);
3951         nm_audit_log_control_op (NM_AUDIT_OP_SLEEP_CONTROL, do_sleep ? "on" : "off", TRUE, subject, NULL);
3952         g_dbus_method_invocation_return_value (context, NULL);
3953         return;
3954
3955 #if 0
3956         chain = nm_auth_chain_new (context, sleep_auth_done_cb, self, &error_desc);
3957         if (chain) {
3958                 priv->auth_chains = g_slist_append (priv->auth_chains, chain);
3959                 nm_auth_chain_set_data (chain, "sleep", GUINT_TO_POINTER (do_sleep), NULL);
3960                 nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_SLEEP_WAKE, TRUE);
3961         } else {
3962                 error = g_error_new_literal (NM_MANAGER_ERROR,
3963                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
3964                                              error_desc);
3965                 g_dbus_method_invocation_take_error (context, error);
3966         }
3967 #endif
3968 }
3969
3970 static void
3971 sleeping_cb (NMSleepMonitor *monitor, gpointer user_data)
3972 {
3973         nm_log_dbg (LOGD_SUSPEND, "Received sleeping signal");
3974         _internal_sleep (NM_MANAGER (user_data), TRUE);
3975 }
3976
3977 static void
3978 resuming_cb (NMSleepMonitor *monitor, gpointer user_data)
3979 {
3980         nm_log_dbg (LOGD_SUSPEND, "Received resuming signal");
3981         _internal_sleep (NM_MANAGER (user_data), FALSE);
3982 }
3983
3984 static void
3985 _internal_enable (NMManager *self, gboolean enable)
3986 {
3987         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
3988         GError *err = NULL;
3989
3990         /* Update "NetworkingEnabled" key in state file */
3991         if (priv->state_file) {
3992                 if (!write_value_to_state_file (priv->state_file,
3993                                                 "main", "NetworkingEnabled",
3994                                                 G_TYPE_BOOLEAN, (gpointer) &enable,
3995                                                 &err)) {
3996                         /* Not a hard error */
3997                         _LOGW (LOGD_SUSPEND, "writing to state file %s failed: %s",
3998                                priv->state_file,
3999                                err->message);
4000                 }
4001         }
4002
4003         _LOGI (LOGD_SUSPEND, "%s requested (sleeping: %s  enabled: %s)",
4004                enable ? "enable" : "disable",
4005                priv->sleeping ? "yes" : "no",
4006                priv->net_enabled ? "yes" : "no");
4007
4008         priv->net_enabled = enable;
4009
4010         do_sleep_wake (self, FALSE);
4011
4012         g_object_notify (G_OBJECT (self), NM_MANAGER_NETWORKING_ENABLED);
4013 }
4014
4015 static void
4016 enable_net_done_cb (NMAuthChain *chain,
4017                     GError *error,
4018                     GDBusMethodInvocation *context,
4019                     gpointer user_data)
4020 {
4021         NMManager *self = NM_MANAGER (user_data);
4022         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4023         GError *ret_error = NULL;
4024         NMAuthCallResult result;
4025         gboolean enable;
4026         NMAuthSubject *subject;
4027
4028         g_assert (context);
4029
4030         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
4031         enable = GPOINTER_TO_UINT (nm_auth_chain_get_data (chain, "enable"));
4032         subject = nm_auth_chain_get_subject (chain);
4033
4034         result = nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_NETWORK);
4035         if (error) {
4036                 _LOGD (LOGD_CORE, "Enable request failed: %s", error->message);
4037                 ret_error = g_error_new (NM_MANAGER_ERROR,
4038                                          NM_MANAGER_ERROR_PERMISSION_DENIED,
4039                                          "Enable request failed: %s",
4040                                          error->message);
4041         } else if (result != NM_AUTH_CALL_RESULT_YES) {
4042                 ret_error = g_error_new_literal (NM_MANAGER_ERROR,
4043                                                  NM_MANAGER_ERROR_PERMISSION_DENIED,
4044                                                  "Not authorized to enable/disable networking");
4045         } else {
4046                 /* Auth success */
4047                 _internal_enable (self, enable);
4048                 g_dbus_method_invocation_return_value (context, NULL);
4049                 nm_audit_log_control_op (NM_AUDIT_OP_NET_CONTROL, enable ? "on" : "off", TRUE,
4050                                          subject, NULL);
4051         }
4052
4053         if (ret_error) {
4054                 nm_audit_log_control_op (NM_AUDIT_OP_NET_CONTROL, enable ? "on" : "off", FALSE,
4055                                          subject, ret_error->message);
4056                 g_dbus_method_invocation_take_error (context, ret_error);
4057         }
4058
4059         nm_auth_chain_unref (chain);
4060 }
4061
4062 static void
4063 impl_manager_enable (NMManager *self,
4064                      GDBusMethodInvocation *context,
4065                      gboolean enable)
4066 {
4067         NMManagerPrivate *priv;
4068         NMAuthChain *chain;
4069         GError *error = NULL;
4070
4071         g_return_if_fail (NM_IS_MANAGER (self));
4072
4073         priv = NM_MANAGER_GET_PRIVATE (self);
4074
4075         if (priv->net_enabled == enable) {
4076                 error = g_error_new (NM_MANAGER_ERROR,
4077                                      NM_MANAGER_ERROR_ALREADY_ENABLED_OR_DISABLED,
4078                                      "Already %s", enable ? "enabled" : "disabled");
4079                 goto done;
4080         }
4081
4082         chain = nm_auth_chain_new_context (context, enable_net_done_cb, self);
4083         if (!chain) {
4084                 error = g_error_new_literal (NM_MANAGER_ERROR,
4085                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4086                                              "Unable to authenticate request.");
4087                 goto done;
4088         }
4089
4090         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
4091         nm_auth_chain_set_data (chain, "enable", GUINT_TO_POINTER (enable), NULL);
4092         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_NETWORK, TRUE);
4093
4094 done:
4095         if (error)
4096                 g_dbus_method_invocation_take_error (context, error);
4097 }
4098
4099 /* Permissions */
4100
4101 static void
4102 get_perm_add_result (NMAuthChain *chain, GVariantBuilder *results, const char *permission)
4103 {
4104         NMAuthCallResult result;
4105
4106         result = nm_auth_chain_get_result (chain, permission);
4107         if (result == NM_AUTH_CALL_RESULT_YES)
4108                 g_variant_builder_add (results, "{ss}", permission, "yes");
4109         else if (result == NM_AUTH_CALL_RESULT_NO)
4110                 g_variant_builder_add (results, "{ss}", permission, "no");
4111         else if (result == NM_AUTH_CALL_RESULT_AUTH)
4112                 g_variant_builder_add (results, "{ss}", permission, "auth");
4113         else {
4114                 nm_log_dbg (LOGD_CORE, "unknown auth chain result %d", result);
4115         }
4116 }
4117
4118 static void
4119 get_permissions_done_cb (NMAuthChain *chain,
4120                          GError *error,
4121                          GDBusMethodInvocation *context,
4122                          gpointer user_data)
4123 {
4124         NMManager *self = NM_MANAGER (user_data);
4125         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4126         GError *ret_error;
4127         GVariantBuilder results;
4128
4129         g_assert (context);
4130
4131         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
4132         if (error) {
4133                 _LOGD (LOGD_CORE, "Permissions request failed: %s", error->message);
4134                 ret_error = g_error_new (NM_MANAGER_ERROR,
4135                                          NM_MANAGER_ERROR_PERMISSION_DENIED,
4136                                          "Permissions request failed: %s",
4137                                          error->message);
4138                 g_dbus_method_invocation_take_error (context, ret_error);
4139         } else {
4140                 g_variant_builder_init (&results, G_VARIANT_TYPE ("a{ss}"));
4141
4142                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_ENABLE_DISABLE_NETWORK);
4143                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_SLEEP_WAKE);
4144                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_ENABLE_DISABLE_WIFI);
4145                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_ENABLE_DISABLE_WWAN);
4146                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_ENABLE_DISABLE_WIMAX);
4147                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_NETWORK_CONTROL);
4148                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED);
4149                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN);
4150                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_SETTINGS_MODIFY_SYSTEM);
4151                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_SETTINGS_MODIFY_OWN);
4152                 get_perm_add_result (chain, &results, NM_AUTH_PERMISSION_SETTINGS_MODIFY_HOSTNAME);
4153
4154                 g_dbus_method_invocation_return_value (context,
4155                                                        g_variant_new ("(a{ss})", &results));
4156         }
4157
4158         nm_auth_chain_unref (chain);
4159 }
4160
4161 static void
4162 impl_manager_get_permissions (NMManager *self,
4163                               GDBusMethodInvocation *context)
4164 {
4165         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4166         NMAuthChain *chain;
4167         GError *error = NULL;
4168
4169         chain = nm_auth_chain_new_context (context, get_permissions_done_cb, self);
4170         if (!chain) {
4171                 error = g_error_new_literal (NM_MANAGER_ERROR,
4172                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4173                                              "Unable to authenticate request.");
4174                 g_dbus_method_invocation_take_error (context, error);
4175                 return;
4176         }
4177
4178         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
4179         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_NETWORK, FALSE);
4180         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_SLEEP_WAKE, FALSE);
4181         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_WIFI, FALSE);
4182         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_WWAN, FALSE);
4183         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_ENABLE_DISABLE_WIMAX, FALSE);
4184         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_NETWORK_CONTROL, FALSE);
4185         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED, FALSE);
4186         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN, FALSE);
4187         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_SETTINGS_MODIFY_SYSTEM, FALSE);
4188         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_SETTINGS_MODIFY_OWN, FALSE);
4189         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_SETTINGS_MODIFY_HOSTNAME, FALSE);
4190 }
4191
4192 static void
4193 impl_manager_get_state (NMManager *self,
4194                         GDBusMethodInvocation *context)
4195 {
4196         nm_manager_update_state (self);
4197         g_dbus_method_invocation_return_value (context,
4198                                                g_variant_new ("(u)", NM_MANAGER_GET_PRIVATE (self)->state));
4199 }
4200
4201 static void
4202 impl_manager_set_logging (NMManager *self,
4203                           GDBusMethodInvocation *context,
4204                           const char *level,
4205                           const char *domains)
4206 {
4207         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4208         GError *error = NULL;
4209         gulong caller_uid = G_MAXULONG;
4210
4211         if (!nm_bus_manager_get_caller_info (priv->dbus_mgr, context, NULL, &caller_uid, NULL)) {
4212                 error = g_error_new_literal (NM_MANAGER_ERROR,
4213                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4214                                              "Failed to get request UID.");
4215                 goto done;
4216         }
4217
4218         if (0 != caller_uid) {
4219                 error = g_error_new_literal (NM_MANAGER_ERROR,
4220                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4221                                              "Permission denied");
4222                 goto done;
4223         }
4224
4225         if (nm_logging_setup (level, domains, NULL, &error)) {
4226                 _LOGI (LOGD_CORE, "logging: level '%s' domains '%s'",
4227                        nm_logging_level_to_string (), nm_logging_domains_to_string ());
4228         }
4229
4230 done:
4231         if (error)
4232                 g_dbus_method_invocation_take_error (context, error);
4233         else
4234                 g_dbus_method_invocation_return_value (context, NULL);
4235 }
4236
4237 static void
4238 impl_manager_get_logging (NMManager *manager,
4239                           GDBusMethodInvocation *context)
4240 {
4241         g_dbus_method_invocation_return_value (context,
4242                                                g_variant_new ("(ss)",
4243                                                               nm_logging_level_to_string (),
4244                                                               nm_logging_domains_to_string ()));
4245 }
4246
4247 static void
4248 connectivity_check_done (GObject *object,
4249                          GAsyncResult *result,
4250                          gpointer user_data)
4251 {
4252         GDBusMethodInvocation *context = user_data;
4253         NMConnectivityState state;
4254         GError *error = NULL;
4255
4256         state = nm_connectivity_check_finish (NM_CONNECTIVITY (object), result, &error);
4257         if (error)
4258                 g_dbus_method_invocation_take_error (context, error);
4259         else {
4260                 g_dbus_method_invocation_return_value (context,
4261                                                        g_variant_new ("(u)", state));
4262         }
4263 }
4264
4265
4266 static void
4267 check_connectivity_auth_done_cb (NMAuthChain *chain,
4268                                  GError *auth_error,
4269                                  GDBusMethodInvocation *context,
4270                                  gpointer user_data)
4271 {
4272         NMManager *self = NM_MANAGER (user_data);
4273         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4274         GError *error = NULL;
4275         NMAuthCallResult result;
4276
4277         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
4278
4279         result = nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_NETWORK_CONTROL);
4280
4281         if (auth_error) {
4282                 _LOGD (LOGD_CORE, "CheckConnectivity request failed: %s", auth_error->message);
4283                 error = g_error_new (NM_MANAGER_ERROR,
4284                                      NM_MANAGER_ERROR_PERMISSION_DENIED,
4285                                      "Connectivity check request failed: %s",
4286                                      auth_error->message);
4287         } else if (result != NM_AUTH_CALL_RESULT_YES) {
4288                 error = g_error_new_literal (NM_MANAGER_ERROR,
4289                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4290                                              "Not authorized to recheck connectivity");
4291         } else {
4292                 /* it's allowed */
4293                 nm_connectivity_check_async (priv->connectivity,
4294                                              connectivity_check_done,
4295                                              context);
4296         }
4297
4298         if (error)
4299                 g_dbus_method_invocation_take_error (context, error);
4300         nm_auth_chain_unref (chain);
4301 }
4302
4303 static void
4304 impl_manager_check_connectivity (NMManager *self,
4305                                  GDBusMethodInvocation *context)
4306 {
4307         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4308         NMAuthChain *chain;
4309         GError *error = NULL;
4310
4311         /* Validate the request */
4312         chain = nm_auth_chain_new_context (context, check_connectivity_auth_done_cb, self);
4313         if (!chain) {
4314                 error = g_error_new_literal (NM_MANAGER_ERROR,
4315                                              NM_MANAGER_ERROR_PERMISSION_DENIED,
4316                                              "Unable to authenticate request.");
4317                 g_dbus_method_invocation_take_error (context, error);
4318                 return;
4319         }
4320
4321         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
4322         nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_NETWORK_CONTROL, TRUE);
4323 }
4324
4325 static void
4326 start_factory (NMDeviceFactory *factory, gpointer user_data)
4327 {
4328         nm_device_factory_start (factory);
4329 }
4330
4331 gboolean
4332 nm_manager_start (NMManager *self, GError **error)
4333 {
4334         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4335         GSList *iter, *connections;
4336         guint i;
4337
4338         if (!nm_settings_start (priv->settings, error))
4339                 return FALSE;
4340
4341         g_signal_connect (NM_PLATFORM_GET,
4342                           NM_PLATFORM_SIGNAL_LINK_CHANGED,
4343                           G_CALLBACK (platform_link_cb),
4344                           self);
4345
4346         /* Set initial radio enabled/disabled state */
4347         for (i = 0; i < RFKILL_TYPE_MAX; i++) {
4348                 RadioState *rstate = &priv->radio_states[i];
4349                 gboolean enabled;
4350
4351                 if (!rstate->desc)
4352                         continue;
4353
4354                 /* recheck kernel rfkill state */
4355                 update_rstate_from_rfkill (priv->rfkill_mgr, rstate);
4356
4357                 if (rstate->desc) {
4358                         _LOGI (LOGD_RFKILL, "%s %s by radio killswitch; %s by state file",
4359                                rstate->desc,
4360                                (rstate->hw_enabled && rstate->sw_enabled) ? "enabled" : "disabled",
4361                                rstate->user_enabled ? "enabled" : "disabled");
4362                 }
4363                 enabled = radio_enabled_for_rstate (rstate, TRUE);
4364                 manager_update_radio_enabled (self, rstate, enabled);
4365         }
4366
4367         /* Log overall networking status - enabled/disabled */
4368         _LOGI (LOGD_CORE, "Networking is %s by state file",
4369                priv->net_enabled ? "enabled" : "disabled");
4370
4371         system_unmanaged_devices_changed_cb (priv->settings, NULL, self);
4372         system_hostname_changed_cb (priv->settings, NULL, self);
4373
4374         /* Start device factories */
4375         nm_device_factory_manager_load_factories (_register_device_factory, self);
4376         nm_device_factory_manager_for_each_factory (start_factory, NULL);
4377
4378         platform_query_devices (self);
4379
4380         /* Load VPN plugins */
4381         priv->vpn_manager = g_object_ref (nm_vpn_manager_get ());
4382
4383         /* Connections added before the manager is started do not emit
4384          * connection-added signals thus devices have to be created manually.
4385          */
4386         _LOGD (LOGD_CORE, "creating virtual devices...");
4387         connections = nm_settings_get_connections (priv->settings);
4388         for (iter = connections; iter; iter = iter->next)
4389                 connection_changed (priv->settings, NM_CONNECTION (iter->data), self);
4390         g_slist_free (connections);
4391
4392         priv->devices_inited = TRUE;
4393
4394         check_if_startup_complete (self);
4395
4396         return TRUE;
4397 }
4398
4399 void
4400 nm_manager_stop (NMManager *self)
4401 {
4402         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4403
4404         /* Remove all devices */
4405         while (priv->devices)
4406                 remove_device (self, NM_DEVICE (priv->devices->data), TRUE, TRUE);
4407
4408         _active_connection_cleanup (self);
4409 }
4410
4411 static gboolean
4412 handle_firmware_changed (gpointer user_data)
4413 {
4414         NMManager *self = NM_MANAGER (user_data);
4415         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4416         GSList *iter;
4417
4418         priv->fw_changed_id = 0;
4419
4420         /* Try to re-enable devices with missing firmware */
4421         for (iter = priv->devices; iter; iter = iter->next) {
4422                 NMDevice *candidate = NM_DEVICE (iter->data);
4423                 NMDeviceState state = nm_device_get_state (candidate);
4424
4425                 if (   nm_device_get_firmware_missing (candidate)
4426                     && (state == NM_DEVICE_STATE_UNAVAILABLE)) {
4427                         _LOGI (LOGD_CORE, "(%s): firmware may now be available",
4428                                nm_device_get_iface (candidate));
4429
4430                         /* Re-set unavailable state to try bringing the device up again */
4431                         nm_device_state_changed (candidate,
4432                                                  NM_DEVICE_STATE_UNAVAILABLE,
4433                                                  NM_DEVICE_STATE_REASON_NONE);
4434                 }
4435         }
4436
4437         return FALSE;
4438 }
4439
4440 static void
4441 connectivity_changed (NMConnectivity *connectivity,
4442                       GParamSpec *pspec,
4443                       gpointer user_data)
4444 {
4445         NMManager *self = NM_MANAGER (user_data);
4446
4447         _LOGD (LOGD_CORE, "connectivity checking indicates %s",
4448                nm_connectivity_state_to_string (nm_connectivity_get_state (connectivity)));
4449
4450         nm_manager_update_state (self);
4451         g_object_notify (G_OBJECT (self), NM_MANAGER_CONNECTIVITY);
4452 }
4453
4454 static void
4455 firmware_dir_changed (GFileMonitor *monitor,
4456                       GFile *file,
4457                       GFile *other_file,
4458                       GFileMonitorEvent event_type,
4459                       gpointer user_data)
4460 {
4461         NMManager *self = NM_MANAGER (user_data);
4462         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4463
4464         switch (event_type) {
4465         case G_FILE_MONITOR_EVENT_CREATED:
4466         case G_FILE_MONITOR_EVENT_CHANGED:
4467         case G_FILE_MONITOR_EVENT_MOVED:
4468         case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
4469         case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
4470                 if (!priv->fw_changed_id) {
4471                         priv->fw_changed_id = g_timeout_add_seconds (4, handle_firmware_changed, self);
4472                         _LOGI (LOGD_CORE, "kernel firmware directory '%s' changed",
4473                                KERNEL_FIRMWARE_DIR);
4474                 }
4475                 break;
4476         default:
4477                 break;
4478         }
4479 }
4480
4481 static void
4482 connection_metered_changed (GObject *object,
4483                             NMMetered metered,
4484                             gpointer user_data)
4485 {
4486         nm_manager_update_metered (NM_MANAGER (user_data));
4487 }
4488
4489 static void
4490 policy_default_device_changed (GObject *object, GParamSpec *pspec, gpointer user_data)
4491 {
4492         NMManager *self = NM_MANAGER (user_data);
4493         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4494         NMDevice *best;
4495         NMActiveConnection *ac;
4496
4497         /* Note: this assumes that it's not possible for the IP4 default
4498          * route to be going over the default-ip6-device. If that changes,
4499          * we need something more complicated here.
4500          */
4501         best = nm_policy_get_default_ip4_device (priv->policy);
4502         if (!best)
4503                 best = nm_policy_get_default_ip6_device (priv->policy);
4504
4505         if (best)
4506                 ac = NM_ACTIVE_CONNECTION (nm_device_get_act_request (best));
4507         else
4508                 ac = NULL;
4509
4510         if (ac != priv->primary_connection) {
4511                 if (priv->primary_connection) {
4512                         g_signal_handlers_disconnect_by_func (priv->primary_connection,
4513                                                               G_CALLBACK (connection_metered_changed),
4514                                                               self);
4515                         g_clear_object (&priv->primary_connection);
4516                 }
4517
4518                 priv->primary_connection = ac ? g_object_ref (ac) : NULL;
4519
4520                 if (priv->primary_connection) {
4521                         g_signal_connect (priv->primary_connection, NM_ACTIVE_CONNECTION_DEVICE_METERED_CHANGED,
4522                                           G_CALLBACK (connection_metered_changed), self);
4523                 }
4524                 _LOGD (LOGD_CORE, "PrimaryConnection now %s", ac ? nm_active_connection_get_settings_connection_id (ac) : "(none)");
4525                 g_object_notify (G_OBJECT (self), NM_MANAGER_PRIMARY_CONNECTION);
4526                 g_object_notify (G_OBJECT (self), NM_MANAGER_PRIMARY_CONNECTION_TYPE);
4527                 nm_manager_update_metered (self);
4528         }
4529 }
4530
4531 static void
4532 policy_activating_device_changed (GObject *object, GParamSpec *pspec, gpointer user_data)
4533 {
4534         NMManager *self = NM_MANAGER (user_data);
4535         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4536         NMDevice *activating, *best;
4537         NMActiveConnection *ac;
4538
4539         /* We only look at activating-ip6-device if activating-ip4-device
4540          * AND default-ip4-device are NULL; if default-ip4-device is
4541          * non-NULL, then activating-ip6-device is irrelevant, since while
4542          * that device might become the new default-ip6-device, it can't
4543          * become primary-connection while default-ip4-device is set to
4544          * something else.
4545          */
4546         activating = nm_policy_get_activating_ip4_device (priv->policy);
4547         best = nm_policy_get_default_ip4_device (priv->policy);
4548         if (!activating && !best)
4549                 activating = nm_policy_get_activating_ip6_device (priv->policy);
4550
4551         if (activating)
4552                 ac = NM_ACTIVE_CONNECTION (nm_device_get_act_request (activating));
4553         else
4554                 ac = NULL;
4555
4556         if (ac != priv->activating_connection) {
4557                 g_clear_object (&priv->activating_connection);
4558                 priv->activating_connection = ac ? g_object_ref (ac) : NULL;
4559                 _LOGD (LOGD_CORE, "ActivatingConnection now %s", ac ? nm_active_connection_get_settings_connection_id (ac) : "(none)");
4560                 g_object_notify (G_OBJECT (self), NM_MANAGER_ACTIVATING_CONNECTION);
4561         }
4562 }
4563
4564 #define NM_PERM_DENIED_ERROR "org.freedesktop.NetworkManager.PermissionDenied"
4565
4566 typedef struct {
4567         NMManager *self;
4568         GDBusConnection *connection;
4569         GDBusMessage *message;
4570         NMAuthSubject *subject;
4571         const char *permission;
4572         const char *audit_op;
4573         char *audit_prop_value;
4574         GType interface_type;
4575         const char *glib_propname;
4576 } PropertyFilterData;
4577
4578 static void
4579 free_property_filter_data (PropertyFilterData *pfd)
4580 {
4581         g_object_unref (pfd->self);
4582         g_object_unref (pfd->connection);
4583         g_object_unref (pfd->message);
4584         g_clear_object (&pfd->subject);
4585         g_free (pfd->audit_prop_value);
4586         g_slice_free (PropertyFilterData, pfd);
4587 }
4588
4589 static void
4590 prop_set_auth_done_cb (NMAuthChain *chain,
4591                        GError *error,
4592                        GDBusMethodInvocation *context, /* NULL */
4593                        gpointer user_data)
4594 {
4595         PropertyFilterData *pfd = user_data;
4596         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (pfd->self);
4597         NMAuthCallResult result;
4598         GDBusMessage *reply = NULL;
4599         const char *error_message;
4600         gs_unref_object NMExportedObject *object = NULL;
4601         const NMGlobalDnsConfig *global_dns;
4602         gs_unref_variant GVariant *value = NULL;
4603         GVariant *args;
4604
4605         priv->auth_chains = g_slist_remove (priv->auth_chains, chain);
4606         result = nm_auth_chain_get_result (chain, pfd->permission);
4607         if (error || (result != NM_AUTH_CALL_RESULT_YES)) {
4608                 reply = g_dbus_message_new_method_error (pfd->message,
4609                                                          NM_PERM_DENIED_ERROR,
4610                                                          (error_message = "Not authorized to perform this operation"));
4611                 if (error)
4612                         error_message = error->message;
4613                 goto done;
4614         }
4615
4616         object = NM_EXPORTED_OBJECT (nm_bus_manager_get_registered_object (priv->dbus_mgr,
4617                                                                            g_dbus_message_get_path (pfd->message)));
4618         if (!object) {
4619                 reply = g_dbus_message_new_method_error (pfd->message,
4620                                                          "org.freedesktop.DBus.Error.UnknownObject",
4621                                                          (error_message = "Object doesn't exist."));
4622                 goto done;
4623         }
4624
4625         /* do some extra type checking... */
4626         if (!nm_exported_object_get_interface_by_type (object, pfd->interface_type)) {
4627                 reply = g_dbus_message_new_method_error (pfd->message,
4628                                                          "org.freedesktop.DBus.Error.InvalidArgs",
4629                                                          (error_message = "Object is of unexpected type."));
4630                 goto done;
4631         }
4632
4633         args = g_dbus_message_get_body (pfd->message);
4634         g_variant_get (args, "(&s&sv)", NULL, NULL, &value);
4635         g_assert (pfd->glib_propname);
4636
4637         if (!strcmp (pfd->glib_propname, NM_MANAGER_GLOBAL_DNS_CONFIGURATION)) {
4638                 g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("a{sv}")));
4639                 global_dns = nm_config_data_get_global_dns_config (nm_config_get_data (priv->config));
4640
4641                 if (global_dns && !nm_global_dns_config_is_internal (global_dns)) {
4642                         reply = g_dbus_message_new_method_error (pfd->message,
4643                                                                  NM_PERM_DENIED_ERROR,
4644                                                                  (error_message = "Global DNS configuration already set via configuration file"));
4645                         goto done;
4646                 }
4647                 /* ... but set the property on the @object itself. It would be correct to set the property
4648                  * on the skeleton interface, but as it is now, the result is the same. */
4649                 g_object_set (object, pfd->glib_propname, value, NULL);
4650         } else {
4651                 g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN));
4652                 /* the same here */
4653                 g_object_set (object, pfd->glib_propname, g_variant_get_boolean (value), NULL);
4654         }
4655
4656         reply = g_dbus_message_new_method_reply (pfd->message);
4657         g_dbus_message_set_body (reply, g_variant_new_tuple (NULL, 0));
4658         error_message = NULL;
4659 done:
4660         nm_audit_log_control_op (pfd->audit_op, pfd->audit_prop_value, !error_message, pfd->subject, error_message);
4661
4662         g_dbus_connection_send_message (pfd->connection, reply,
4663                                         G_DBUS_SEND_MESSAGE_FLAGS_NONE,
4664                                         NULL, NULL);
4665         g_object_unref (reply);
4666         nm_auth_chain_unref (chain);
4667
4668         free_property_filter_data (pfd);
4669 }
4670
4671 static gboolean
4672 do_set_property_check (gpointer user_data)
4673 {
4674         PropertyFilterData *pfd = user_data;
4675         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (pfd->self);
4676         GDBusMessage *reply = NULL;
4677         NMAuthChain *chain;
4678         const char *error_message = NULL;
4679
4680         pfd->subject = nm_auth_subject_new_unix_process_from_message (pfd->connection, pfd->message);
4681         if (!pfd->subject) {
4682                 reply = g_dbus_message_new_method_error (pfd->message,
4683                                                          NM_PERM_DENIED_ERROR,
4684                                                          (error_message = "Could not determine request UID."));
4685                 goto out;
4686         }
4687
4688         /* Validate the user request */
4689         chain = nm_auth_chain_new_subject (pfd->subject, NULL, prop_set_auth_done_cb, pfd);
4690         if (!chain) {
4691                 reply = g_dbus_message_new_method_error (pfd->message,
4692                                                          NM_PERM_DENIED_ERROR,
4693                                                          (error_message = "Could not authenticate request."));
4694                 goto out;
4695         }
4696
4697         priv->auth_chains = g_slist_append (priv->auth_chains, chain);
4698         nm_auth_chain_add_call (chain, pfd->permission, TRUE);
4699
4700 out:
4701         if (reply) {
4702                 nm_audit_log_control_op (pfd->audit_op, pfd->audit_prop_value, FALSE, pfd->subject, error_message);
4703                 g_dbus_connection_send_message (pfd->connection, reply,
4704                                                 G_DBUS_SEND_MESSAGE_FLAGS_NONE,
4705                                                 NULL, NULL);
4706                 g_object_unref (reply);
4707                 free_property_filter_data (pfd);
4708         }
4709
4710         return FALSE;
4711 }
4712
4713 static GDBusMessage *
4714 prop_filter (GDBusConnection *connection,
4715              GDBusMessage *message,
4716              gboolean incoming,
4717              gpointer user_data)
4718 {
4719         gs_unref_object NMManager *self = NULL;
4720         GVariant *args;
4721         const char *propiface = NULL;
4722         const char *propname = NULL;
4723         const char *glib_propname = NULL, *permission = NULL;
4724         const char *audit_op = NULL;
4725         GType interface_type = G_TYPE_INVALID;
4726         PropertyFilterData *pfd;
4727         const GVariantType *expected_type = G_VARIANT_TYPE_BOOLEAN;
4728         gs_unref_variant GVariant *value = NULL;
4729
4730         self = g_weak_ref_get (user_data);
4731         if (!self)
4732                 return message;
4733
4734         /* The sole purpose of this function is to validate property accesses on the
4735          * NMManager object since gdbus doesn't give us this functionality.
4736          */
4737
4738         /* Only filter org.freedesktop.DBus.Properties.Set calls */
4739         if (   !incoming
4740             || g_dbus_message_get_message_type (message) != G_DBUS_MESSAGE_TYPE_METHOD_CALL
4741             || g_strcmp0 (g_dbus_message_get_interface (message), DBUS_INTERFACE_PROPERTIES) != 0
4742             || g_strcmp0 (g_dbus_message_get_member (message), "Set") != 0)
4743                 return message;
4744
4745         args = g_dbus_message_get_body (message);
4746         if (!g_variant_is_of_type (args, G_VARIANT_TYPE ("(ssv)")))
4747                 return message;
4748         g_variant_get (args, "(&s&sv)", &propiface, &propname, &value);
4749
4750         /* Only filter calls to filtered properties, on existing objects */
4751         if (!strcmp (propiface, NM_DBUS_INTERFACE)) {
4752                 if (!strcmp (propname, "WirelessEnabled")) {
4753                         glib_propname = NM_MANAGER_WIRELESS_ENABLED;
4754                         permission = NM_AUTH_PERMISSION_ENABLE_DISABLE_WIFI;
4755                         audit_op = NM_AUDIT_OP_RADIO_CONTROL;
4756                 } else if (!strcmp (propname, "WwanEnabled")) {
4757                         glib_propname = NM_MANAGER_WWAN_ENABLED;
4758                         permission = NM_AUTH_PERMISSION_ENABLE_DISABLE_WWAN;
4759                         audit_op = NM_AUDIT_OP_RADIO_CONTROL;
4760                 } else if (!strcmp (propname, "WimaxEnabled")) {
4761                         glib_propname = NM_MANAGER_WIMAX_ENABLED;
4762                         permission = NM_AUTH_PERMISSION_ENABLE_DISABLE_WIMAX;
4763                         audit_op = NM_AUDIT_OP_RADIO_CONTROL;
4764                 } else if (!strcmp (propname, "GlobalDnsConfiguration")) {
4765                         glib_propname = NM_MANAGER_GLOBAL_DNS_CONFIGURATION;
4766                         permission = NM_AUTH_PERMISSION_SETTINGS_MODIFY_GLOBAL_DNS;
4767                         audit_op = NM_AUDIT_OP_NET_CONTROL;
4768                         expected_type = G_VARIANT_TYPE ("a{sv}");
4769                 } else
4770                         return message;
4771                 interface_type = NMDBUS_TYPE_MANAGER_SKELETON;
4772         } else if (!strcmp (propiface, NM_DBUS_INTERFACE_DEVICE)) {
4773                 if (!strcmp (propname, "Autoconnect")) {
4774                         glib_propname = NM_DEVICE_AUTOCONNECT;
4775                         permission = NM_AUTH_PERMISSION_NETWORK_CONTROL;
4776                         audit_op = NM_AUDIT_OP_DEVICE_AUTOCONNECT;
4777                 } else if (!strcmp (propname, "Managed")) {
4778                         glib_propname = NM_DEVICE_MANAGED;
4779                         permission = NM_AUTH_PERMISSION_NETWORK_CONTROL;
4780                         audit_op = NM_AUDIT_OP_DEVICE_MANAGED;
4781                 } else
4782                         return message;
4783                 interface_type = NMDBUS_TYPE_DEVICE_SKELETON;
4784         } else
4785                 return message;
4786
4787         if (!g_variant_is_of_type (value, expected_type))
4788                 return message;
4789
4790         /* This filter function is called from a gdbus worker thread which we can't
4791          * make other D-Bus calls from. In particular, we cannot call
4792          * org.freedesktop.DBus.GetConnectionUnixUser to find the remote UID.
4793          */
4794         pfd = g_slice_new0 (PropertyFilterData);
4795         pfd->self = self;
4796         self = NULL;
4797         pfd->connection = g_object_ref (connection);
4798         pfd->message = message;
4799         pfd->permission = permission;
4800         pfd->interface_type = interface_type;
4801         pfd->glib_propname = glib_propname;
4802         pfd->audit_op = audit_op;
4803         if (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
4804                 pfd->audit_prop_value = g_strdup_printf ("%s:%d", pfd->glib_propname,
4805                                                          g_variant_get_boolean (value));
4806         } else
4807                 pfd->audit_prop_value = g_strdup (pfd->glib_propname);
4808
4809         g_idle_add (do_set_property_check, pfd);
4810
4811         return NULL;
4812 }
4813
4814 /******************************************************************************/
4815
4816 static int
4817 _set_prop_filter_free2 (gpointer user_data)
4818 {
4819         g_slice_free (GWeakRef, user_data);
4820         return G_SOURCE_REMOVE;
4821 }
4822
4823 static void
4824 _set_prop_filter_free (gpointer user_data)
4825 {
4826         g_weak_ref_clear (user_data);
4827
4828         /* Delay the final deletion of the user_data. There is a race when
4829          * calling g_dbus_connection_remove_filter() that the callback and user_data
4830          * might have been copied and being executed after the destroy function
4831          * runs (bgo #704568).
4832          * This doesn't really fix the race, but it should work well enough. */
4833         g_timeout_add_seconds (2, _set_prop_filter_free2, user_data);
4834 }
4835
4836 static void
4837 _set_prop_filter (NMManager *self, GDBusConnection *connection)
4838 {
4839         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4840
4841         nm_assert ((!priv->prop_filter.connection) == (!priv->prop_filter.id));
4842
4843         if (priv->prop_filter.connection == connection)
4844                 return;
4845
4846         if (priv->prop_filter.connection) {
4847                 g_dbus_connection_remove_filter (priv->prop_filter.connection, priv->prop_filter.id);
4848                 priv->prop_filter.id = 0;
4849                 g_clear_object (&priv->prop_filter.connection);
4850         }
4851         if (connection) {
4852                 GWeakRef *wptr;
4853
4854                 wptr = g_slice_new (GWeakRef);
4855                 g_weak_ref_init  (wptr, self);
4856                 priv->prop_filter.id = g_dbus_connection_add_filter (connection, prop_filter, wptr, _set_prop_filter_free);
4857                 priv->prop_filter.connection = g_object_ref (connection);
4858         }
4859 }
4860
4861 /******************************************************************************/
4862
4863 static void
4864 authority_changed_cb (NMAuthManager *auth_manager, gpointer user_data)
4865 {
4866         /* Let clients know they should re-check their authorization */
4867         g_signal_emit (NM_MANAGER (user_data), signals[CHECK_PERMISSIONS], 0);
4868 }
4869
4870 #define KERN_RFKILL_OP_CHANGE_ALL 3
4871 #define KERN_RFKILL_TYPE_WLAN     1
4872 #define KERN_RFKILL_TYPE_WWAN     5
4873 struct rfkill_event {
4874         __u32 idx;
4875         __u8  type;
4876         __u8  op;
4877         __u8  soft, hard;
4878 } __attribute__((packed));
4879
4880 static void
4881 rfkill_change (const char *desc, RfKillType rtype, gboolean enabled)
4882 {
4883         int fd;
4884         struct rfkill_event event;
4885         ssize_t len;
4886
4887         g_return_if_fail (rtype == RFKILL_TYPE_WLAN || rtype == RFKILL_TYPE_WWAN);
4888
4889         errno = 0;
4890         fd = open ("/dev/rfkill", O_RDWR);
4891         if (fd < 0) {
4892                 if (errno == EACCES)
4893                         nm_log_warn (LOGD_RFKILL, "(%s): failed to open killswitch device", desc);
4894                 return;
4895         }
4896
4897         if (fcntl (fd, F_SETFL, O_NONBLOCK) < 0) {
4898                 nm_log_warn (LOGD_RFKILL, "(%s): failed to set killswitch device for "
4899                              "non-blocking operation", desc);
4900                 close (fd);
4901                 return;
4902         }
4903
4904         memset (&event, 0, sizeof (event));
4905         event.op = KERN_RFKILL_OP_CHANGE_ALL;
4906         switch (rtype) {
4907         case RFKILL_TYPE_WLAN:
4908                 event.type = KERN_RFKILL_TYPE_WLAN;
4909                 break;
4910         case RFKILL_TYPE_WWAN:
4911                 event.type = KERN_RFKILL_TYPE_WWAN;
4912                 break;
4913         default:
4914                 g_assert_not_reached ();
4915         }
4916         event.soft = enabled ? 0 : 1;
4917
4918         len = write (fd, &event, sizeof (event));
4919         if (len < 0) {
4920                 nm_log_warn (LOGD_RFKILL, "(%s): failed to change WiFi killswitch state: (%d) %s",
4921                              desc, errno, g_strerror (errno));
4922         } else if (len == sizeof (event)) {
4923                 nm_log_info (LOGD_RFKILL, "%s hardware radio set %s",
4924                              desc, enabled ? "enabled" : "disabled");
4925         } else {
4926                 /* Failed to write full structure */
4927                 nm_log_warn (LOGD_RFKILL, "(%s): failed to change WiFi killswitch state", desc);
4928         }
4929
4930         close (fd);
4931 }
4932
4933 static void
4934 manager_radio_user_toggled (NMManager *self,
4935                             RadioState *rstate,
4936                             gboolean enabled)
4937 {
4938         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
4939         GError *error = NULL;
4940         gboolean old_enabled, new_enabled;
4941
4942         /* Don't touch devices if asleep/networking disabled */
4943         if (manager_sleeping (self))
4944                 return;
4945
4946         if (rstate->desc) {
4947                 _LOGD (LOGD_RFKILL, "(%s): setting radio %s by user",
4948                        rstate->desc,
4949                        enabled ? "enabled" : "disabled");
4950         }
4951
4952         /* Update enabled key in state file */
4953         if (priv->state_file) {
4954                 if (!write_value_to_state_file (priv->state_file,
4955                                                 "main", rstate->key,
4956                                                 G_TYPE_BOOLEAN, (gpointer) &enabled,
4957                                                 &error)) {
4958                         _LOGW (LOGD_CORE, "writing to state file %s failed: %s",
4959                                priv->state_file,
4960                                error->message);
4961                         g_clear_error (&error);
4962                 }
4963         }
4964
4965         /* When the user toggles the radio, their request should override any
4966          * daemon (like ModemManager) enabled state that can be changed.  For WWAN
4967          * for example, we want the WwanEnabled property to reflect the daemon state
4968          * too so that users can toggle the modem powered, but we don't want that
4969          * daemon state to affect whether or not the user *can* turn it on, which is
4970          * what the kernel rfkill state does.  So we ignore daemon enabled state
4971          * when determining what the new state should be since it shouldn't block
4972          * the user's request.
4973          */
4974         old_enabled = radio_enabled_for_rstate (rstate, TRUE);
4975         rstate->user_enabled = enabled;
4976         new_enabled = radio_enabled_for_rstate (rstate, FALSE);
4977         if (new_enabled != old_enabled) {
4978                 /* Try to change the kernel rfkill state */
4979                 if (rstate->rtype == RFKILL_TYPE_WLAN || rstate->rtype == RFKILL_TYPE_WWAN)
4980                         rfkill_change (rstate->desc, rstate->rtype, new_enabled);
4981
4982                 manager_update_radio_enabled (self, rstate, new_enabled);
4983         }
4984 }
4985
4986 static gboolean
4987 periodic_update_active_connection_timestamps (gpointer user_data)
4988 {
4989         NMManager *manager = NM_MANAGER (user_data);
4990         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
4991         GSList *iter;
4992
4993         for (iter = priv->active_connections; iter; iter = g_slist_next (iter)) {
4994                 NMActiveConnection *ac = iter->data;
4995                 NMSettingsConnection *connection;
4996
4997                 if (nm_active_connection_get_state (ac) == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
4998                         connection = nm_active_connection_get_settings_connection (ac);
4999                         nm_settings_connection_update_timestamp (connection, (guint64) time (NULL), FALSE);
5000                 }
5001         }
5002
5003         return TRUE;
5004 }
5005
5006 static void
5007 dbus_connection_changed_cb (NMBusManager *dbus_mgr,
5008                             GDBusConnection *connection,
5009                             gpointer user_data)
5010 {
5011         _set_prop_filter (NM_MANAGER (user_data), connection);
5012 }
5013
5014 /**********************************************************************/
5015
5016 NM_DEFINE_SINGLETON_REGISTER (NMManager);
5017
5018 NMManager *
5019 nm_manager_get (void)
5020 {
5021         g_return_val_if_fail (singleton_instance, NULL);
5022         return singleton_instance;
5023 }
5024
5025 NMConnectionProvider *
5026 nm_connection_provider_get (void)
5027 {
5028         NMConnectionProvider *p;
5029
5030         g_return_val_if_fail (singleton_instance, NULL);
5031
5032         p = NM_CONNECTION_PROVIDER (NM_MANAGER_GET_PRIVATE (singleton_instance)->settings);
5033         g_return_val_if_fail (p, NULL);
5034         return p;
5035 }
5036
5037 NMManager *
5038 nm_manager_setup (const char *state_file,
5039                   gboolean initial_net_enabled,
5040                   gboolean initial_wifi_enabled,
5041                   gboolean initial_wwan_enabled)
5042 {
5043         NMManager *self;
5044
5045         g_return_val_if_fail (!singleton_instance, singleton_instance);
5046
5047         self = g_object_new (NM_TYPE_MANAGER,
5048                              NM_MANAGER_NETWORKING_ENABLED, initial_net_enabled,
5049                              NM_MANAGER_WIRELESS_ENABLED, initial_wifi_enabled,
5050                              NM_MANAGER_WWAN_ENABLED, initial_wwan_enabled,
5051                              NM_MANAGER_STATE_FILE, state_file,
5052                              NULL);
5053         nm_assert (NM_IS_MANAGER (self));
5054         singleton_instance = self;
5055
5056         nm_singleton_instance_register ();
5057         _LOGD (LOGD_CORE, "setup %s singleton (%p)", "NMManager", singleton_instance);
5058
5059         nm_exported_object_export ((NMExportedObject *) self);
5060
5061         return self;
5062 }
5063
5064 static void
5065 constructed (GObject *object)
5066 {
5067         NMManager *self = NM_MANAGER (object);
5068         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
5069         NMConfigData *config_data;
5070
5071         G_OBJECT_CLASS (nm_manager_parent_class)->constructed (object);
5072
5073         _set_prop_filter (self, nm_bus_manager_get_connection (priv->dbus_mgr));
5074
5075         priv->settings = nm_settings_new ();
5076         g_signal_connect (priv->settings, "notify::" NM_SETTINGS_STARTUP_COMPLETE,
5077                           G_CALLBACK (settings_startup_complete_changed), self);
5078         g_signal_connect (priv->settings, "notify::" NM_SETTINGS_UNMANAGED_SPECS,
5079                           G_CALLBACK (system_unmanaged_devices_changed_cb), self);
5080         g_signal_connect (priv->settings, "notify::" NM_SETTINGS_HOSTNAME,
5081                           G_CALLBACK (system_hostname_changed_cb), self);
5082         g_signal_connect (priv->settings, NM_SETTINGS_SIGNAL_CONNECTION_ADDED,
5083                           G_CALLBACK (connection_changed), self);
5084         g_signal_connect (priv->settings, NM_SETTINGS_SIGNAL_CONNECTION_UPDATED_BY_USER,
5085                           G_CALLBACK (connection_changed), self);
5086         g_signal_connect (priv->settings, NM_SETTINGS_SIGNAL_CONNECTION_REMOVED,
5087                           G_CALLBACK (connection_removed), self);
5088
5089         priv->policy = nm_policy_new (self, priv->settings);
5090         g_signal_connect (priv->policy, "notify::" NM_POLICY_DEFAULT_IP4_DEVICE,
5091                           G_CALLBACK (policy_default_device_changed), self);
5092         g_signal_connect (priv->policy, "notify::" NM_POLICY_DEFAULT_IP6_DEVICE,
5093                           G_CALLBACK (policy_default_device_changed), self);
5094         g_signal_connect (priv->policy, "notify::" NM_POLICY_ACTIVATING_IP4_DEVICE,
5095                           G_CALLBACK (policy_activating_device_changed), self);
5096         g_signal_connect (priv->policy, "notify::" NM_POLICY_ACTIVATING_IP6_DEVICE,
5097                           G_CALLBACK (policy_activating_device_changed), self);
5098
5099         priv->config = g_object_ref (nm_config_get ());
5100         g_signal_connect (G_OBJECT (priv->config),
5101                           NM_CONFIG_SIGNAL_CONFIG_CHANGED,
5102                           G_CALLBACK (_config_changed_cb),
5103                           self);
5104
5105         config_data = nm_config_get_data (priv->config);
5106         priv->connectivity = nm_connectivity_new (nm_config_data_get_connectivity_uri (config_data),
5107                                                   nm_config_data_get_connectivity_interval (config_data),
5108                                                   nm_config_data_get_connectivity_response (config_data));
5109         g_signal_connect (priv->connectivity, "notify::" NM_CONNECTIVITY_STATE,
5110                           G_CALLBACK (connectivity_changed), self);
5111
5112         priv->rfkill_mgr = nm_rfkill_manager_new ();
5113         g_signal_connect (priv->rfkill_mgr,
5114                           "rfkill-changed",
5115                           G_CALLBACK (rfkill_manager_rfkill_changed_cb),
5116                           self);
5117
5118         /* Force kernel WiFi/WWAN rfkill state to follow NM saved WiFi/WWAN state
5119          * in case the BIOS doesn't save rfkill state, and to be consistent with user
5120          * changes to the WirelessEnabled/WWANEnabled properties which toggle kernel
5121          * rfkill.
5122          */
5123         rfkill_change (priv->radio_states[RFKILL_TYPE_WLAN].desc, RFKILL_TYPE_WLAN, priv->radio_states[RFKILL_TYPE_WLAN].user_enabled);
5124         rfkill_change (priv->radio_states[RFKILL_TYPE_WWAN].desc, RFKILL_TYPE_WWAN, priv->radio_states[RFKILL_TYPE_WWAN].user_enabled);
5125 }
5126
5127 static void
5128 nm_manager_init (NMManager *self)
5129 {
5130         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
5131         guint i;
5132         GFile *file;
5133
5134         /* Initialize rfkill structures and states */
5135         memset (priv->radio_states, 0, sizeof (priv->radio_states));
5136
5137         priv->radio_states[RFKILL_TYPE_WLAN].user_enabled = TRUE;
5138         priv->radio_states[RFKILL_TYPE_WLAN].key = "WirelessEnabled";
5139         priv->radio_states[RFKILL_TYPE_WLAN].prop = NM_MANAGER_WIRELESS_ENABLED;
5140         priv->radio_states[RFKILL_TYPE_WLAN].hw_prop = NM_MANAGER_WIRELESS_HARDWARE_ENABLED;
5141         priv->radio_states[RFKILL_TYPE_WLAN].desc = "WiFi";
5142         priv->radio_states[RFKILL_TYPE_WLAN].rtype = RFKILL_TYPE_WLAN;
5143
5144         priv->radio_states[RFKILL_TYPE_WWAN].user_enabled = TRUE;
5145         priv->radio_states[RFKILL_TYPE_WWAN].key = "WWANEnabled";
5146         priv->radio_states[RFKILL_TYPE_WWAN].prop = NM_MANAGER_WWAN_ENABLED;
5147         priv->radio_states[RFKILL_TYPE_WWAN].hw_prop = NM_MANAGER_WWAN_HARDWARE_ENABLED;
5148         priv->radio_states[RFKILL_TYPE_WWAN].desc = "WWAN";
5149         priv->radio_states[RFKILL_TYPE_WWAN].rtype = RFKILL_TYPE_WWAN;
5150
5151         for (i = 0; i < RFKILL_TYPE_MAX; i++)
5152                 priv->radio_states[i].hw_enabled = TRUE;
5153
5154         priv->sleeping = FALSE;
5155         priv->state = NM_STATE_DISCONNECTED;
5156         priv->startup = TRUE;
5157
5158         priv->dbus_mgr = g_object_ref (nm_bus_manager_get ());
5159         g_signal_connect (priv->dbus_mgr,
5160                           NM_BUS_MANAGER_DBUS_CONNECTION_CHANGED,
5161                           G_CALLBACK (dbus_connection_changed_cb),
5162                           self);
5163
5164         /* sleep/wake handling */
5165         priv->sleep_monitor = g_object_ref (nm_sleep_monitor_get ());
5166         g_signal_connect (priv->sleep_monitor, NM_SLEEP_MONITOR_SLEEPING,
5167                           G_CALLBACK (sleeping_cb), self);
5168         g_signal_connect (priv->sleep_monitor, NM_SLEEP_MONITOR_RESUMING,
5169                           G_CALLBACK (resuming_cb), self);
5170
5171         /* Listen for authorization changes */
5172         g_signal_connect (nm_auth_manager_get (),
5173                           NM_AUTH_MANAGER_SIGNAL_CHANGED,
5174                           G_CALLBACK (authority_changed_cb),
5175                           self);
5176
5177
5178         /* Monitor the firmware directory */
5179         if (strlen (KERNEL_FIRMWARE_DIR)) {
5180                 file = g_file_new_for_path (KERNEL_FIRMWARE_DIR "/");
5181                 priv->fw_monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
5182                 g_object_unref (file);
5183         }
5184
5185         if (priv->fw_monitor) {
5186                 g_signal_connect (priv->fw_monitor, "changed",
5187                                   G_CALLBACK (firmware_dir_changed),
5188                                   self);
5189                 _LOGI (LOGD_CORE, "monitoring kernel firmware directory '%s'.",
5190                              KERNEL_FIRMWARE_DIR);
5191         } else {
5192                 _LOGW (LOGD_CORE, "failed to monitor kernel firmware directory '%s'.",
5193                        KERNEL_FIRMWARE_DIR);
5194         }
5195
5196         /* Update timestamps in active connections */
5197         priv->timestamp_update_id = g_timeout_add_seconds (300, (GSourceFunc) periodic_update_active_connection_timestamps, self);
5198
5199         priv->metered = NM_METERED_UNKNOWN;
5200 }
5201
5202 static gboolean
5203 device_is_real (GObject *device, gpointer user_data)
5204 {
5205         return nm_device_is_real (NM_DEVICE (device));
5206 }
5207
5208 static void
5209 get_property (GObject *object, guint prop_id,
5210               GValue *value, GParamSpec *pspec)
5211 {
5212         NMManager *self = NM_MANAGER (object);
5213         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
5214         NMConfigData *config_data;
5215         const NMGlobalDnsConfig *dns_config;
5216         const char *type;
5217
5218         switch (prop_id) {
5219         case PROP_VERSION:
5220                 g_value_set_string (value, VERSION);
5221                 break;
5222         case PROP_STATE:
5223                 nm_manager_update_state (self);
5224                 g_value_set_uint (value, priv->state);
5225                 break;
5226         case PROP_STARTUP:
5227                 g_value_set_boolean (value, priv->startup);
5228                 break;
5229         case PROP_NETWORKING_ENABLED:
5230                 g_value_set_boolean (value, priv->net_enabled);
5231                 break;
5232         case PROP_WIRELESS_ENABLED:
5233                 g_value_set_boolean (value, radio_enabled_for_type (self, RFKILL_TYPE_WLAN, TRUE));
5234                 break;
5235         case PROP_WIRELESS_HARDWARE_ENABLED:
5236                 g_value_set_boolean (value, priv->radio_states[RFKILL_TYPE_WLAN].hw_enabled);
5237                 break;
5238         case PROP_WWAN_ENABLED:
5239                 g_value_set_boolean (value, radio_enabled_for_type (self, RFKILL_TYPE_WWAN, TRUE));
5240                 break;
5241         case PROP_WWAN_HARDWARE_ENABLED:
5242                 g_value_set_boolean (value, priv->radio_states[RFKILL_TYPE_WWAN].hw_enabled);
5243                 break;
5244         case PROP_WIMAX_ENABLED:
5245                 g_value_set_boolean (value, FALSE);
5246                 break;
5247         case PROP_WIMAX_HARDWARE_ENABLED:
5248                 g_value_set_boolean (value, FALSE);
5249                 break;
5250         case PROP_ACTIVE_CONNECTIONS:
5251                 nm_utils_g_value_set_object_path_array (value, priv->active_connections, NULL, NULL);
5252                 break;
5253         case PROP_CONNECTIVITY:
5254                 g_value_set_uint (value, nm_connectivity_get_state (priv->connectivity));
5255                 break;
5256         case PROP_PRIMARY_CONNECTION:
5257                 nm_utils_g_value_set_object_path (value, priv->primary_connection);
5258                 break;
5259         case PROP_PRIMARY_CONNECTION_TYPE:
5260                 type = NULL;
5261                 if (priv->primary_connection) {
5262                         NMConnection *con;
5263
5264                         con = nm_active_connection_get_applied_connection (priv->primary_connection);
5265                         if (con)
5266                                 type = nm_connection_get_connection_type (con);
5267                 }
5268                 g_value_set_string (value, type ? type : "");
5269                 break;
5270         case PROP_ACTIVATING_CONNECTION:
5271                 nm_utils_g_value_set_object_path (value, priv->activating_connection);
5272                 break;
5273         case PROP_HOSTNAME:
5274                 g_value_set_string (value, priv->hostname);
5275                 break;
5276         case PROP_SLEEPING:
5277                 g_value_set_boolean (value, priv->sleeping);
5278                 break;
5279         case PROP_DEVICES:
5280                 nm_utils_g_value_set_object_path_array (value, priv->devices, device_is_real, NULL);
5281                 break;
5282         case PROP_METERED:
5283                 g_value_set_uint (value, priv->metered);
5284                 break;
5285         case PROP_GLOBAL_DNS_CONFIGURATION:
5286                 config_data = nm_config_get_data (priv->config);
5287                 dns_config = nm_config_data_get_global_dns_config (config_data);
5288                 nm_global_dns_config_to_dbus (dns_config, value);
5289                 break;
5290         case PROP_ALL_DEVICES:
5291                 nm_utils_g_value_set_object_path_array (value, priv->devices, NULL, NULL);
5292                 break;
5293         default:
5294                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
5295                 break;
5296         }
5297 }
5298
5299 static void
5300 set_property (GObject *object, guint prop_id,
5301               const GValue *value, GParamSpec *pspec)
5302 {
5303         NMManager *self = NM_MANAGER (object);
5304         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
5305         NMGlobalDnsConfig *dns_config;
5306         GError *error = NULL;
5307
5308         switch (prop_id) {
5309         case PROP_STATE_FILE:
5310                 /* construct-only */
5311                 priv->state_file = g_value_dup_string (value);
5312                 break;
5313         case PROP_NETWORKING_ENABLED:
5314                 /* construct-only */
5315                 priv->net_enabled = g_value_get_boolean (value);
5316                 break;
5317         case PROP_WIRELESS_ENABLED:
5318                 if (!priv->rfkill_mgr) {
5319                         /* called during object construction. */
5320                         priv->radio_states[RFKILL_TYPE_WLAN].user_enabled = g_value_get_boolean (value);
5321                 } else {
5322                         manager_radio_user_toggled (NM_MANAGER (object),
5323                                                     &priv->radio_states[RFKILL_TYPE_WLAN],
5324                                                     g_value_get_boolean (value));
5325                 }
5326                 break;
5327         case PROP_WWAN_ENABLED:
5328                 if (!priv->rfkill_mgr) {
5329                         /* called during object construction. */
5330                         priv->radio_states[RFKILL_TYPE_WWAN].user_enabled = g_value_get_boolean (value);
5331                 } else {
5332                         manager_radio_user_toggled (NM_MANAGER (object),
5333                                                     &priv->radio_states[RFKILL_TYPE_WWAN],
5334                                                     g_value_get_boolean (value));
5335                 }
5336                 break;
5337         case PROP_WIMAX_ENABLED:
5338                 /* WIMAX is depreacted. This does nothing. */
5339                 break;
5340         case PROP_GLOBAL_DNS_CONFIGURATION:
5341                 dns_config = nm_global_dns_config_from_dbus (value, &error);
5342                 if (!error)
5343                         nm_config_set_global_dns (priv->config, dns_config, &error);
5344
5345                 nm_global_dns_config_free (dns_config);
5346
5347                 if (error) {
5348                         _LOGD (LOGD_CORE, "set global DNS failed with error: %s", error->message);
5349                         g_error_free (error);
5350                 }
5351                 break;
5352         default:
5353                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
5354                 break;
5355         }
5356 }
5357
5358 static void
5359 _deinit_device_factory (NMDeviceFactory *factory, gpointer user_data)
5360 {
5361         g_signal_handlers_disconnect_matched (factory, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, NM_MANAGER (user_data));
5362 }
5363
5364 static void
5365 dispose (GObject *object)
5366 {
5367         NMManager *manager = NM_MANAGER (object);
5368         NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
5369
5370         g_slist_free_full (priv->auth_chains, (GDestroyNotify) nm_auth_chain_unref);
5371         priv->auth_chains = NULL;
5372
5373         g_signal_handlers_disconnect_by_func (nm_auth_manager_get (),
5374                                               G_CALLBACK (authority_changed_cb),
5375                                               manager);
5376
5377         g_assert (priv->devices == NULL);
5378
5379         nm_clear_g_source (&priv->ac_cleanup_id);
5380
5381         while (priv->active_connections)
5382                 active_connection_remove (manager, NM_ACTIVE_CONNECTION (priv->active_connections->data));
5383         g_clear_pointer (&priv->active_connections, g_slist_free);
5384         g_clear_object (&priv->primary_connection);
5385         g_clear_object (&priv->activating_connection);
5386
5387         if (priv->config) {
5388                 g_signal_handlers_disconnect_by_func (priv->config, _config_changed_cb, manager);
5389                 g_clear_object (&priv->config);
5390         }
5391         if (priv->connectivity) {
5392                 g_signal_handlers_disconnect_by_func (priv->connectivity, connectivity_changed, manager);
5393                 g_clear_object (&priv->connectivity);
5394         }
5395
5396         g_free (priv->hostname);
5397
5398         if (priv->policy) {
5399                 g_signal_handlers_disconnect_by_func (priv->policy, policy_default_device_changed, manager);
5400                 g_signal_handlers_disconnect_by_func (priv->policy, policy_activating_device_changed, manager);
5401                 g_clear_object (&priv->policy);
5402         }
5403
5404         if (priv->settings) {
5405                 g_signal_handlers_disconnect_by_func (priv->settings, settings_startup_complete_changed, manager);
5406                 g_signal_handlers_disconnect_by_func (priv->settings, system_unmanaged_devices_changed_cb, manager);
5407                 g_signal_handlers_disconnect_by_func (priv->settings, system_hostname_changed_cb, manager);
5408                 g_signal_handlers_disconnect_by_func (priv->settings, connection_changed, manager);
5409                 g_signal_handlers_disconnect_by_func (priv->settings, connection_removed, manager);
5410                 g_clear_object (&priv->settings);
5411         }
5412
5413         g_clear_pointer (&priv->state_file, g_free);
5414         g_clear_object (&priv->vpn_manager);
5415
5416         /* Unregister property filter */
5417         if (priv->dbus_mgr) {
5418                 g_signal_handlers_disconnect_by_func (priv->dbus_mgr, dbus_connection_changed_cb, manager);
5419                 g_clear_object (&priv->dbus_mgr);
5420         }
5421         _set_prop_filter (manager, NULL);
5422
5423         if (priv->sleep_monitor) {
5424                 g_signal_handlers_disconnect_by_func (priv->sleep_monitor, sleeping_cb, manager);
5425                 g_signal_handlers_disconnect_by_func (priv->sleep_monitor, resuming_cb, manager);
5426                 g_clear_object (&priv->sleep_monitor);
5427         }
5428
5429         if (priv->fw_monitor) {
5430                 g_signal_handlers_disconnect_by_func (priv->fw_monitor, firmware_dir_changed, manager);
5431
5432                 nm_clear_g_source (&priv->fw_changed_id);
5433
5434                 g_file_monitor_cancel (priv->fw_monitor);
5435                 g_clear_object (&priv->fw_monitor);
5436         }
5437
5438         if (priv->rfkill_mgr) {
5439                 g_signal_handlers_disconnect_by_func (priv->rfkill_mgr, rfkill_manager_rfkill_changed_cb, manager);
5440                 g_clear_object (&priv->rfkill_mgr);
5441         }
5442
5443         nm_device_factory_manager_for_each_factory (_deinit_device_factory, manager);
5444
5445         nm_clear_g_source (&priv->timestamp_update_id);
5446
5447         G_OBJECT_CLASS (nm_manager_parent_class)->dispose (object);
5448 }
5449
5450 static void
5451 nm_manager_class_init (NMManagerClass *manager_class)
5452 {
5453         GObjectClass *object_class = G_OBJECT_CLASS (manager_class);
5454         NMExportedObjectClass *exported_object_class = NM_EXPORTED_OBJECT_CLASS (manager_class);
5455
5456         g_type_class_add_private (manager_class, sizeof (NMManagerPrivate));
5457
5458         exported_object_class->export_path = NM_DBUS_PATH;
5459
5460         /* virtual methods */
5461         object_class->constructed = constructed;
5462         object_class->set_property = set_property;
5463         object_class->get_property = get_property;
5464         object_class->dispose = dispose;
5465
5466         /* properties */
5467         g_object_class_install_property
5468                 (object_class, PROP_VERSION,
5469                  g_param_spec_string (NM_MANAGER_VERSION, "", "",
5470                                       NULL,
5471                                       G_PARAM_READABLE |
5472                                       G_PARAM_STATIC_STRINGS));
5473
5474         g_object_class_install_property (object_class,
5475                                          PROP_STATE_FILE,
5476                                          g_param_spec_string (NM_MANAGER_STATE_FILE, "", "",
5477                                                               NULL,
5478                                                               G_PARAM_WRITABLE |
5479                                                               G_PARAM_CONSTRUCT_ONLY |
5480                                                               G_PARAM_STATIC_STRINGS));
5481
5482         g_object_class_install_property
5483                 (object_class, PROP_STATE,
5484                  g_param_spec_uint (NM_MANAGER_STATE, "", "",
5485                                     0, NM_STATE_DISCONNECTED, 0,
5486                                     G_PARAM_READABLE |
5487                                     G_PARAM_STATIC_STRINGS));
5488
5489         g_object_class_install_property
5490                 (object_class, PROP_STARTUP,
5491                  g_param_spec_boolean (NM_MANAGER_STARTUP, "", "",
5492                                        TRUE,
5493                                        G_PARAM_READABLE |
5494                                        G_PARAM_STATIC_STRINGS));
5495
5496         g_object_class_install_property
5497                 (object_class, PROP_NETWORKING_ENABLED,
5498                  g_param_spec_boolean (NM_MANAGER_NETWORKING_ENABLED, "", "",
5499                                        TRUE,
5500                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
5501                                        G_PARAM_STATIC_STRINGS));
5502
5503         g_object_class_install_property
5504                 (object_class, PROP_WIRELESS_ENABLED,
5505                  g_param_spec_boolean (NM_MANAGER_WIRELESS_ENABLED, "", "",
5506                                        TRUE,
5507                                        G_PARAM_READWRITE |
5508                                        G_PARAM_CONSTRUCT |
5509                                        G_PARAM_STATIC_STRINGS));
5510
5511         g_object_class_install_property
5512                 (object_class, PROP_WIRELESS_HARDWARE_ENABLED,
5513                  g_param_spec_boolean (NM_MANAGER_WIRELESS_HARDWARE_ENABLED, "", "",
5514                                        TRUE,
5515                                        G_PARAM_READABLE |
5516                                        G_PARAM_STATIC_STRINGS));
5517
5518         g_object_class_install_property
5519                 (object_class, PROP_WWAN_ENABLED,
5520                  g_param_spec_boolean (NM_MANAGER_WWAN_ENABLED, "", "",
5521                                        TRUE,
5522                                        G_PARAM_READWRITE |
5523                                        G_PARAM_CONSTRUCT |
5524                                        G_PARAM_STATIC_STRINGS));
5525
5526         g_object_class_install_property
5527                 (object_class, PROP_WWAN_HARDWARE_ENABLED,
5528                  g_param_spec_boolean (NM_MANAGER_WWAN_HARDWARE_ENABLED, "", "",
5529                                        TRUE,
5530                                        G_PARAM_READABLE |
5531                                        G_PARAM_STATIC_STRINGS));
5532
5533         g_object_class_install_property
5534                 (object_class, PROP_WIMAX_ENABLED,
5535                  g_param_spec_boolean (NM_MANAGER_WIMAX_ENABLED, "", "",
5536                                        TRUE,
5537                                        G_PARAM_READWRITE |
5538                                        G_PARAM_STATIC_STRINGS));
5539
5540         g_object_class_install_property
5541                 (object_class, PROP_WIMAX_HARDWARE_ENABLED,
5542                  g_param_spec_boolean (NM_MANAGER_WIMAX_HARDWARE_ENABLED, "", "",
5543                                        TRUE,
5544                                        G_PARAM_READABLE |
5545                                        G_PARAM_STATIC_STRINGS));
5546
5547         g_object_class_install_property
5548                 (object_class, PROP_ACTIVE_CONNECTIONS,
5549                  g_param_spec_boxed (NM_MANAGER_ACTIVE_CONNECTIONS, "", "",
5550                                      G_TYPE_STRV,
5551                                      G_PARAM_READABLE |
5552                                      G_PARAM_STATIC_STRINGS));
5553
5554         g_object_class_install_property
5555                 (object_class, PROP_CONNECTIVITY,
5556                  g_param_spec_uint (NM_MANAGER_CONNECTIVITY, "", "",
5557                                     NM_CONNECTIVITY_UNKNOWN, NM_CONNECTIVITY_FULL, NM_CONNECTIVITY_UNKNOWN,
5558                                     G_PARAM_READABLE |
5559                                     G_PARAM_STATIC_STRINGS));
5560
5561         g_object_class_install_property
5562                 (object_class, PROP_PRIMARY_CONNECTION,
5563                  g_param_spec_string (NM_MANAGER_PRIMARY_CONNECTION, "", "",
5564                                       NULL,
5565                                       G_PARAM_READABLE |
5566                                       G_PARAM_STATIC_STRINGS));
5567
5568         g_object_class_install_property
5569                 (object_class, PROP_PRIMARY_CONNECTION_TYPE,
5570                  g_param_spec_string (NM_MANAGER_PRIMARY_CONNECTION_TYPE, "", "",
5571                                       NULL,
5572                                       G_PARAM_READABLE |
5573                                       G_PARAM_STATIC_STRINGS));
5574
5575
5576         g_object_class_install_property
5577                 (object_class, PROP_ACTIVATING_CONNECTION,
5578                  g_param_spec_string (NM_MANAGER_ACTIVATING_CONNECTION, "", "",
5579                                       NULL,
5580                                       G_PARAM_READABLE |
5581                                       G_PARAM_STATIC_STRINGS));
5582
5583         /* Hostname is not exported over D-Bus */
5584         g_object_class_install_property
5585                 (object_class, PROP_HOSTNAME,
5586                  g_param_spec_string (NM_MANAGER_HOSTNAME, "", "",
5587                                       NULL,
5588                                       G_PARAM_READABLE |
5589                                       G_PARAM_STATIC_STRINGS));
5590
5591         /* Sleeping is not exported over D-Bus */
5592         g_object_class_install_property
5593                 (object_class, PROP_SLEEPING,
5594                  g_param_spec_boolean (NM_MANAGER_SLEEPING, "", "",
5595                                        FALSE,
5596                                        G_PARAM_READABLE |
5597                                        G_PARAM_STATIC_STRINGS));
5598
5599         g_object_class_install_property
5600                 (object_class, PROP_DEVICES,
5601                  g_param_spec_boxed (NM_MANAGER_DEVICES, "", "",
5602                                      G_TYPE_STRV,
5603                                      G_PARAM_READABLE |
5604                                      G_PARAM_STATIC_STRINGS));
5605
5606         /**
5607          * NMManager:metered:
5608          *
5609          * Whether the connectivity is metered.
5610          *
5611          * Since: 1.2
5612          **/
5613         g_object_class_install_property
5614                 (object_class, PROP_METERED,
5615                  g_param_spec_uint (NM_MANAGER_METERED, "", "",
5616                                     0, G_MAXUINT32, NM_METERED_UNKNOWN,
5617                                     G_PARAM_READABLE |
5618                                     G_PARAM_STATIC_STRINGS));
5619
5620         /**
5621          * NMManager:global-dns-configuration:
5622          *
5623          * The global DNS configuration.
5624          *
5625          * Since: 1.2
5626          **/
5627         g_object_class_install_property
5628                 (object_class, PROP_GLOBAL_DNS_CONFIGURATION,
5629                  g_param_spec_variant (NM_MANAGER_GLOBAL_DNS_CONFIGURATION, "", "",
5630                                        G_VARIANT_TYPE ("a{sv}"),
5631                                        NULL,
5632                                        G_PARAM_READWRITE |
5633                                        G_PARAM_STATIC_STRINGS));
5634
5635         /**
5636          * NMManager:all-devices:
5637          *
5638          * All devices, including those that are not realized.
5639          *
5640          * Since: 1.2
5641          **/
5642         g_object_class_install_property
5643                 (object_class, PROP_ALL_DEVICES,
5644                  g_param_spec_boxed (NM_MANAGER_ALL_DEVICES, "", "",
5645                                      G_TYPE_STRV,
5646                                      G_PARAM_READABLE |
5647                                      G_PARAM_STATIC_STRINGS));
5648
5649         /* signals */
5650
5651         /* D-Bus exported; emitted only for realized devices */
5652         signals[DEVICE_ADDED] =
5653                 g_signal_new ("device-added",
5654                               G_OBJECT_CLASS_TYPE (object_class),
5655                               G_SIGNAL_RUN_FIRST,
5656                               G_STRUCT_OFFSET (NMManagerClass, device_added),
5657                               NULL, NULL, NULL,
5658                               G_TYPE_NONE, 1, NM_TYPE_DEVICE);
5659
5660         /* Emitted for both realized devices and placeholder devices */
5661         signals[INTERNAL_DEVICE_ADDED] =
5662                 g_signal_new ("internal-device-added",
5663                               G_OBJECT_CLASS_TYPE (object_class),
5664                               G_SIGNAL_RUN_FIRST, 0,
5665                               NULL, NULL, NULL,
5666                               G_TYPE_NONE, 1, G_TYPE_OBJECT);
5667
5668         /* D-Bus exported; emitted only for realized devices */
5669         signals[DEVICE_REMOVED] =
5670                 g_signal_new ("device-removed",
5671                               G_OBJECT_CLASS_TYPE (object_class),
5672                               G_SIGNAL_RUN_FIRST,
5673                               G_STRUCT_OFFSET (NMManagerClass, device_removed),
5674                               NULL, NULL, NULL,
5675                               G_TYPE_NONE, 1, NM_TYPE_DEVICE);
5676
5677         /* Emitted for both realized devices and placeholder devices */
5678         signals[INTERNAL_DEVICE_REMOVED] =
5679                 g_signal_new ("internal-device-removed",
5680                               G_OBJECT_CLASS_TYPE (object_class),
5681                               G_SIGNAL_RUN_FIRST, 0,
5682                               NULL, NULL, NULL,
5683                               G_TYPE_NONE, 1, G_TYPE_OBJECT);
5684
5685         signals[STATE_CHANGED] =
5686                 g_signal_new (NM_MANAGER_STATE_CHANGED,
5687                               G_OBJECT_CLASS_TYPE (object_class),
5688                               G_SIGNAL_RUN_FIRST,
5689                               G_STRUCT_OFFSET (NMManagerClass, state_changed),
5690                               NULL, NULL, NULL,
5691                               G_TYPE_NONE, 1, G_TYPE_UINT);
5692
5693         signals[CHECK_PERMISSIONS] =
5694                 g_signal_new ("check-permissions",
5695                               G_OBJECT_CLASS_TYPE (object_class),
5696                               G_SIGNAL_RUN_FIRST,
5697                               0, NULL, NULL, NULL,
5698                               G_TYPE_NONE, 0);
5699
5700         signals[USER_PERMISSIONS_CHANGED] =
5701                 g_signal_new ("user-permissions-changed",
5702                               G_OBJECT_CLASS_TYPE (object_class),
5703                               G_SIGNAL_RUN_FIRST,
5704                               0, NULL, NULL, NULL,
5705                               G_TYPE_NONE, 0);
5706
5707         signals[ACTIVE_CONNECTION_ADDED] =
5708                 g_signal_new (NM_MANAGER_ACTIVE_CONNECTION_ADDED,
5709                               G_OBJECT_CLASS_TYPE (object_class),
5710                               G_SIGNAL_RUN_FIRST,
5711                               0, NULL, NULL, NULL,
5712                               G_TYPE_NONE, 1, NM_TYPE_ACTIVE_CONNECTION);
5713
5714         signals[ACTIVE_CONNECTION_REMOVED] =
5715                 g_signal_new (NM_MANAGER_ACTIVE_CONNECTION_REMOVED,
5716                               G_OBJECT_CLASS_TYPE (object_class),
5717                               G_SIGNAL_RUN_FIRST,
5718                               0, NULL, NULL, NULL,
5719                               G_TYPE_NONE, 1, NM_TYPE_ACTIVE_CONNECTION);
5720
5721         signals[CONFIGURE_QUIT] =
5722                 g_signal_new (NM_MANAGER_CONFIGURE_QUIT,
5723                               G_OBJECT_CLASS_TYPE (object_class),
5724                               G_SIGNAL_RUN_FIRST,
5725                               0, NULL, NULL, NULL,
5726                               G_TYPE_NONE, 0);
5727
5728         nm_exported_object_class_add_interface (NM_EXPORTED_OBJECT_CLASS (manager_class),
5729                                                 NMDBUS_TYPE_MANAGER_SKELETON,
5730                                                 "GetDevices", impl_manager_get_devices,
5731                                                 "GetAllDevices", impl_manager_get_all_devices,
5732                                                 "GetDeviceByIpIface", impl_manager_get_device_by_ip_iface,
5733                                                 "ActivateConnection", impl_manager_activate_connection,
5734                                                 "AddAndActivateConnection", impl_manager_add_and_activate_connection,
5735                                                 "DeactivateConnection", impl_manager_deactivate_connection,
5736                                                 "Sleep", impl_manager_sleep,
5737                                                 "Enable", impl_manager_enable,
5738                                                 "GetPermissions", impl_manager_get_permissions,
5739                                                 "SetLogging", impl_manager_set_logging,
5740                                                 "GetLogging", impl_manager_get_logging,
5741                                                 "CheckConnectivity", impl_manager_check_connectivity,
5742                                                 "state", impl_manager_get_state,
5743                                                 NULL);
5744 }
5745