systemd-fallback.patch

   1 --- NetworkManager-1.0.0/configure.ac.orig      2014-12-19 23:27:36.133692361 +0100
   2 +++ NetworkManager-1.0.0/configure.ac   2014-12-19 23:29:57.159595024 +0100
   3 @@ -348,7 +348,7 @@ AM_CONDITIONAL(SESSION_TRACKING_CK, test
   4  AM_CONDITIONAL(SESSION_TRACKING_SYSTEMD, test "$with_session_tracking" = "systemd")
   5  if test "$with_session_tracking" = "systemd"; then
   6         PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd],,
   7 -                         [PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd-login])])
   8 +                         [PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd-daemon libsystemd-login])])
   9         AC_SUBST(SYSTEMD_LOGIN_CFLAGS)
  10         AC_SUBST(SYSTEMD_LOGIN_LIBS)
  11  fi
  12 --- NetworkManager-1.0.0/src/nm-session-monitor-systemd.c.orig  2014-12-11 22:28:51.000000000 +0100
  13 +++ NetworkManager-1.0.0/src/nm-session-monitor-systemd.c       2014-12-21 11:30:09.859311469 +0100
  14 @@ -29,10 +29,14 @@
  15  #include <glib/gstdio.h>
  16  #include <systemd/sd-login.h>
  17  #include <stdlib.h>
  18 +#include <systemd/sd-daemon.h>
  19 +#include <sys/stat.h>
  20 +#include <gio/gio.h>
  21
  22  #include "nm-session-utils.h"
  23  #include "nm-session-monitor.h"
  24  #include "nm-logging.h"
  25 +#include "nm-errors.h"
  26
  27  /********************************************************************/
  28
  29 @@ -109,10 +113,18 @@ sd_source_new (void)
  30         return source;
  31  }
  32
  33 +#define CKDB_PATH "/var/run/ConsoleKit/database"
  34 +
  35  struct _NMSessionMonitor {
  36         GObject parent_instance;
  37
  38         GSource *sd_source;
  39 +
  40 +       GKeyFile *database;
  41 +       GFileMonitor *database_monitor;
  42 +       time_t database_mtime;
  43 +       GHashTable *sessions_by_uid;
  44 +       GHashTable *sessions_by_user;
  45  };
  46
  47  struct _NMSessionMonitorClass {
  48 @@ -132,6 +144,215 @@ G_DEFINE_TYPE (NMSessionMonitor, nm_sess
  49
  50  /* ---------------------------------------------------------------------------------------------------- */
  51
  52 +typedef struct {
  53 +       char *user;
  54 +       uid_t uid;
  55 +       gboolean local;
  56 +       gboolean active;
  57 +} Session;
  58 +
  59 +static void
  60 +session_free (Session *s)
  61 +{
  62 +       g_free (s->user);
  63 +       memset (s, 0, sizeof (Session));
  64 +       g_free (s);
  65 +}
  66 +
  67 +static gboolean
  68 +check_key (GKeyFile *keyfile, const char *group, const char *key, GError **error)
  69 +{
  70 +       if (g_key_file_has_key (keyfile, group, key, error))
  71 +               return TRUE;
  72 +
  73 +       if (!error) {
  74 +               g_set_error (error,
  75 +                                NM_MANAGER_ERROR,
  76 +                                NM_MANAGER_ERROR_FAILED,
  77 +                                "ConsoleKit database " CKDB_PATH " group '%s' had no '%s' key",
  78 +                                group, key);
  79 +       }
  80 +       return FALSE;
  81 +}
  82 +
  83 +static Session *
  84 +session_new (GKeyFile *keyfile, const char *group, GError **error)
  85 +{
  86 +       GError *local = NULL;
  87 +       Session *s;
  88 +       const char *uname = NULL;
  89 +
  90 +       s = g_new0 (Session, 1);
  91 +       g_assert (s);
  92 +
  93 +       s->uid = G_MAXUINT; /* paranoia */
  94 +       if (!check_key (keyfile, group, "uid", &local))
  95 +               goto error;
  96 +       s->uid = (uid_t) g_key_file_get_integer (keyfile, group, "uid", &local);
  97 +       if (local)
  98 +               goto error;
  99 +
 100 +       if (!check_key (keyfile, group, "is_active", &local))
 101 +               goto error;
 102 +       s->active = g_key_file_get_boolean (keyfile, group, "is_active", &local);
 103 +       if (local)
 104 +               goto error;
 105 +
 106 +       if (!check_key (keyfile, group, "is_local", &local))
 107 +               goto error;
 108 +       s->local = g_key_file_get_boolean (keyfile, group, "is_local", &local);
 109 +       if (local)
 110 +               goto error;
 111 +
 112 +       if (!nm_session_uid_to_user (s->uid, &uname, error))
 113 +               return FALSE;
 114 +       s->user = g_strdup (uname);
 115 +
 116 +       return s;
 117 +
 118 +error:
 119 +       session_free (s);
 120 +       g_propagate_error (error, local);
 121 +       return NULL;
 122 +}
 123 +
 124 +static void
 125 +session_merge (Session *src, Session *dest)
 126 +{
 127 +       g_return_if_fail (src != NULL);
 128 +       g_return_if_fail (dest != NULL);
 129 +
 130 +       g_warn_if_fail (g_strcmp0 (src->user, dest->user) == 0);
 131 +       g_warn_if_fail (src->uid == dest->uid);
 132 +
 133 +       dest->local = (dest->local || src->local);
 134 +       dest->active = (dest->active || src->active);
 135 +}
 136 +
 137 +/********************************************************************/
 138 +
 139 +static void
 140 +free_database (NMSessionMonitor *self)
 141 +{
 142 +       if (self->database != NULL) {
 143 +               g_key_file_free (self->database);
 144 +               self->database = NULL;
 145 +       }
 146 +
 147 +       g_hash_table_remove_all (self->sessions_by_uid);
 148 +       g_hash_table_remove_all (self->sessions_by_user);
 149 +}
 150 +
 151 +static gboolean
 152 +reload_database (NMSessionMonitor *self, GError **error)
 153 +{
 154 +       struct stat statbuf;
 155 +       char **groups = NULL;
 156 +       gsize len = 0, i;
 157 +       Session *s;
 158 +
 159 +       free_database (self);
 160 +
 161 +       errno = 0;
 162 +       if (stat (CKDB_PATH, &statbuf) != 0) {
 163 +               g_set_error (error,
 164 +                            NM_MANAGER_ERROR,
 165 +                            NM_MANAGER_ERROR_FAILED,
 166 +                            "Error statting file " CKDB_PATH ": %s",
 167 +                            strerror (errno));
 168 +               goto error;
 169 +       }
 170 +       self->database_mtime = statbuf.st_mtime;
 171 +
 172 +       self->database = g_key_file_new ();
 173 +       if (!g_key_file_load_from_file (self->database, CKDB_PATH, G_KEY_FILE_NONE, error))
 174 +               goto error;
 175 +
 176 +       groups = g_key_file_get_groups (self->database, &len);
 177 +       if (!groups) {
 178 +               g_set_error_literal (error,
 179 +                                    NM_MANAGER_ERROR,
 180 +                                    NM_MANAGER_ERROR_FAILED,
 181 +                                    "Could not load groups from " CKDB_PATH "");
 182 +               goto error;
 183 +       }
 184 +
 185 +       for (i = 0; i < len; i++) {
 186 +               Session *found;
 187 +
 188 +               if (!g_str_has_prefix (groups[i], "Session "))
 189 +                       continue;
 190 +
 191 +               s = session_new (self->database, groups[i], error);
 192 +               if (!s)
 193 +                       goto error;
 194 +
 195 +               found = g_hash_table_lookup (self->sessions_by_user, (gpointer) s->user);
 196 +               if (found) {
 197 +                       session_merge (s, found);
 198 +                       session_free (s);
 199 +               } else {
 200 +                       /* Entirely new user */
 201 +                       g_hash_table_insert (self->sessions_by_user, (gpointer) s->user, s);
 202 +                       g_hash_table_insert (self->sessions_by_uid, GUINT_TO_POINTER (s->uid), s);
 203 +               }
 204 +       }
 205 +
 206 +       g_strfreev (groups);
 207 +       return TRUE;
 208 +
 209 +error:
 210 +       if (groups)
 211 +               g_strfreev (groups);
 212 +       free_database (self);
 213 +       return FALSE;
 214 +}
 215 +
 216 +static gboolean
 217 +ensure_database (NMSessionMonitor *self, GError **error)
 218 +{
 219 +       gboolean ret = FALSE;
 220 +
 221 +       if (self->database != NULL) {
 222 +               struct stat statbuf;
 223 +
 224 +               errno = 0;
 225 +               if (stat (CKDB_PATH, &statbuf) != 0) {
 226 +                       g_set_error (error,
 227 +                                    NM_MANAGER_ERROR,
 228 +                                    NM_MANAGER_ERROR_FAILED,
 229 +                                    "Error statting file " CKDB_PATH " to check timestamp: %s",
 230 +                                    strerror (errno));
 231 +                       goto out;
 232 +               }
 233 +
 234 +               if (statbuf.st_mtime == self->database_mtime) {
 235 +                       ret = TRUE;
 236 +                       goto out;
 237 +               }
 238 +       }
 239 +
 240 +       ret = reload_database (self, error);
 241 +
 242 +out:
 243 +       return ret;
 244 +}
 245 +
 246 +static void
 247 +on_file_monitor_changed (GFileMonitor *    file_monitor,
 248 +                         GFile *           file,
 249 +                         GFile *           other_file,
 250 +                         GFileMonitorEvent event_type,
 251 +                         gpointer          user_data)
 252 +{
 253 +       NMSessionMonitor *self = NM_SESSION_MONITOR (user_data);
 254 +
 255 +       /* throw away cache */
 256 +       free_database (self);
 257 +
 258 +       g_signal_emit (self, signals[CHANGED_SIGNAL], 0);
 259 +}
 260 +
 261  static gboolean
 262  sessions_changed (gpointer user_data)
 263  {
 264 @@ -145,9 +366,46 @@ sessions_changed (gpointer user_data)
 265  static void
 266  nm_session_monitor_init (NMSessionMonitor *monitor)
 267  {
 268 -       monitor->sd_source = sd_source_new ();
 269 -       g_source_set_callback (monitor->sd_source, sessions_changed, monitor, NULL);
 270 -       g_source_attach (monitor->sd_source, NULL);
 271 +       if (sd_booted () > 0) {
 272 +               monitor->sd_source = sd_source_new ();
 273 +               g_source_set_callback (monitor->sd_source, sessions_changed, monitor, NULL);
 274 +               g_source_attach (monitor->sd_source, NULL);
 275 +
 276 +               monitor->database_monitor = NULL;
 277 +               monitor->database = NULL;
 278 +       } else {
 279 +               GError *error = NULL;
 280 +               GFile *file;
 281 +
 282 +               monitor->sd_source = NULL;
 283 +
 284 +               /* Sessions-by-user is responsible for destroying the Session objects */
 285 +               monitor->sessions_by_user = g_hash_table_new_full (g_str_hash, g_str_equal,
 286 +                                                                   NULL, (GDestroyNotify) session_free);
 287 +               monitor->sessions_by_uid = g_hash_table_new (g_direct_hash, g_direct_equal);
 288 +
 289 +
 290 +               if (!ensure_database (monitor, &error)) {
 291 +                       nm_log_dbg (LOGD_CORE, "Error loading " CKDB_PATH ": %s", error->message);
 292 +
 293 +                       /* Ignore the first error, the CK database might not exist yet */
 294 +                       g_error_free (error);
 295 +                       error = NULL;
 296 +               }
 297 +
 298 +               file = g_file_new_for_path (CKDB_PATH);
 299 +               monitor->database_monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, &error);
 300 +               g_object_unref (file);
 301 +               if (monitor->database_monitor == NULL) {
 302 +                       nm_log_err (LOGD_CORE, "Error monitoring " CKDB_PATH ": %s", error->message);
 303 +                       g_error_free (error);
 304 +               } else {
 305 +                       g_signal_connect (monitor->database_monitor,
 306 +                                             "changed",
 307 +                                             G_CALLBACK (on_file_monitor_changed),
 308 +                                             monitor);
 309 +               }
 310 +       }
 311  }
 312
 313  static void
 314 @@ -155,11 +413,19 @@ nm_session_monitor_finalize (GObject *ob
 315  {
 316         NMSessionMonitor *monitor = NM_SESSION_MONITOR (object);
 317
 318 -       if (monitor->sd_source != NULL) {
 319 -               g_source_destroy (monitor->sd_source);
 320 -               g_source_unref (monitor->sd_source);
 321 +       if (sd_booted () > 0) {
 322 +               if (monitor->sd_source != NULL) {
 323 +                       g_source_destroy (monitor->sd_source);
 324 +                       g_source_unref (monitor->sd_source);
 325 +               }
 326 +       } else {
 327 +               if (monitor->database_monitor != NULL)
 328 +                       g_object_unref (monitor->database_monitor);
 329 +
 330 +               free_database (monitor);
 331         }
 332
 333 +
 334         if (G_OBJECT_CLASS (nm_session_monitor_parent_class)->finalize != NULL)
 335                 G_OBJECT_CLASS (nm_session_monitor_parent_class)->finalize (object);
 336  }
 337 @@ -205,15 +471,36 @@ nm_session_monitor_user_has_session (NMS
 338                                       uid_t *out_uid,
 339                                       GError **error)
 340  {
 341 -       uid_t uid;
 342 +       if (sd_booted () > 0) {
 343 +               uid_t uid;
 344
 345 -       if (!nm_session_user_to_uid (username, &uid, error))
 346 -               return FALSE;
 347 +               if (!nm_session_user_to_uid (username, &uid, error))
 348 +                       return FALSE;
 349
 350 -       if (out_uid)
 351 -               *out_uid = uid;
 352 +               if (out_uid)
 353 +                       *out_uid = uid;
 354
 355 -       return nm_session_monitor_uid_has_session (monitor, uid, NULL, error);
 356 +               return nm_session_monitor_uid_has_session (monitor, uid, NULL, error);
 357 +       } else {
 358 +               Session *s;
 359 +
 360 +               if (!ensure_database (monitor, error))
 361 +                       return FALSE;
 362 +
 363 +               s = g_hash_table_lookup (monitor->sessions_by_user, (gpointer) username);
 364 +               if (!s) {
 365 +                       g_set_error (error,
 366 +                                        NM_MANAGER_ERROR,
 367 +                                        NM_MANAGER_ERROR_FAILED,
 368 +                                        "No session found for user '%s'",
 369 +                                        username);
 370 +                       return FALSE;
 371 +               }
 372 +
 373 +               if (out_uid)
 374 +                       *out_uid = s->uid;
 375 +               return TRUE;
 376 +       }
 377  }
 378
 379  gboolean
 380 @@ -221,12 +508,31 @@ nm_session_monitor_user_active (NMSessio
 381                                  const char *username,
 382                                  GError **error)
 383  {
 384 -       uid_t uid;
 385 +       if (sd_booted () > 0) {
 386 +               uid_t uid;
 387
 388 -       if (!nm_session_user_to_uid (username, &uid, error))
 389 -               return FALSE;
 390 +               if (!nm_session_user_to_uid (username, &uid, error))
 391 +                       return FALSE;
 392 +
 393 +               return nm_session_monitor_uid_active (monitor, uid, error);
 394 +       } else {
 395 +               Session *s;
 396 +
 397 +               if (!ensure_database (monitor, error))
 398 +                       return FALSE;
 399 +
 400 +               s = g_hash_table_lookup (monitor->sessions_by_user, (gpointer) username);
 401 +               if (!s) {
 402 +                       g_set_error (error,
 403 +                                        NM_MANAGER_ERROR,
 404 +                                        NM_MANAGER_ERROR_FAILED,
 405 +                                        "No session found for user '%s'",
 406 +                                        username);
 407 +                       return FALSE;
 408 +               }
 409
 410 -       return nm_session_monitor_uid_active (monitor, uid, error);
 411 +               return s->active;
 412 +       }
 413  }
 414
 415  gboolean
 416 @@ -235,19 +541,40 @@ nm_session_monitor_uid_has_session (NMSe
 417                                      const char **out_user,
 418                                      GError **error)
 419  {
 420 -       int num_sessions;
 421 +       if (sd_booted () > 0) {
 422 +               int num_sessions;
 423
 424 -       if (!nm_session_uid_to_user (uid, out_user, error))
 425 -               return FALSE;
 426 +               if (!nm_session_uid_to_user (uid, out_user, error))
 427 +                       return FALSE;
 428
 429 -       /* Get all sessions (including inactive ones) for the user */
 430 -       num_sessions = sd_uid_get_sessions (uid, 0, NULL);
 431 -       if (num_sessions < 0) {
 432 -               nm_log_warn (LOGD_CORE, "Failed to get systemd sessions for uid %d: %d",
 433 -                            uid, num_sessions);
 434 -               return FALSE;
 435 +               /* Get all sessions (including inactive ones) for the user */
 436 +               num_sessions = sd_uid_get_sessions (uid, 0, NULL);
 437 +               if (num_sessions < 0) {
 438 +                       nm_log_warn (LOGD_CORE, "Failed to get systemd sessions for uid %d: %d",
 439 +                                        uid, num_sessions);
 440 +                       return FALSE;
 441 +               }
 442 +               return num_sessions > 0;
 443 +       } else {
 444 +               Session *s;
 445 +
 446 +               if (!ensure_database (monitor, error))
 447 +                       return FALSE;
 448 +
 449 +               s = g_hash_table_lookup (monitor->sessions_by_uid, GUINT_TO_POINTER (uid));
 450 +               if (!s) {
 451 +                       g_set_error (error,
 452 +                                        NM_MANAGER_ERROR,
 453 +                                        NM_MANAGER_ERROR_FAILED,
 454 +                                        "No session found for uid %d",
 455 +                                        uid);
 456 +                       return FALSE;
 457 +               }
 458 +
 459 +               if (out_user)
 460 +                       *out_user = s->user;
 461 +               return TRUE;
 462         }
 463 -       return num_sessions > 0;
 464  }
 465
 466  gboolean
 467 @@ -255,14 +582,33 @@ nm_session_monitor_uid_active (NMSession
 468                                 uid_t uid,
 469                                 GError **error)
 470  {
 471 -       int num_sessions;
 472 +       if (sd_booted () > 0) {
 473 +               int num_sessions;
 474
 475 -       /* Get active sessions for the user */
 476 -       num_sessions = sd_uid_get_sessions (uid, 1, NULL);
 477 -       if (num_sessions < 0) {
 478 -               nm_log_warn (LOGD_CORE, "Failed to get active systemd sessions for uid %d: %d",
 479 -                            uid, num_sessions);
 480 -               return FALSE;
 481 +               /* Get active sessions for the user */
 482 +               num_sessions = sd_uid_get_sessions (uid, 1, NULL);
 483 +               if (num_sessions < 0) {
 484 +                       nm_log_warn (LOGD_CORE, "Failed to get active systemd sessions for uid %d: %d",
 485 +                                        uid, num_sessions);
 486 +                       return FALSE;
 487 +               }
 488 +               return num_sessions > 0;
 489 +       } else {
 490 +               Session *s;
 491 +
 492 +               if (!ensure_database (monitor, error))
 493 +                       return FALSE;
 494 +
 495 +               s = g_hash_table_lookup (monitor->sessions_by_uid, GUINT_TO_POINTER (uid));
 496 +               if (!s) {
 497 +                       g_set_error (error,
 498 +                                        NM_MANAGER_ERROR,
 499 +                                        NM_MANAGER_ERROR_FAILED,
 500 +                                        "No session found for uid '%d'",
 501 +                                        uid);
 502 +                       return FALSE;
 503 +               }
 504 +
 505 +               return s->active;
 506         }
 507 -       return num_sessions > 0;
 508  }
 509 --- NetworkManager-1.0.0/src/nm-sleep-monitor-systemd.c.orig    2014-12-19 23:32:53.481973137 +0100
 510 +++ NetworkManager-1.0.0/src/nm-sleep-monitor-systemd.c 2014-12-20 00:12:04.572281013 +0100
 511 @@ -35,12 +35,15 @@
 512  #define SD_PATH              "/org/freedesktop/login1"
 513  #define SD_INTERFACE         "org.freedesktop.login1.Manager"
 514
 515 +#define UPOWER_DBUS_SERVICE "org.freedesktop.UPower"
 516
 517  struct _NMSleepMonitor {
 518         GObject parent_instance;
 519
 520         GDBusProxy *sd_proxy;
 521         gint inhibit_fd;
 522 +
 523 +       DBusGProxy *upower_proxy;
 524  };
 525
 526  struct _NMSleepMonitorClass {
 527 @@ -62,6 +65,20 @@ G_DEFINE_TYPE (NMSleepMonitor, nm_sleep_
 528
 529  /********************************************************************/
 530
 531 +static void
 532 +upower_sleeping_cb (DBusGProxy *proxy, gpointer user_data)
 533 +{
 534 +        nm_log_dbg (LOGD_SUSPEND, "Received UPower sleeping signal");
 535 +        g_signal_emit (user_data, signals[SLEEPING], 0);
 536 +}
 537 +
 538 +static void
 539 +upower_resuming_cb (DBusGProxy *proxy, gpointer user_data)
 540 +{
 541 +        nm_log_dbg (LOGD_SUSPEND, "Received UPower resuming signal");
 542 +        g_signal_emit (user_data, signals[RESUMING], 0);
 543 +}
 544 +
 545  static gboolean
 546  drop_inhibitor (NMSleepMonitor *self)
 547  {
 548 @@ -193,14 +210,37 @@ on_proxy_acquired (GObject *object,
 549  static void
 550  nm_sleep_monitor_init (NMSleepMonitor *self)
 551  {
 552 -       self->inhibit_fd = -1;
 553 -       g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
 554 -                                 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START |
 555 -                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
 556 -                                 NULL,
 557 -                                 SD_NAME, SD_PATH, SD_INTERFACE,
 558 -                                 NULL,
 559 -                                 (GAsyncReadyCallback) on_proxy_acquired, self);
 560 +       if (sd_booted () > 0) {
 561 +               self->inhibit_fd = -1;
 562 +               g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
 563 +                                             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START |
 564 +                                             G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
 565 +                                             NULL,
 566 +                                             SD_NAME, SD_PATH, SD_INTERFACE,
 567 +                                             NULL,
 568 +                                             (GAsyncReadyCallback) on_proxy_acquired, self);
 569 +       } else {
 570 +               DBusGConnection *bus;
 571 +
 572 +        bus = nm_dbus_manager_get_connection (nm_dbus_manager_get ());
 573 +        self->upower_proxy = dbus_g_proxy_new_for_name (bus,
 574 +                                                        UPOWER_DBUS_SERVICE,
 575 +                                                        "/org/freedesktop/UPower",
 576 +                                                        "org.freedesktop.UPower");
 577 +        if (self->upower_proxy) {
 578 +            dbus_g_proxy_add_signal (self->upower_proxy, "Sleeping", G_TYPE_INVALID);
 579 +            dbus_g_proxy_connect_signal (self->upower_proxy, "Sleeping",
 580 +                                         G_CALLBACK (upower_sleeping_cb),
 581 +                                         self, NULL);
 582 +
 583 +            dbus_g_proxy_add_signal (self->upower_proxy, "Resuming", G_TYPE_INVALID);
 584 +            dbus_g_proxy_connect_signal (self->upower_proxy, "Resuming",
 585 +                                         G_CALLBACK (upower_resuming_cb),
 586 +                                         self, NULL);
 587 +        } else {
 588 +               nm_log_warn (LOGD_SUSPEND, "could not initialize UPower D-Bus proxy");
 589 +               }
 590 +       }
 591  }
 592
 593  static void
 594 @@ -208,9 +248,14 @@ finalize (GObject *object)
 595  {
 596         NMSleepMonitor *self = NM_SLEEP_MONITOR (object);
 597
 598 -       drop_inhibitor (self);
 599 -       if (self->sd_proxy)
 600 -               g_object_unref (self->sd_proxy);
 601 +       if (sd_booted () > 0) {
 602 +               drop_inhibitor (self);
 603 +               if (self->sd_proxy)
 604 +                       g_object_unref (self->sd_proxy);
 605 +       } else {
 606 +               if (self->upower_proxy)
 607 +               g_object_unref (self->upower_proxy);
 608 +       }
 609
 610         if (G_OBJECT_CLASS (nm_sleep_monitor_parent_class)->finalize != NULL)
 611                 G_OBJECT_CLASS (nm_sleep_monitor_parent_class)->finalize (object);