Dogcows Code - chaz/openbox/blob - obt/watch.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    obt/watch.c for the Openbox window manager
   4    Copyright (c) 2010        Dana Jansens
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    See the COPYING file for a copy of the GNU General Public License.
  17 */
  18
  19 #include "obt/watch.h"
  20
  21 #ifdef HAVE_SYS_INOTIFY_H
  22 #  include <sys/inotify.h>
  23 #endif
  24 #ifdef HAVE_UNISTD_H
  25 #  include <unistd.h>
  26 #endif
  27 #include <errno.h>
  28
  29 struct _ObtWatch {
  30     guint ref;
  31     gint ino_fd;
  32     guint ino_watch;
  33     GHashTable *targets;
  34
  35 #ifdef HAVE_SYS_INOTIFY_H
  36     GHashTable *targets_by_wd;
  37 #endif
  38 };
  39
  40 typedef struct _ObtWatchTarget {
  41     ObtWatch *w;
  42
  43 #ifdef HAVE_SYS_INOTIFY_H
  44     gint wd;
  45 #endif
  46
  47     gchar *path;
  48     ObtWatchFunc func;
  49     gpointer data;
  50 } ObtWatchTarget;
  51
  52 static void init_inot(ObtWatch *w);
  53 static gboolean read_inot(GIOChannel *s, GIOCondition cond, gpointer data);
  54 static gboolean add_inot(ObtWatch *w, ObtWatchTarget *t, const char *path,
  55                          gboolean dir);
  56 static void rm_inot(ObtWatchTarget *t);
  57 static ObtWatchTarget* target_new(ObtWatch *w, const gchar *path,
  58                                   ObtWatchFunc func, gpointer data);
  59 static void target_free(ObtWatchTarget *t);
  60
  61 ObtWatch* obt_watch_new()
  62 {
  63     ObtWatch *w;
  64
  65     w = g_slice_new(ObtWatch);
  66     w->ref = 1;
  67     w->ino_fd = -1;
  68     w->targets = g_hash_table_new_full(g_str_hash, g_str_equal,
  69                                        NULL, (GDestroyNotify)target_free);
  70 #ifdef HAVE_SYS_INOTIFY_H
  71     w->targets_by_wd = g_hash_table_new(g_int_hash, g_int_equal);
  72 #endif
  73
  74     init_inot(w);
  75
  76     return w;
  77 }
  78 void obt_watch_ref(ObtWatch *w)
  79 {
  80     ++w->ref;
  81 }
  82
  83 void obt_watch_unref(ObtWatch *w)
  84 {
  85     if (--w->ref < 1) {
  86         if (w->ino_fd >= 0 && w->ino_watch)
  87             g_source_remove(w->ino_watch);
  88
  89         g_hash_table_destroy(w->targets);
  90         g_hash_table_destroy(w->targets_by_wd);
  91
  92         g_slice_free(ObtWatch, w);
  93     }
  94 }
  95
  96 static void init_inot(ObtWatch *w)
  97 {
  98 #ifdef HAVE_SYS_INOTIFY_H
  99     if (w->ino_fd >= 0) return;
 100
 101     w->ino_fd = inotify_init();
 102     if (w->ino_fd >= 0) {
 103         GIOChannel *ch;
 104
 105         ch = g_io_channel_unix_new(w->ino_fd);
 106         w->ino_watch = g_io_add_watch(ch, G_IO_IN | G_IO_HUP | G_IO_ERR,
 107                                       read_inot, w);
 108         g_io_channel_unref(ch);
 109     }
 110 #endif
 111 }
 112
 113 static gboolean read_inot(GIOChannel *src, GIOCondition cond, gpointer data)
 114 {
 115 #ifdef HAVE_SYS_INOTIFY_H
 116     ObtWatch *w = data;
 117     ObtWatchTarget *t;
 118     struct inotify_event s;
 119     gint len;
 120     guint ilen;
 121     char *name;
 122
 123     /* read the event */
 124     for (ilen = 0; ilen < sizeof(s); ilen += len) {
 125         len = read(w->ino_fd, ((char*)&s)+ilen, sizeof(s)-ilen);
 126         if (len < 0 && errno != EINTR) return FALSE; /* error, don't repeat */
 127         if (!len) return TRUE; /* nothing there */
 128     }
 129
 130     name = g_new(char, s.len);
 131
 132     /* read the filename */
 133     for (ilen = 0; ilen < s.len; ilen += len) {
 134         len = read(w->ino_fd, name+ilen, s.len-ilen);
 135         if (len < 0 && errno != EINTR) return FALSE; /* error, don't repeat */
 136         if (!len) return TRUE; /* nothing there */
 137     }
 138
 139     t = g_hash_table_lookup(w->targets, &s.wd);
 140     if (t) t->func(w, name, t->data);
 141
 142     g_free(name);
 143 #endif
 144     return TRUE; /* repeat */
 145 }
 146
 147 static gboolean add_inot(ObtWatch *w, ObtWatchTarget *t, const char *path,
 148                          gboolean dir)
 149 {
 150 #ifndef HAVE_SYS_INOTIFY_H
 151     return FALSE;
 152 #else
 153     gint mask;
 154     if (w->ino_fd < 0) return FALSE;
 155     if (dir) mask = IN_MODIFY | IN_CREATE | IN_DELETE | IN_MOVE;
 156     else g_assert_not_reached();
 157     t->wd = inotify_add_watch(w->ino_fd, path, mask);
 158     return TRUE;
 159 #endif
 160 }
 161
 162 static void rm_inot(ObtWatchTarget *t)
 163 {
 164 #ifdef HAVE_SYS_INOTIFY_H
 165     if (t->w->ino_fd < 0) return;
 166     if (t->wd < 0) return;
 167     inotify_rm_watch(t->w->ino_fd, t->wd);
 168 #endif
 169 }
 170
 171 static ObtWatchTarget* target_new(ObtWatch *w, const gchar *path,
 172                                   ObtWatchFunc func, gpointer data)
 173 {
 174     ObtWatchTarget *t;
 175
 176     t = g_slice_new0(ObtWatchTarget);
 177     t->w = w;
 178     t->wd = -1;
 179     t->path = g_strdup(path);
 180     t->func = func;
 181     t->data = data;
 182
 183     if (!add_inot(w, t, path, TRUE)) {
 184         g_assert_not_reached(); /* XXX do something */
 185     }
 186
 187 #ifndef HAVE_SYS_INOTIFY_H
 188 #error need inotify for now
 189 #endif
 190
 191     return t;
 192 }
 193
 194 static void target_free(ObtWatchTarget *t)
 195 {
 196     rm_inot(t);
 197
 198     g_free(t->path);
 199     g_slice_free(ObtWatchTarget, t);
 200 }
 201
 202 void obt_paths_watch_dir(ObtWatch *w, const gchar *path,
 203                          ObtWatchFunc func, gpointer data)
 204 {
 205     ObtWatchTarget *t;
 206
 207     g_return_if_fail(w != NULL);
 208     g_return_if_fail(path != NULL);
 209     g_return_if_fail(data != NULL);
 210
 211     t = target_new(w, path, func, data);
 212     g_hash_table_insert(w->targets, t->path, t);
 213 #ifdef HAVE_SYS_INOTIFY_H
 214     g_hash_table_insert(w->targets_by_wd, &t->wd, t);
 215 #endif
 216 }
 217
 218 void obt_paths_unwatch_dir(ObtWatch *w, const gchar *path)
 219 {
 220     ObtWatchTarget *t;
 221
 222     g_return_if_fail(w != NULL);
 223     g_return_if_fail(path != NULL);
 224
 225     t = g_hash_table_lookup(w->targets, path);
 226
 227     if (t) {
 228 #ifdef HAVE_SYS_INOTIFY_H
 229         g_hash_table_remove(w->targets_by_wd, &t->wd);
 230 #endif
 231         g_hash_table_remove(w->targets, path);
 232     }
 233 }