source3/modules/vfs_notify_fam.c

   1 /*
   2  * FAM file notification support.
   3  *
   4  * Copyright (c) James Peach 2005
   5  * Copyright (c) Volker Lendecke 2007
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program 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
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "includes.h"
  22 #include "smbd/smbd.h"
  23 #include "librpc/gen_ndr/notify.h"
  24
  25 #include <fam.h>
  26
  27 #if !defined(HAVE_FAM_H_FAMCODES_TYPEDEF)
  28 /* Gamin provides this typedef which means we can't use 'enum FAMCodes' as per
  29  * every other FAM implementation. Phooey.
  30  */
  31 typedef enum FAMCodes FAMCodes;
  32 #endif
  33
  34 /* NOTE: There are multiple versions of FAM floating around the net, each with
  35  * slight differences from the original SGI FAM implementation. In this file,
  36  * we rely only on the SGI features and do not assume any extensions. For
  37  * example, we do not look at FAMErrno, because it is not set by the original
  38  * implementation.
  39  *
  40  * Random FAM links:
  41  *      http://oss.sgi.com/projects/fam/
  42  *      http://savannah.nongnu.org/projects/fam/
  43  *      http://sourceforge.net/projects/bsdfam/
  44  */
  45
  46 /* ------------------------------------------------------------------------- */
  47
  48 struct fam_watch_context {
  49         struct fam_watch_context *prev, *next;
  50         FAMConnection *fam_connection;
  51         struct FAMRequest fr;
  52         struct sys_notify_context *sys_ctx;
  53         void (*callback)(struct sys_notify_context *ctx,
  54                          void *private_data,
  55                          struct notify_event *ev);
  56         void *private_data;
  57         uint32_t mask; /* the inotify mask */
  58         uint32_t filter; /* the windows completion filter */
  59         const char *path;
  60 };
  61
  62
  63 /*
  64  * We want one FAM connection per smbd, not one per tcon.
  65  */
  66 static FAMConnection fam_connection;
  67 static bool fam_connection_initialized = False;
  68
  69 static struct fam_watch_context *fam_notify_list;
  70 static void fam_handler(struct event_context *event_ctx,
  71                         struct fd_event *fd_event,
  72                         uint16 flags,
  73                         void *private_data);
  74
  75 static NTSTATUS fam_open_connection(FAMConnection *fam_conn,
  76                                     struct event_context *event_ctx)
  77 {
  78         int res;
  79         char *name;
  80
  81         ZERO_STRUCTP(fam_conn);
  82         FAMCONNECTION_GETFD(fam_conn) = -1;
  83
  84
  85 #ifdef HAVE_FAMNOEXISTS
  86         /* We should honor outside setting of the GAM_CLIENT_ID. */
  87         setenv("GAM_CLIENT_ID","SAMBA",0);
  88 #endif
  89
  90         if (asprintf(&name, "smbd (%lu)", (unsigned long)getpid()) == -1) {
  91                 DEBUG(0, ("No memory\n"));
  92                 return NT_STATUS_NO_MEMORY;
  93         }
  94
  95         res = FAMOpen2(fam_conn, name);
  96
  97 #ifdef HAVE_FAMNOEXISTS
  98         /*
  99          * This reduces the chatter between GAMIN and samba making the pair
 100          * much more reliable.
 101          */
 102         FAMNoExists(fam_conn);
 103 #endif
 104
 105         SAFE_FREE(name);
 106
 107         if (res < 0) {
 108                 DEBUG(10, ("FAM file change notifications not available\n"));
 109                 /*
 110                  * No idea how to get NT_STATUS from a FAM result
 111                  */
 112                 FAMCONNECTION_GETFD(fam_conn) = -1;
 113                 return NT_STATUS_UNEXPECTED_IO_ERROR;
 114         }
 115
 116         if (event_add_fd(event_ctx, event_ctx,
 117                          FAMCONNECTION_GETFD(fam_conn),
 118                          EVENT_FD_READ, fam_handler,
 119                          (void *)fam_conn) == NULL) {
 120                 DEBUG(0, ("event_add_fd failed\n"));
 121                 FAMClose(fam_conn);
 122                 FAMCONNECTION_GETFD(fam_conn) = -1;
 123                 return NT_STATUS_NO_MEMORY;
 124         }
 125
 126         return NT_STATUS_OK;
 127 }
 128
 129 static void fam_reopen(FAMConnection *fam_conn,
 130                        struct event_context *event_ctx,
 131                        struct fam_watch_context *notify_list)
 132 {
 133         struct fam_watch_context *ctx;
 134
 135         DEBUG(5, ("Re-opening FAM connection\n"));
 136
 137         FAMClose(fam_conn);
 138
 139         if (!NT_STATUS_IS_OK(fam_open_connection(fam_conn, event_ctx))) {
 140                 DEBUG(5, ("Re-opening fam connection failed\n"));
 141                 return;
 142         }
 143
 144         for (ctx = notify_list; ctx; ctx = ctx->next) {
 145                 FAMMonitorDirectory(fam_conn, ctx->path, &ctx->fr, NULL);
 146         }
 147 }
 148
 149 static void fam_handler(struct event_context *event_ctx,
 150                         struct fd_event *fd_event,
 151                         uint16 flags,
 152                         void *private_data)
 153 {
 154         FAMConnection *fam_conn = (FAMConnection *)private_data;
 155         FAMEvent fam_event;
 156         struct fam_watch_context *ctx;
 157         struct notify_event ne;
 158
 159         if (FAMPending(fam_conn) == 0) {
 160                 DEBUG(10, ("fam_handler called but nothing pending\n"));
 161                 return;
 162         }
 163
 164         if (FAMNextEvent(fam_conn, &fam_event) != 1) {
 165                 DEBUG(5, ("FAMNextEvent returned an error\n"));
 166                 TALLOC_FREE(fd_event);
 167                 fam_reopen(fam_conn, event_ctx, fam_notify_list);
 168                 return;
 169         }
 170
 171         DEBUG(10, ("Got FAMCode %d for %s\n", fam_event.code,
 172                    fam_event.filename));
 173
 174         switch (fam_event.code) {
 175         case FAMChanged:
 176                 ne.action = NOTIFY_ACTION_MODIFIED;
 177                 break;
 178         case FAMCreated:
 179                 ne.action = NOTIFY_ACTION_ADDED;
 180                 break;
 181         case FAMDeleted:
 182                 ne.action = NOTIFY_ACTION_REMOVED;
 183                 break;
 184         default:
 185                 DEBUG(10, ("Ignoring code FAMCode %d for file %s\n",
 186                            (int)fam_event.code, fam_event.filename));
 187                 return;
 188         }
 189
 190         for (ctx = fam_notify_list; ctx; ctx = ctx->next) {
 191                 if (memcmp(&fam_event.fr, &ctx->fr, sizeof(FAMRequest)) == 0) {
 192                         break;
 193                 }
 194         }
 195
 196         if (ctx == NULL) {
 197                 DEBUG(5, ("Discarding event for file %s\n",
 198                           fam_event.filename));
 199                 return;
 200         }
 201
 202         if ((ne.path = strrchr_m(fam_event.filename, '\\')) == NULL) {
 203                 ne.path = fam_event.filename;
 204         }
 205
 206         ctx->callback(ctx->sys_ctx, ctx->private_data, &ne);
 207 }
 208
 209 static int fam_watch_context_destructor(struct fam_watch_context *ctx)
 210 {
 211         if (FAMCONNECTION_GETFD(ctx->fam_connection) != -1) {
 212                 FAMCancelMonitor(&fam_connection, &ctx->fr);
 213         }
 214         DLIST_REMOVE(fam_notify_list, ctx);
 215         return 0;
 216 }
 217
 218 /*
 219   add a watch. The watch is removed when the caller calls
 220   talloc_free() on *handle
 221 */
 222 static NTSTATUS fam_watch(vfs_handle_struct *vfs_handle,
 223                           struct sys_notify_context *ctx,
 224                           const char *path,
 225                           uint32_t *filter,
 226                           uint32_t *subdir_filter,
 227                           void (*callback)(struct sys_notify_context *ctx,
 228                                            void *private_data,
 229                                            struct notify_event *ev),
 230                           void *private_data,
 231                           void *handle_p)
 232 {
 233         const uint32 fam_mask = (FILE_NOTIFY_CHANGE_FILE_NAME|
 234                                  FILE_NOTIFY_CHANGE_DIR_NAME);
 235         struct fam_watch_context *watch;
 236         void **handle = (void **)handle_p;
 237
 238         if ((*filter & fam_mask) == 0) {
 239                 DEBUG(10, ("filter = %u, ignoring in FAM\n", *filter));
 240                 return NT_STATUS_OK;
 241         }
 242
 243         if (!fam_connection_initialized) {
 244                 if (!NT_STATUS_IS_OK(fam_open_connection(&fam_connection,
 245                                                          ctx->ev))) {
 246                         /*
 247                          * Just let smbd do all the work itself
 248                          */
 249                         return NT_STATUS_OK;
 250                 }
 251                 fam_connection_initialized = True;
 252         }
 253
 254         if (!(watch = talloc(ctx, struct fam_watch_context))) {
 255                 return NT_STATUS_NO_MEMORY;
 256         }
 257
 258         watch->fam_connection = &fam_connection;
 259
 260         watch->callback = callback;
 261         watch->private_data = private_data;
 262         watch->sys_ctx = ctx;
 263
 264         watch->path = talloc_strdup(watch, path);
 265         if (watch->path == NULL) {
 266                 DEBUG(0, ("talloc_asprintf failed\n"));
 267                 TALLOC_FREE(watch);
 268                 return NT_STATUS_NO_MEMORY;
 269         }
 270
 271         /*
 272          * The FAM module in this early state will only take care of
 273          * FAMCreated and FAMDeleted events, Leave the rest to
 274          * notify_internal.c
 275          */
 276
 277         watch->filter = fam_mask;
 278         *filter &= ~fam_mask;
 279
 280         DLIST_ADD(fam_notify_list, watch);
 281         talloc_set_destructor(watch, fam_watch_context_destructor);
 282
 283         /*
 284          * Only directories monitored so far
 285          */
 286
 287         if (FAMCONNECTION_GETFD(watch->fam_connection) != -1) {
 288                 FAMMonitorDirectory(watch->fam_connection, watch->path,
 289                                     &watch->fr, NULL);
 290         }
 291         else {
 292                 /*
 293                  * If the re-open is successful, this will establish the
 294                  * FAMMonitor from the list
 295                  */
 296                 fam_reopen(watch->fam_connection, ctx->ev, fam_notify_list);
 297         }
 298
 299         *handle = (void *)watch;
 300
 301         return NT_STATUS_OK;
 302 }
 303
 304 /* VFS operations structure */
 305
 306 static struct vfs_fn_pointers notify_fam_fns = {
 307         .notify_watch_fn = fam_watch,
 308 };
 309
 310
 311 NTSTATUS vfs_notify_fam_init(void);
 312 NTSTATUS vfs_notify_fam_init(void)
 313 {
 314         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "notify_fam",
 315                                 &notify_fam_fns);
 316 }