r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[tprouty/samba.git] / source / smbd / notify.c
index 97192d6e63c34b13d257615ebb2618b8c5b81850..6ab4266c19f04410cdc49b9bea876a10ec19bdf1 100644 (file)
@@ -7,7 +7,7 @@
 
    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;
+
+struct notify_change_request {
+       struct notify_change_request *prev, *next;
+       struct files_struct *fsp;       /* backpointer for cancel by mid */
+       char request_buf[smb_size];
+       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;
 
 /*
@@ -36,6 +49,17 @@ struct notify_mid_map {
        uint16 mid;
 };
 
+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(int num_changes,
                                    struct notify_change *changes,
                                    prs_struct *ps)
@@ -44,11 +68,20 @@ static BOOL notify_marshall_changes(int num_changes,
        UNISTR uni_name;
 
        for (i=0; i<num_changes; i++) {
-               struct notify_change *c = &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);
@@ -95,6 +128,7 @@ static BOOL notify_marshall_changes(int num_changes,
 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));
@@ -106,7 +140,7 @@ static void change_notify_reply_packet(const char *request_buf,
         * 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))
@@ -114,25 +148,28 @@ static void change_notify_reply_packet(const char *request_buf,
                                    "failed.");
 }
 
-void change_notify_reply(const char *request_buf, uint32 max_param_count,
-                        int num_changes, struct notify_change *changes)
+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+max_param_count;
+       size_t buflen;
 
-       if (num_changes == -1) {
+       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(num_changes, changes, &ps)) {
+           || !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) > 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.
@@ -148,7 +185,7 @@ void change_notify_reply(const char *request_buf, uint32 max_param_count,
 
        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.");
        }
@@ -156,10 +193,54 @@ void change_notify_reply(const char *request_buf, uint32 max_param_count,
  done:
        SAFE_FREE(outbuf);
        prs_mem_free(&ps);
+
+       TALLOC_FREE(notify_buf->changes);
+       notify_buf->num_changes = 0;
 }
 
-NTSTATUS change_notify_add_request(const char *inbuf, uint32 max_param_count,
-                                  uint32 filter, struct files_struct *fsp)
+static void notify_callback(void *private_data, const struct notify_event *e)
+{
+       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);
+}
+
+NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
+                             BOOL recursive)
+{
+       char *fullpath;
+       struct notify_entry e;
+       NTSTATUS status;
+
+       SMB_ASSERT(fsp->notify == NULL);
+
+       if (!(fsp->notify = TALLOC_ZERO_P(NULL, struct notify_change_buf))) {
+               DEBUG(0, ("talloc failed\n"));
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       if (asprintf(&fullpath, "%s/%s", fsp->conn->connectpath,
+                    fsp->fsp_name) == -1) {
+               DEBUG(0, ("asprintf failed\n"));
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       e.path = fullpath;
+       e.filter = filter;
+       e.subdir_filter = 0;
+       if (recursive) {
+               e.subdir_filter = filter;
+       }
+
+       status = notify_add(fsp->conn->notify_ctx, &e, notify_callback, fsp);
+       SAFE_FREE(fullpath);
+
+       return status;
+}
+
+NTSTATUS change_notify_add_request(const char *inbuf, 
+                                  uint32 filter, BOOL recursive,
+                                  struct files_struct *fsp)
 {
        struct notify_change_request *request = NULL;
        struct notify_mid_map *map = NULL;
@@ -174,12 +255,10 @@ NTSTATUS change_notify_add_request(const char *inbuf, uint32 max_param_count,
        map->req = request;
 
        memcpy(request->request_buf, inbuf, sizeof(request->request_buf));
-       request->max_param_count = max_param_count;
+       request->current_bufsize = 0;
        request->filter = filter;
        request->fsp = fsp;
-
-       request->backend_data = cnotify->notify_add(NULL, smbd_event_context(),
-                                                   fsp, &request->filter);
+       request->backend_data = NULL;
        
        DLIST_ADD_END(fsp->notify->requests, request,
                      struct notify_change_request *);
@@ -213,7 +292,7 @@ static void change_notify_remove_request(struct notify_change_request *remove_re
        }
 
        if (req == NULL) {
-               smb_panic("notify_req not found in fsp's requests\n");
+               smb_panic("notify_req not found in fsp's requests");
        }
 
        DLIST_REMOVE(fsp->notify->requests, req);
@@ -263,162 +342,24 @@ void remove_pending_change_notify_requests_by_fid(files_struct *fsp,
        }
 }
 
-/* notify message definition
-
-Offset  Data                   length.
-0      SMB_DEV_T dev           8
-8      SMB_INO_T inode         8
-16     uint32 filter           4
-20     uint32 action           4
-24..   name
-*/
-
-#define MSG_NOTIFY_MESSAGE_SIZE 25 /* Includes at least the '\0' terminator */
-
-struct notify_message {
-       SMB_DEV_T dev;
-       SMB_INO_T inode;
-       uint32 filter;
-       uint32 action;
-       char *name;
-};
-
-static DATA_BLOB notify_message_to_buf(const struct notify_message *msg)
-{
-       DATA_BLOB result;
-       size_t len;
-
-       len = strlen(msg->name);
-
-       result = data_blob(NULL, MSG_NOTIFY_MESSAGE_SIZE + len);
-       if (!result.data) {
-               return result;
-       }
-
-       SDEV_T_VAL(result.data, 0, msg->dev);
-       SINO_T_VAL(result.data, 8, msg->inode);
-       SIVAL(result.data, 16, msg->filter);
-       SIVAL(result.data, 20, msg->action);
-       memcpy(result.data+24, 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",
-                         (int)len));
-               return False;
-       }
-
-       msg->dev     = DEV_T_VAL(buf, 0);
-       msg->inode   = INO_T_VAL(buf, 8);
-       msg->filter  = IVAL(buf, 16);
-       msg->action  = IVAL(buf, 20);
-       msg->name    = ((char *)buf)+24;
-       return True;
-}
-
-void notify_action(connection_struct *conn, const char *parent,
-                  const char *name, uint32 filter, uint32_t action)
-{
-       struct share_mode_lock *lck;
-       SMB_STRUCT_STAT sbuf;
-       int i;
-       struct notify_message msg;
-       DATA_BLOB blob;
-
-       struct process_id *pids;
-       int num_pids;
-
-       DEBUG(10, ("notify_action: parent=%s, name=%s, action=%u\n",
-                  parent, name, (unsigned)action));
-
-       if (SMB_VFS_STAT(conn, parent, &sbuf) != 0) {
-               /*
-                * Not 100% critical, ignore failure
-                */
-               return;
-       }
-
-       if (!(lck = get_share_mode_lock(NULL, sbuf.st_dev, sbuf.st_ino,
-                                       NULL, NULL))) {
-               return;
-       }
-
-       msg.dev = sbuf.st_dev;
-       msg.inode = sbuf.st_ino;
-       msg.filter = filter;
-       msg.action = action;
-       msg.name = CONST_DISCARD(char *, name);
-
-       blob = notify_message_to_buf(&msg);
-       if (blob.data == NULL) {
-               DEBUG(0, ("notify_message_to_buf failed\n"));
-               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;
-               }
-
-               message_send_pid(lck->share_modes[i].pid, MSG_SMB_NOTIFY,
-                                blob.data, blob.length, True);
-
-               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;
-       }
-
-       unbecome_root_uid_only();
-
-       data_blob_free(&blob);
-       TALLOC_FREE(lck);
-}
-
-void notify_fname(connection_struct *conn, const char *path,
-                 uint32 filter, uint32 action)
+void notify_fname(connection_struct *conn, uint32 action, uint32 filter,
+                 const char *path)
 {
-       char *parent;
-       const char *name;
+       char *fullpath;
 
-       if (!parent_dirname_talloc(tmp_talloc_ctx(), path, &parent, &name)) {
+       if (asprintf(&fullpath, "%s/%s", conn->connectpath, path) == -1) {
+               DEBUG(0, ("asprintf failed\n"));
                return;
        }
 
-       notify_action(conn, parent, name, filter, action);
-       TALLOC_FREE(parent);
+       notify_trigger(conn->notify_ctx, action, filter, fullpath);
+       SAFE_FREE(fullpath);
 }
 
-void notify_fsp(files_struct *fsp, uint32 action, char *name)
+static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
 {
        struct notify_change *change, *changes;
+       char *tmp;
 
        if (fsp->notify == NULL) {
                /*
@@ -427,45 +368,15 @@ void notify_fsp(files_struct *fsp, uint32 action, char *name)
                return;
        }
 
-       if (fsp->notify->requests != NULL) {
-               /*
-                * Someone is waiting for the change, trigger the reply
-                * immediately.
-                *
-                * TODO: do we have to walk the lists of requests pending?
-                */
-
-               struct notify_change_request *req = fsp->notify->requests;
-               struct notify_change onechange;
-
-               if (name == NULL) {
-                       /*
-                        * Catch-all change, possibly from notify_hash.c
-                        */
-                       change_notify_reply(req->request_buf,
-                                           req->max_param_count,
-                                           -1, NULL);
-                       return;
-               }
-
-               onechange.action = action;
-               onechange.name = name;
-
-               change_notify_reply(req->request_buf, req->max_param_count,
-                                   1, &onechange);
-               change_notify_remove_request(req);
-               return;
-       }
-
        /*
         * Someone has triggered a notify previously, queue the change for
-        * later. TODO: Limit the number of changes queued, test how filters
-        * apply here. Do we have to store them?
+        * later.
         */
 
-       if ((fsp->notify->num_changes > 30) || (name == NULL)) {
+       if ((fsp->notify->num_changes > 1000) || (name == NULL)) {
                /*
-                * W2k3 seems to store at most 30 changes.
+                * 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;
@@ -487,69 +398,83 @@ void notify_fsp(files_struct *fsp, uint32 action, char *name)
 
        change = &(fsp->notify->changes[fsp->notify->num_changes]);
 
-       if (!(change->name = talloc_strdup(changes, name))) {
+       if (!(tmp = talloc_strdup(changes, name))) {
                DEBUG(0, ("talloc_strdup failed\n"));
                return;
        }
-       change->action = action;
-       fsp->notify->num_changes += 1;
 
-       return;
-}
+       string_replace(tmp, '/', '\\');
+       change->name = tmp;     
 
-static void notify_message_callback(int msgtype, struct process_id pid,
-                                   void *buf, size_t len,
-                                   void *private_data)
-{
-       struct notify_message msg;
-       files_struct *fsp;
+       change->action = action;
+       fsp->notify->num_changes += 1;
 
-       if (!buf_to_notify_message(buf, len, &msg)) {
+       if (fsp->notify->requests == NULL) {
+               /*
+                * Nobody is waiting, so don't send anything. The ot
+                */
                return;
        }
 
-       DEBUG(10, ("Received notify_message for 0x%x/%.0f: %d\n",
-                  (unsigned)msg.dev, (double)msg.inode, msg.action));
-
-       for(fsp = fsp_find_di_first(msg.dev, msg.inode); fsp;
-           fsp = fsp_find_di_next(fsp)) {
-               if ((fsp->notify != NULL) 
-                   && (fsp->notify->requests != NULL)
-                   && (fsp->notify->requests->filter & msg.filter)) {
-                       notify_fsp(fsp, msg.action, msg.name);
-               }
+       if (action == NOTIFY_ACTION_OLD_NAME) {
+               /*
+                * We have to send the two rename events in one reply. So hold
+                * the first part back.
+                */
+               return;
        }
-}
 
-/****************************************************************************
- Initialise the change notify subsystem.
-****************************************************************************/
+       /*
+        * Someone is waiting for the change, trigger the reply immediately.
+        *
+        * TODO: do we have to walk the lists of requests pending?
+        */
 
-BOOL init_change_notify(void)
-{
-       cnotify = NULL;
-
-#if HAVE_KERNEL_CHANGE_NOTIFY
-       if (cnotify == NULL && lp_kernel_change_notify())
-               cnotify = kernel_notify_init(smbd_event_context());
-#endif
-#if HAVE_FAM_CHANGE_NOTIFY
-       if (cnotify == NULL && lp_fam_change_notify())
-               cnotify = fam_notify_init(smbd_event_context());
-#endif
-       if (!cnotify) cnotify = hash_notify_init();
-       
-       if (!cnotify) {
-               DEBUG(0,("Failed to init change notify system\n"));
-               return False;
-       }
+       change_notify_reply(fsp->notify->requests->request_buf,
+                           fsp->notify);
 
-       message_register(MSG_SMB_NOTIFY, notify_message_callback, NULL);
+       change_notify_remove_request(fsp->notify->requests);
+}
 
-       return True;
+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;
 }
 
-struct sys_notify_context *sys_notify_context_create(struct share_params *scfg,
+struct sys_notify_context *sys_notify_context_create(connection_struct *conn,
                                                     TALLOC_CTX *mem_ctx, 
                                                     struct event_context *ev)
 {
@@ -561,6 +486,7 @@ struct sys_notify_context *sys_notify_context_create(struct share_params *scfg,
        }
 
        ctx->ev = ev;
+       ctx->conn = conn;
        ctx->private_data = NULL;
        return ctx;
 }
@@ -572,6 +498,7 @@ NTSTATUS sys_notify_watch(struct sys_notify_context *ctx,
                                           struct notify_event *ev),
                          void *private_data, void *handle)
 {
-       return inotify_watch(ctx, e, callback, private_data, handle);
+       return SMB_VFS_NOTIFY_WATCH(ctx->conn, ctx, e, callback, private_data,
+                                   handle);
 }