r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[tprouty/samba.git] / source / smbd / notify.c
index 2a5d7fc5525796ff6605b46dd4a16af7faff66e8..6ab4266c19f04410cdc49b9bea876a10ec19bdf1 100644 (file)
@@ -3,10 +3,11 @@
    change notify handling
    Copyright (C) Andrew Tridgell 2000
    Copyright (C) Jeremy Allison 1994-1998
+   Copyright (C) Volker Lendecke 2007
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
 
-static struct cnotify_fns *cnotify;
+/* Max size we can send to client in a notify response. */
+extern int max_send;
 
-/****************************************************************************
- This is the structure to queue to implement NT change
- notify. It consists of smb_size bytes stored from the
- transact command (to keep the mid, tid etc around).
- Plus the fid to examine and notify private data.
-*****************************************************************************/
-
-struct change_notify {
-       struct change_notify *next, *prev;
-       files_struct *fsp;
-       connection_struct *conn;
-       uint32 flags;
-       uint32 max_param_count;
+struct notify_change_request {
+       struct notify_change_request *prev, *next;
+       struct files_struct *fsp;       /* backpointer for cancel by mid */
        char request_buf[smb_size];
-       void *change_data;
+       uint32 filter;
+       uint32 current_bufsize;
+       struct notify_mid_map *mid_map;
+       void *backend_data;
+};
+
+static void notify_fsp(files_struct *fsp, uint32 action, const char *name);
+
+static struct notify_mid_map *notify_changes_by_mid;
+
+/*
+ * For NTCancel, we need to find the notify_change_request indexed by
+ * mid. Separate list here.
+ */
+
+struct notify_mid_map {
+       struct notify_mid_map *prev, *next;
+       struct notify_change_request *req;
+       uint16 mid;
 };
 
-static struct change_notify *change_notify_list;
+static BOOL notify_change_record_identical(struct notify_change *c1,
+                                       struct notify_change *c2)
+{
+       /* Note this is deliberately case sensitive. */
+       if (c1->action == c2->action &&
+                       strcmp(c1->name, c2->name) == 0) {
+               return True;
+       }
+       return False;
+}
 
-static BOOL notify_marshall_changes(struct notify_changes *changes,
+static BOOL notify_marshall_changes(int num_changes,
+                                   struct notify_change *changes,
                                    prs_struct *ps)
 {
        int i;
        UNISTR uni_name;
 
-       for (i=0; i<changes->num_changes; i++) {
-               struct notify_change *c = &changes->changes[i];
+       for (i=0; i<num_changes; i++) {
+               struct notify_change *c;
                size_t namelen;
                uint32 u32_tmp; /* Temp arg to prs_uint32 to avoid
                                 * signed/unsigned issues */
 
+               /* Coalesce any identical records. */
+               while (i+1 < num_changes &&
+                       notify_change_record_identical(&changes[i],
+                                               &changes[i+1])) {
+                       i++;
+               }
+
+               c = &changes[i];
+
                namelen = convert_string_allocate(
                        NULL, CH_UNIX, CH_UTF16LE, c->name, strlen(c->name)+1,
                        &uni_name.buffer, True);
@@ -67,7 +95,7 @@ static BOOL notify_marshall_changes(struct notify_changes *changes,
                 * Offset to next entry, only if there is one
                 */
 
-               u32_tmp = (i == changes->num_changes-1) ? 0 : namelen + 12;
+               u32_tmp = (i == num_changes-1) ? 0 : namelen + 12;
                if (!prs_uint32("offset", ps, 1, &u32_tmp)) goto fail;
 
                u32_tmp = c->action;
@@ -97,13 +125,14 @@ static BOOL notify_marshall_changes(struct notify_changes *changes,
  Setup the common parts of the return packet and send it.
 *****************************************************************************/
 
-static void change_notify_reply_packet(struct change_notify *notify,
+static void change_notify_reply_packet(const char *request_buf,
                                       NTSTATUS error_code)
 {
+       const char *inbuf = request_buf;
        char outbuf[smb_size+38];
 
        memset(outbuf, '\0', sizeof(outbuf));
-       construct_reply_common(notify->request_buf, outbuf);
+       construct_reply_common(request_buf, outbuf);
 
        ERROR_NT(error_code);
 
@@ -111,43 +140,52 @@ static void change_notify_reply_packet(struct change_notify *notify,
         * Seems NT needs a transact command with an error code
         * in it. This is a longer packet than a simple error.
         */
-       set_message(outbuf,18,0,False);
+       set_message(inbuf,outbuf,18,0,False);
 
        show_msg(outbuf);
        if (!send_smb(smbd_server_fd(),outbuf))
-               exit_server_cleanly("change_notify_reply_packet: send_smb failed.");
+               exit_server_cleanly("change_notify_reply_packet: send_smb "
+                                   "failed.");
 }
 
-static void change_notify_reply(struct change_notify *notify)
+void change_notify_reply(const char *request_buf,
+                        struct notify_change_buf *notify_buf)
 {
        char *outbuf = NULL;
        prs_struct ps;
-       size_t buflen = smb_size+38+notify->max_param_count;
+       size_t buflen;
+
+       if (notify_buf->num_changes == -1) {
+               change_notify_reply_packet(request_buf, NT_STATUS_OK);
+               return;
+       }
 
        if (!prs_init(&ps, 0, NULL, False)
-           || !notify_marshall_changes(notify->fsp->notify, &ps)) {
-               change_notify_reply_packet(notify, NT_STATUS_NO_MEMORY);
+           || !notify_marshall_changes(notify_buf->num_changes,
+                                       notify_buf->changes, &ps)) {
+               change_notify_reply_packet(request_buf, NT_STATUS_NO_MEMORY);
                goto done;
        }
 
-       if (prs_offset(&ps) > notify->max_param_count) {
+       buflen = smb_size+38+prs_offset(&ps) + 4 /* padding */;
+
+       if (buflen > max_send) {
                /*
                 * We exceed what the client is willing to accept. Send
                 * nothing.
                 */
-               change_notify_reply_packet(notify, NT_STATUS_OK);
+               change_notify_reply_packet(request_buf, NT_STATUS_OK);
                goto done;
        }
 
        if (!(outbuf = SMB_MALLOC_ARRAY(char, buflen))) {
-               change_notify_reply_packet(notify, NT_STATUS_NO_MEMORY);
+               change_notify_reply_packet(request_buf, NT_STATUS_NO_MEMORY);
                goto done;
        }
 
-       memset(outbuf, '\0', sizeof(outbuf));
-       construct_reply_common(notify->request_buf, outbuf);
+       construct_reply_common(request_buf, outbuf);
 
-       if (send_nt_replies(outbuf, buflen, NT_STATUS_OK, prs_data_p(&ps),
+       if (send_nt_replies(request_buf, outbuf, buflen, NT_STATUS_OK, prs_data_p(&ps),
                            prs_offset(&ps), NULL, 0) == -1) {
                exit_server("change_notify_reply_packet: send_smb failed.");
        }
@@ -155,325 +193,197 @@ static void change_notify_reply(struct change_notify *notify)
  done:
        SAFE_FREE(outbuf);
        prs_mem_free(&ps);
-       notify->fsp->notify->num_changes = 0;
-       TALLOC_FREE(notify->fsp->notify->changes);
-}
-
-/****************************************************************************
- Remove an entry from the list and free it, also closing any
- directory handle if necessary.
-*****************************************************************************/
 
-static void change_notify_remove(struct change_notify *cnbp)
-{
-       cnotify->remove_notify(cnbp->change_data);
-       DLIST_REMOVE(change_notify_list, cnbp);
-       ZERO_STRUCTP(cnbp);
-       SAFE_FREE(cnbp);
+       TALLOC_FREE(notify_buf->changes);
+       notify_buf->num_changes = 0;
 }
 
-/****************************************************************************
- Delete entries by fnum from the change notify pending queue.
-*****************************************************************************/
-
-void remove_pending_change_notify_requests_by_fid(files_struct *fsp, NTSTATUS status)
+static void notify_callback(void *private_data, const struct notify_event *e)
 {
-       struct change_notify *cnbp, *next;
-
-       for (cnbp=change_notify_list; cnbp; cnbp=next) {
-               next=cnbp->next;
-               if (cnbp->fsp->fnum == fsp->fnum) {
-                       change_notify_reply_packet(cnbp, status);
-                       change_notify_remove(cnbp);
-               }
-       }
+       files_struct *fsp = (files_struct *)private_data;
+       DEBUG(10, ("notify_callback called for %s\n", fsp->fsp_name));
+       notify_fsp(fsp, e->action, e->path);
 }
 
-/****************************************************************************
- Delete entries by mid from the change notify pending queue. Always send reply.
-*****************************************************************************/
-
-void remove_pending_change_notify_requests_by_mid(int mid)
+NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
+                             BOOL recursive)
 {
-       struct change_notify *cnbp, *next;
-
-       for (cnbp=change_notify_list; cnbp; cnbp=next) {
-               next=cnbp->next;
-               if(SVAL(cnbp->request_buf,smb_mid) == mid) {
-                       change_notify_reply_packet(cnbp, NT_STATUS_CANCELLED);
-                       change_notify_remove(cnbp);
-               }
-       }
-}
-
-/****************************************************************************
- Delete entries by filename and cnum from the change notify pending queue.
- Always send reply.
-*****************************************************************************/
+       char *fullpath;
+       struct notify_entry e;
+       NTSTATUS status;
 
-void remove_pending_change_notify_requests_by_filename(files_struct *fsp, NTSTATUS status)
-{
-       struct change_notify *cnbp, *next;
+       SMB_ASSERT(fsp->notify == NULL);
 
-       for (cnbp=change_notify_list; cnbp; cnbp=next) {
-               next=cnbp->next;
-               /*
-                * We know it refers to the same directory if the connection number and
-                * the filename are identical.
-                */
-               if((cnbp->fsp->conn == fsp->conn) && strequal(cnbp->fsp->fsp_name,fsp->fsp_name)) {
-                       change_notify_reply_packet(cnbp, status);
-                       change_notify_remove(cnbp);
-               }
+       if (!(fsp->notify = TALLOC_ZERO_P(NULL, struct notify_change_buf))) {
+               DEBUG(0, ("talloc failed\n"));
+               return NT_STATUS_NO_MEMORY;
        }
-}
 
-/****************************************************************************
- Set the current change notify timeout to the lowest value across all service
- values.
-****************************************************************************/
-
-void set_change_notify_timeout(int val)
-{
-       if (val > 0) {
-               cnotify->select_time = MIN(cnotify->select_time, val);
+       if (asprintf(&fullpath, "%s/%s", fsp->conn->connectpath,
+                    fsp->fsp_name) == -1) {
+               DEBUG(0, ("asprintf failed\n"));
+               return NT_STATUS_NO_MEMORY;
        }
-}
-
-/****************************************************************************
- Longest time to sleep for before doing a change notify scan.
-****************************************************************************/
 
-int change_notify_timeout(void)
-{
-       return cnotify->select_time;
-}
-
-/****************************************************************************
- Process the change notify queue. Note that this is only called as root.
- Returns True if there are still outstanding change notify requests on the
- queue.
-*****************************************************************************/
-
-BOOL process_pending_change_notify_queue(time_t t)
-{
-       struct change_notify *cnbp, *next;
-       uint16 vuid;
-
-       for (cnbp=change_notify_list; cnbp; cnbp=next) {
-               next=cnbp->next;
-
-               vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(cnbp->request_buf,smb_uid);
-
-               if ((cnbp->fsp->notify->num_changes != 0)
-                   || cnotify->check_notify(cnbp->conn, vuid,
-                                            cnbp->fsp->fsp_name, cnbp->flags,
-                                            cnbp->change_data, t)) {
-                       DEBUG(10,("process_pending_change_notify_queue: dir "
-                                 "%s changed !\n", cnbp->fsp->fsp_name ));
-                       change_notify_reply(cnbp);
-                       change_notify_remove(cnbp);
-               }
+       e.path = fullpath;
+       e.filter = filter;
+       e.subdir_filter = 0;
+       if (recursive) {
+               e.subdir_filter = filter;
        }
 
-       return (change_notify_list != NULL);
+       status = notify_add(fsp->conn->notify_ctx, &e, notify_callback, fsp);
+       SAFE_FREE(fullpath);
+
+       return status;
 }
 
-/****************************************************************************
- Now queue an entry on the notify change list.
- We only need to save smb_size bytes from this incoming packet
- as we will always by returning a 'read the directory yourself'
- error.
-****************************************************************************/
-
-BOOL change_notify_set(char *inbuf, files_struct *fsp, connection_struct *conn,
-                      uint32 flags, uint32 max_param_count)
+NTSTATUS change_notify_add_request(const char *inbuf, 
+                                  uint32 filter, BOOL recursive,
+                                  struct files_struct *fsp)
 {
-       struct change_notify *cnbp;
+       struct notify_change_request *request = NULL;
+       struct notify_mid_map *map = NULL;
 
-       if((cnbp = SMB_MALLOC_P(struct change_notify)) == NULL) {
-               DEBUG(0,("change_notify_set: malloc fail !\n" ));
-               return False;
+       if (!(request = SMB_MALLOC_P(struct notify_change_request))
+           || !(map = SMB_MALLOC_P(struct notify_mid_map))) {
+               SAFE_FREE(request);
+               return NT_STATUS_NO_MEMORY;
        }
 
-       ZERO_STRUCTP(cnbp);
+       request->mid_map = map;
+       map->req = request;
 
-       memcpy(cnbp->request_buf, inbuf, smb_size);
-       cnbp->fsp = fsp;
-       cnbp->conn = conn;
-       cnbp->flags = flags;
-       cnbp->max_param_count = max_param_count;
-       cnbp->change_data = cnotify->register_notify(conn, fsp->fsp_name,
-                                                    flags);
+       memcpy(request->request_buf, inbuf, sizeof(request->request_buf));
+       request->current_bufsize = 0;
+       request->filter = filter;
+       request->fsp = fsp;
+       request->backend_data = NULL;
        
-       if (!cnbp->change_data) {
-               SAFE_FREE(cnbp);
-               return False;
-       }
+       DLIST_ADD_END(fsp->notify->requests, request,
+                     struct notify_change_request *);
 
-       DLIST_ADD(change_notify_list, cnbp);
+       map->mid = SVAL(inbuf, smb_mid);
+       DLIST_ADD(notify_changes_by_mid, map);
 
        /* Push the MID of this packet on the signing queue. */
        srv_defer_sign_response(SVAL(inbuf,smb_mid));
 
-       return True;
+       return NT_STATUS_OK;
 }
 
-int change_notify_fd(void)
+static void change_notify_remove_request(struct notify_change_request *remove_req)
 {
-       if (cnotify) {
-               return cnotify->notification_fd;
-       }
-
-       return -1;
-}
-
-/* notify message definition
-
-Offset  Data                   length.
-0      SMB_DEV_T dev           8
-8      SMB_INO_T inode         8
-16     uint32 action           4
-20..   name
-*/
-
-#define MSG_NOTIFY_MESSAGE_SIZE 21 /* Includes at least the '\0' terminator */
-
-struct notify_message {
-       SMB_DEV_T dev;
-       SMB_INO_T inode;
-       uint32_t action;
-       char *name;
-};
+       files_struct *fsp;
+       struct notify_change_request *req;
 
-static DATA_BLOB notify_message_to_buf(const struct notify_message *msg)
-{
-       DATA_BLOB result;
-       size_t len;
+       /*
+        * Paranoia checks, the fsp referenced must must have the request in
+        * its list of pending requests
+        */
 
-       len = strlen(msg->name);
+       fsp = remove_req->fsp;
+       SMB_ASSERT(fsp->notify != NULL);
 
-       result = data_blob(NULL, MSG_NOTIFY_MESSAGE_SIZE + len);
-       if (!result.data) {
-               return result;
+       for (req = fsp->notify->requests; req; req = req->next) {
+               if (req == remove_req) {
+                       break;
+               }
        }
 
-       SDEV_T_VAL(result.data, 0, msg->dev);
-       SINO_T_VAL(result.data, 8, msg->inode);
-       SIVAL(result.data, 16, msg->action);
-       memcpy(result.data+20, msg->name, len+1);
-
-       return result;
-}
-
-static BOOL buf_to_notify_message(void *buf, size_t len,
-                                 struct notify_message *msg)
-{
-       if (len < MSG_NOTIFY_MESSAGE_SIZE) {
-               DEBUG(0, ("Got invalid notify message of len %d\n", len));
-               return False;
+       if (req == NULL) {
+               smb_panic("notify_req not found in fsp's requests");
        }
 
-       msg->dev     = DEV_T_VAL(buf, 0);
-       msg->inode   = INO_T_VAL(buf, 8);
-       msg->action  = IVAL(buf, 16);
-       msg->name    = ((char *)buf)+20;
-       return True;
+       DLIST_REMOVE(fsp->notify->requests, req);
+       DLIST_REMOVE(notify_changes_by_mid, req->mid_map);
+       SAFE_FREE(req->mid_map);
+       TALLOC_FREE(req->backend_data);
+       SAFE_FREE(req);
 }
 
-void notify_action(connection_struct *conn, const char *parent,
-                  const char *name, uint32_t action)
-{
-       struct share_mode_lock *lck;
-       SMB_STRUCT_STAT sbuf;
-       int i;
-       struct notify_message msg;
-       DATA_BLOB blob;
+/****************************************************************************
+ Delete entries by mid from the change notify pending queue. Always send reply.
+*****************************************************************************/
 
-       struct process_id *pids;
-       int num_pids;
+void remove_pending_change_notify_requests_by_mid(uint16 mid)
+{
+       struct notify_mid_map *map;
 
-       if (SMB_VFS_STAT(conn, parent, &sbuf) != 0) {
-               /*
-                * Not 100% critical, ignore failure
-                */
-               return;
+       for (map = notify_changes_by_mid; map; map = map->next) {
+               if (map->mid == mid) {
+                       break;
+               }
        }
 
-       if (!(lck = get_share_mode_lock(NULL, sbuf.st_dev, sbuf.st_ino,
-                                       NULL, NULL))) {
+       if (map == NULL) {
                return;
        }
 
-       msg.dev = sbuf.st_dev;
-       msg.inode = sbuf.st_ino;
-       msg.action = action;
-       msg.name = CONST_DISCARD(char *, name);
+       change_notify_reply_packet(map->req->request_buf, NT_STATUS_CANCELLED);
+       change_notify_remove_request(map->req);
+}
+
+/****************************************************************************
+ Delete entries by fnum from the change notify pending queue.
+*****************************************************************************/
 
-       blob = notify_message_to_buf(&msg);
-       if (blob.data == NULL) {
-               DEBUG(0, ("notify_message_to_buf failed\n"));
+void remove_pending_change_notify_requests_by_fid(files_struct *fsp,
+                                                 NTSTATUS status)
+{
+       if (fsp->notify == NULL) {
                return;
        }
 
-       pids = NULL;
-       num_pids = 0;
-
-       become_root_uid_only();
-
-       for (i=0; i<lck->num_share_modes; i++) {
-               struct share_mode_entry *e = &lck->share_modes[i];
-               int j;
-               struct process_id *tmp;
-
-               for (j=0; j<num_pids; j++) {
-                       if (procid_equal(&e->pid, &pids[j])) {
-                               break;
-                       }
-               }
-
-               if (j < num_pids) {
-                       /*
-                        * Already sent to that process, skip it
-                        */
-                       continue;
-               }
+       while (fsp->notify->requests != NULL) {
+               change_notify_reply_packet(
+                       fsp->notify->requests->request_buf, status);
+               change_notify_remove_request(fsp->notify->requests);
+       }
+}
 
-               message_send_pid(lck->share_modes[i].pid, MSG_SMB_NOTIFY,
-                                blob.data, blob.length, True);
+void notify_fname(connection_struct *conn, uint32 action, uint32 filter,
+                 const char *path)
+{
+       char *fullpath;
 
-               if (!(tmp = TALLOC_REALLOC_ARRAY(lck, pids, struct process_id,
-                                                num_pids+1))) {
-                       DEBUG(0, ("realloc failed\n"));
-                       break;
-               }
-               pids = tmp;
-               pids[num_pids] = e->pid;
-               num_pids += 1;
+       if (asprintf(&fullpath, "%s/%s", conn->connectpath, path) == -1) {
+               DEBUG(0, ("asprintf failed\n"));
+               return;
        }
 
-       unbecome_root_uid_only();
-
-       data_blob_free(&blob);
-       TALLOC_FREE(lck);
+       notify_trigger(conn->notify_ctx, action, filter, fullpath);
+       SAFE_FREE(fullpath);
 }
 
-static void notify_message(int msgtype, struct process_id pid,
-                          void *buf, size_t len)
+static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
 {
-       struct notify_message msg;
-       files_struct *fsp;
-       struct notify_change *changes, *change;
+       struct notify_change *change, *changes;
+       char *tmp;
 
-       if (!buf_to_notify_message(buf, len, &msg)) {
+       if (fsp->notify == NULL) {
+               /*
+                * Nobody is waiting, don't queue
+                */
                return;
        }
 
-       DEBUG(10, ("Received notify_message for 0x%x/%.0f: %d\n",
-                  (unsigned)msg.dev, (double)msg.inode, msg.action));
+       /*
+        * Someone has triggered a notify previously, queue the change for
+        * later.
+        */
 
-       if (!(fsp = file_find_dir_lowest_id(msg.dev, msg.inode))) {
-               DEBUG(10, ("notify_message: did not find fsp\n"));
+       if ((fsp->notify->num_changes > 1000) || (name == NULL)) {
+               /*
+                * The real number depends on the client buf, just provide a
+                * guard against a DoS here.
+                */
+               TALLOC_FREE(fsp->notify->changes);
+               fsp->notify->num_changes = -1;
+               return;
+       }
+
+       if (fsp->notify->num_changes == -1) {
                return;
        }
 
@@ -488,38 +398,107 @@ static void notify_message(int msgtype, struct process_id pid,
 
        change = &(fsp->notify->changes[fsp->notify->num_changes]);
 
-       if (!(change->name = talloc_strdup(changes, msg.name))) {
+       if (!(tmp = talloc_strdup(changes, name))) {
                DEBUG(0, ("talloc_strdup failed\n"));
                return;
        }
-       change->action = msg.action;
+
+       string_replace(tmp, '/', '\\');
+       change->name = tmp;     
+
+       change->action = action;
        fsp->notify->num_changes += 1;
+
+       if (fsp->notify->requests == NULL) {
+               /*
+                * Nobody is waiting, so don't send anything. The ot
+                */
+               return;
+       }
+
+       if (action == NOTIFY_ACTION_OLD_NAME) {
+               /*
+                * We have to send the two rename events in one reply. So hold
+                * the first part back.
+                */
+               return;
+       }
+
+       /*
+        * Someone is waiting for the change, trigger the reply immediately.
+        *
+        * TODO: do we have to walk the lists of requests pending?
+        */
+
+       change_notify_reply(fsp->notify->requests->request_buf,
+                           fsp->notify);
+
+       change_notify_remove_request(fsp->notify->requests);
 }
 
-/****************************************************************************
- Initialise the change notify subsystem.
-****************************************************************************/
+char *notify_filter_string(TALLOC_CTX *mem_ctx, uint32 filter)
+{
+       char *result = NULL;
+
+       result = talloc_strdup(mem_ctx, "");
+
+       if (filter & FILE_NOTIFY_CHANGE_FILE_NAME)
+               result = talloc_asprintf_append(result, "FILE_NAME|");
+       if (filter & FILE_NOTIFY_CHANGE_DIR_NAME)
+               result = talloc_asprintf_append(result, "DIR_NAME|");
+       if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
+               result = talloc_asprintf_append(result, "ATTRIBUTES|");
+       if (filter & FILE_NOTIFY_CHANGE_SIZE)
+               result = talloc_asprintf_append(result, "SIZE|");
+       if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
+               result = talloc_asprintf_append(result, "LAST_WRITE|");
+       if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
+               result = talloc_asprintf_append(result, "LAST_ACCESS|");
+       if (filter & FILE_NOTIFY_CHANGE_CREATION)
+               result = talloc_asprintf_append(result, "CREATION|");
+       if (filter & FILE_NOTIFY_CHANGE_EA)
+               result = talloc_asprintf_append(result, "EA|");
+       if (filter & FILE_NOTIFY_CHANGE_SECURITY)
+               result = talloc_asprintf_append(result, "SECURITY|");
+       if (filter & FILE_NOTIFY_CHANGE_STREAM_NAME)
+               result = talloc_asprintf_append(result, "STREAM_NAME|");
+       if (filter & FILE_NOTIFY_CHANGE_STREAM_SIZE)
+               result = talloc_asprintf_append(result, "STREAM_SIZE|");
+       if (filter & FILE_NOTIFY_CHANGE_STREAM_WRITE)
+               result = talloc_asprintf_append(result, "STREAM_WRITE|");
+
+       if (result == NULL) return NULL;
+       if (*result == '\0') return result;
+
+       result[strlen(result)-1] = '\0';
+       return result;
+}
 
-BOOL init_change_notify(void)
+struct sys_notify_context *sys_notify_context_create(connection_struct *conn,
+                                                    TALLOC_CTX *mem_ctx, 
+                                                    struct event_context *ev)
 {
-       cnotify = NULL;
-
-#if HAVE_KERNEL_CHANGE_NOTIFY
-       if (cnotify == NULL && lp_kernel_change_notify())
-               cnotify = kernel_notify_init();
-#endif
-#if HAVE_FAM_CHANGE_NOTIFY
-       if (cnotify == NULL && lp_fam_change_notify())
-               cnotify = fam_notify_init();
-#endif
-       if (!cnotify) cnotify = hash_notify_init();
-       
-       if (!cnotify) {
-               DEBUG(0,("Failed to init change notify system\n"));
-               return False;
+       struct sys_notify_context *ctx;
+
+       if (!(ctx = TALLOC_P(mem_ctx, struct sys_notify_context))) {
+               DEBUG(0, ("talloc failed\n"));
+               return NULL;
        }
 
-       message_register(MSG_SMB_NOTIFY, notify_message);
+       ctx->ev = ev;
+       ctx->conn = conn;
+       ctx->private_data = NULL;
+       return ctx;
+}
 
-       return True;
+NTSTATUS sys_notify_watch(struct sys_notify_context *ctx,
+                         struct notify_entry *e,
+                         void (*callback)(struct sys_notify_context *ctx, 
+                                          void *private_data,
+                                          struct notify_event *ev),
+                         void *private_data, void *handle)
+{
+       return SMB_VFS_NOTIFY_WATCH(ctx->conn, ctx, e, callback, private_data,
+                                   handle);
 }
+