gio/gunixvolumemonitor.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2
   3 /* GIO - GLib Input, Output and Streaming Library
   4  *
   5  * Copyright (C) 2006-2007 Red Hat, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General
  18  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  *         David Zeuthen <davidz@redhat.com>
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27
  28 #include <glib.h>
  29 #include "gunixvolumemonitor.h"
  30 #include "gunixmounts.h"
  31 #include "gunixmount.h"
  32 #include "gunixvolume.h"
  33 #include "gmount.h"
  34 #include "gmountprivate.h"
  35 #include "giomodule.h"
  36 #include "glibintl.h"
  37
  38
  39 struct _GUnixVolumeMonitor {
  40   GNativeVolumeMonitor parent;
  41
  42   GUnixMountMonitor *mount_monitor;
  43
  44   GList *last_mountpoints;
  45   GList *last_mounts;
  46
  47   GList *volumes;
  48   GList *mounts;
  49 };
  50
  51 static void mountpoints_changed      (GUnixMountMonitor  *mount_monitor,
  52                                       gpointer            user_data);
  53 static void mounts_changed           (GUnixMountMonitor  *mount_monitor,
  54                                       gpointer            user_data);
  55 static void update_volumes           (GUnixVolumeMonitor *monitor);
  56 static void update_mounts            (GUnixVolumeMonitor *monitor);
  57
  58 #define g_unix_volume_monitor_get_type _g_unix_volume_monitor_get_type
  59 G_DEFINE_TYPE_WITH_CODE (GUnixVolumeMonitor, g_unix_volume_monitor, G_TYPE_NATIVE_VOLUME_MONITOR,
  60                          g_io_extension_point_implement (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME,
  61                                                          g_define_type_id,
  62                                                          "unix",
  63                                                          0));
  64
  65 static void
  66 g_unix_volume_monitor_finalize (GObject *object)
  67 {
  68   GUnixVolumeMonitor *monitor;
  69
  70   monitor = G_UNIX_VOLUME_MONITOR (object);
  71
  72   g_signal_handlers_disconnect_by_func (monitor->mount_monitor, mountpoints_changed, monitor);
  73   g_signal_handlers_disconnect_by_func (monitor->mount_monitor, mounts_changed, monitor);
  74
  75   g_object_unref (monitor->mount_monitor);
  76
  77   g_list_free_full (monitor->last_mountpoints, (GDestroyNotify) g_unix_mount_point_free);
  78   g_list_free_full (monitor->last_mounts, (GDestroyNotify) g_unix_mount_free);
  79
  80   g_list_free_full (monitor->volumes, g_object_unref);
  81   g_list_free_full (monitor->mounts, g_object_unref);
  82
  83   G_OBJECT_CLASS (g_unix_volume_monitor_parent_class)->finalize (object);
  84 }
  85
  86 static void
  87 g_unix_volume_monitor_dispose (GObject *object)
  88 {
  89   GUnixVolumeMonitor *monitor;
  90
  91   monitor = G_UNIX_VOLUME_MONITOR (object);
  92
  93   g_list_free_full (monitor->volumes, g_object_unref);
  94   monitor->volumes = NULL;
  95
  96   g_list_free_full (monitor->mounts, g_object_unref);
  97   monitor->mounts = NULL;
  98
  99   G_OBJECT_CLASS (g_unix_volume_monitor_parent_class)->dispose (object);
 100 }
 101
 102 static GList *
 103 get_mounts (GVolumeMonitor *volume_monitor)
 104 {
 105   GUnixVolumeMonitor *monitor;
 106
 107   monitor = G_UNIX_VOLUME_MONITOR (volume_monitor);
 108
 109   return g_list_copy_deep (monitor->mounts, (GCopyFunc) g_object_ref, NULL);
 110 }
 111
 112 static GList *
 113 get_volumes (GVolumeMonitor *volume_monitor)
 114 {
 115   GUnixVolumeMonitor *monitor;
 116
 117   monitor = G_UNIX_VOLUME_MONITOR (volume_monitor);
 118
 119   return g_list_copy_deep (monitor->volumes, (GCopyFunc) g_object_ref, NULL);
 120 }
 121
 122 static GList *
 123 get_connected_drives (GVolumeMonitor *volume_monitor)
 124 {
 125   return NULL;
 126 }
 127
 128 static GVolume *
 129 get_volume_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 130 {
 131   return NULL;
 132 }
 133
 134 static GMount *
 135 get_mount_for_uuid (GVolumeMonitor *volume_monitor, const char *uuid)
 136 {
 137   return NULL;
 138 }
 139
 140 static gboolean
 141 is_supported (void)
 142 {
 143   return TRUE;
 144 }
 145
 146 static GMount *
 147 get_mount_for_mount_path (const char *mount_path,
 148                           GCancellable *cancellable)
 149 {
 150   GUnixMountEntry *mount_entry;
 151   GUnixMount *mount;
 152
 153   mount_entry = g_unix_mount_at (mount_path, NULL);
 154
 155   if (!mount_entry)
 156     return NULL;
 157
 158   /* TODO: Set mountable volume? */
 159   mount = _g_unix_mount_new (NULL, mount_entry, NULL);
 160
 161   g_unix_mount_free (mount_entry);
 162
 163   return G_MOUNT (mount);
 164 }
 165
 166 static void
 167 g_unix_volume_monitor_class_init (GUnixVolumeMonitorClass *klass)
 168 {
 169   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 170   GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
 171   GNativeVolumeMonitorClass *native_class = G_NATIVE_VOLUME_MONITOR_CLASS (klass);
 172
 173   gobject_class->finalize = g_unix_volume_monitor_finalize;
 174   gobject_class->dispose = g_unix_volume_monitor_dispose;
 175
 176   monitor_class->get_mounts = get_mounts;
 177   monitor_class->get_volumes = get_volumes;
 178   monitor_class->get_connected_drives = get_connected_drives;
 179   monitor_class->get_volume_for_uuid = get_volume_for_uuid;
 180   monitor_class->get_mount_for_uuid = get_mount_for_uuid;
 181   monitor_class->is_supported = is_supported;
 182
 183   native_class->get_mount_for_mount_path = get_mount_for_mount_path;
 184 }
 185
 186 void
 187 _g_unix_volume_monitor_update (GUnixVolumeMonitor *unix_monitor)
 188 {
 189   /* Update both to make sure volumes are created before mounts */
 190   update_volumes (unix_monitor);
 191   update_mounts (unix_monitor);
 192 }
 193
 194 static void
 195 mountpoints_changed (GUnixMountMonitor *mount_monitor,
 196                      gpointer           user_data)
 197 {
 198   GUnixVolumeMonitor *unix_monitor = user_data;
 199
 200   _g_unix_volume_monitor_update (unix_monitor);
 201 }
 202
 203 static void
 204 mounts_changed (GUnixMountMonitor *mount_monitor,
 205                 gpointer           user_data)
 206 {
 207   GUnixVolumeMonitor *unix_monitor = user_data;
 208
 209   _g_unix_volume_monitor_update (unix_monitor);
 210 }
 211
 212 static void
 213 g_unix_volume_monitor_init (GUnixVolumeMonitor *unix_monitor)
 214 {
 215
 216   unix_monitor->mount_monitor = g_unix_mount_monitor_get ();
 217
 218   g_signal_connect (unix_monitor->mount_monitor,
 219                     "mounts-changed", G_CALLBACK (mounts_changed),
 220                     unix_monitor);
 221
 222   g_signal_connect (unix_monitor->mount_monitor,
 223                     "mountpoints-changed", G_CALLBACK (mountpoints_changed),
 224                     unix_monitor);
 225
 226   _g_unix_volume_monitor_update (unix_monitor);
 227 }
 228
 229 GVolumeMonitor *
 230 _g_unix_volume_monitor_new (void)
 231 {
 232   GUnixVolumeMonitor *monitor;
 233
 234   monitor = g_object_new (G_TYPE_UNIX_VOLUME_MONITOR, NULL);
 235
 236   return G_VOLUME_MONITOR (monitor);
 237 }
 238
 239 static void
 240 diff_sorted_lists (GList         *list1,
 241                    GList         *list2,
 242                    GCompareFunc   compare,
 243                    GList        **added,
 244                    GList        **removed)
 245 {
 246   int order;
 247
 248   *added = *removed = NULL;
 249
 250   while (list1 != NULL &&
 251          list2 != NULL)
 252     {
 253       order = (*compare) (list1->data, list2->data);
 254       if (order < 0)
 255         {
 256           *removed = g_list_prepend (*removed, list1->data);
 257           list1 = list1->next;
 258         }
 259       else if (order > 0)
 260         {
 261           *added = g_list_prepend (*added, list2->data);
 262           list2 = list2->next;
 263         }
 264       else
 265         { /* same item */
 266           list1 = list1->next;
 267           list2 = list2->next;
 268         }
 269     }
 270
 271   while (list1 != NULL)
 272     {
 273       *removed = g_list_prepend (*removed, list1->data);
 274       list1 = list1->next;
 275     }
 276   while (list2 != NULL)
 277     {
 278       *added = g_list_prepend (*added, list2->data);
 279       list2 = list2->next;
 280     }
 281 }
 282
 283 GUnixVolume *
 284 _g_unix_volume_monitor_lookup_volume_for_mount_path (GUnixVolumeMonitor *monitor,
 285                                                      const char         *mount_path)
 286 {
 287   GList *l;
 288
 289   for (l = monitor->volumes; l != NULL; l = l->next)
 290     {
 291       GUnixVolume *volume = l->data;
 292
 293       if (_g_unix_volume_has_mount_path (volume, mount_path))
 294         return volume;
 295     }
 296
 297   return NULL;
 298 }
 299
 300 static GUnixMount *
 301 find_mount_by_mountpath (GUnixVolumeMonitor *monitor,
 302                          const char *mount_path)
 303 {
 304   GList *l;
 305
 306   for (l = monitor->mounts; l != NULL; l = l->next)
 307     {
 308       GUnixMount *mount = l->data;
 309
 310       if (_g_unix_mount_has_mount_path (mount, mount_path))
 311         return mount;
 312     }
 313
 314   return NULL;
 315 }
 316
 317 static void
 318 update_volumes (GUnixVolumeMonitor *monitor)
 319 {
 320   GList *new_mountpoints;
 321   GList *removed, *added;
 322   GList *l;
 323   GUnixVolume *volume;
 324
 325   new_mountpoints = g_unix_mount_points_get (NULL);
 326
 327   new_mountpoints = g_list_sort (new_mountpoints, (GCompareFunc) g_unix_mount_point_compare);
 328
 329   diff_sorted_lists (monitor->last_mountpoints,
 330                      new_mountpoints, (GCompareFunc) g_unix_mount_point_compare,
 331                      &added, &removed);
 332
 333   for (l = removed; l != NULL; l = l->next)
 334     {
 335       GUnixMountPoint *mountpoint = l->data;
 336
 337       volume = _g_unix_volume_monitor_lookup_volume_for_mount_path (monitor,
 338                                                                     g_unix_mount_point_get_mount_path (mountpoint));
 339       if (volume)
 340         {
 341           _g_unix_volume_disconnected (volume);
 342           monitor->volumes = g_list_remove (monitor->volumes, volume);
 343           g_signal_emit_by_name (monitor, "volume-removed", volume);
 344           g_signal_emit_by_name (volume, "removed");
 345           g_object_unref (volume);
 346         }
 347     }
 348
 349   for (l = added; l != NULL; l = l->next)
 350     {
 351       GUnixMountPoint *mountpoint = l->data;
 352
 353       volume = _g_unix_volume_new (G_VOLUME_MONITOR (monitor), mountpoint);
 354       if (volume)
 355         {
 356           monitor->volumes = g_list_prepend (monitor->volumes, volume);
 357           g_signal_emit_by_name (monitor, "volume-added", volume);
 358         }
 359     }
 360
 361   g_list_free (added);
 362   g_list_free (removed);
 363   g_list_free_full (monitor->last_mountpoints, (GDestroyNotify) g_unix_mount_point_free);
 364   monitor->last_mountpoints = new_mountpoints;
 365 }
 366
 367 static void
 368 update_mounts (GUnixVolumeMonitor *monitor)
 369 {
 370   GList *new_mounts;
 371   GList *removed, *added;
 372   GList *l;
 373   GUnixMount *mount;
 374   GUnixVolume *volume;
 375   const char *mount_path;
 376
 377   new_mounts = g_unix_mounts_get (NULL);
 378
 379   new_mounts = g_list_sort (new_mounts, (GCompareFunc) g_unix_mount_compare);
 380
 381   diff_sorted_lists (monitor->last_mounts,
 382                      new_mounts, (GCompareFunc) g_unix_mount_compare,
 383                      &added, &removed);
 384
 385   for (l = removed; l != NULL; l = l->next)
 386     {
 387       GUnixMountEntry *mount_entry = l->data;
 388
 389       mount = find_mount_by_mountpath (monitor, g_unix_mount_get_mount_path (mount_entry));
 390       if (mount)
 391         {
 392           _g_unix_mount_unmounted (mount);
 393           monitor->mounts = g_list_remove (monitor->mounts, mount);
 394           g_signal_emit_by_name (monitor, "mount-removed", mount);
 395           g_signal_emit_by_name (mount, "unmounted");
 396           g_object_unref (mount);
 397         }
 398     }
 399
 400   for (l = added; l != NULL; l = l->next)
 401     {
 402       GUnixMountEntry *mount_entry = l->data;
 403
 404       mount_path = g_unix_mount_get_mount_path (mount_entry);
 405
 406       volume = _g_unix_volume_monitor_lookup_volume_for_mount_path (monitor, mount_path);
 407       mount = _g_unix_mount_new (G_VOLUME_MONITOR (monitor), mount_entry, volume);
 408       if (mount)
 409         {
 410           monitor->mounts = g_list_prepend (monitor->mounts, mount);
 411           g_signal_emit_by_name (monitor, "mount-added", mount);
 412         }
 413     }
 414
 415   g_list_free (added);
 416   g_list_free (removed);
 417   g_list_free_full (monitor->last_mounts, (GDestroyNotify) g_unix_mount_free);
 418   monitor->last_mounts = new_mounts;
 419 }