s3-talloc Change TALLOC_P() to talloc()
[nivanova/samba-autobuild/.git] / source3 / smbd / notify.c
index cbafeccd943521e309268cd357783a8dca087418..a70f86df007b486f1e2e9e5fd95ef70bbab96c49 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"
-
-/* Max size we can send to client in a notify response. */
-extern int max_send;
+#include "smbd/smbd.h"
+#include "smbd/globals.h"
+#include "../librpc/gen_ndr/ndr_notify.h"
 
 struct notify_change_request {
        struct notify_change_request *prev, *next;
        struct files_struct *fsp;       /* backpointer for cancel by mid */
-       char request_buf[smb_size];
+       struct smb_request *req;
        uint32 filter;
-       uint32 current_bufsize;
+       uint32 max_param;
+       void (*reply_fn)(struct smb_request *req,
+                        NTSTATUS error_code,
+                        uint8_t *buf, size_t len);
        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.
@@ -47,10 +47,10 @@ static struct notify_mid_map *notify_changes_by_mid;
 struct notify_mid_map {
        struct notify_mid_map *prev, *next;
        struct notify_change_request *req;
-       uint16 mid;
+       uint64_t mid;
 };
 
-static BOOL notify_change_record_identical(struct notify_change *c1,
+static bool notify_change_record_identical(struct notify_change *c1,
                                        struct notify_change *c2)
 {
        /* Note this is deliberately case sensitive. */
@@ -61,18 +61,22 @@ static BOOL notify_change_record_identical(struct notify_change *c1,
        return False;
 }
 
-static BOOL notify_marshall_changes(int num_changes,
-                                   struct notify_change *changes,
-                                   prs_struct *ps)
+static bool notify_marshall_changes(int num_changes,
+                               uint32 max_offset,
+                               struct notify_change *changes,
+                               DATA_BLOB *final_blob)
 {
        int i;
-       UNISTR uni_name;
+
+       if (num_changes == -1) {
+               return false;
+       }
 
        for (i=0; i<num_changes; i++) {
+               enum ndr_err_code ndr_err;
                struct notify_change *c;
-               size_t namelen;
-               uint32 u32_tmp; /* Temp arg to prs_uint32 to avoid
-                                * signed/unsigned issues */
+               struct FILE_NOTIFY_INFORMATION m;
+               DATA_BLOB blob;
 
                /* Coalesce any identical records. */
                while (i+1 < num_changes &&
@@ -83,117 +87,81 @@ static BOOL notify_marshall_changes(int num_changes,
 
                c = &changes[i];
 
-               namelen = convert_string_allocate(
-                       NULL, CH_UNIX, CH_UTF16LE, c->name, strlen(c->name)+1,
-                       &uni_name.buffer, True);
-               if ((namelen == -1) || (uni_name.buffer == NULL)) {
-                       goto fail;
-               }
-
-               namelen -= 2;   /* Dump NULL termination */
+               m.FileName1 = c->name;
+               m.FileNameLength = strlen_m(c->name)*2;
+               m.Action = c->action;
+               m.NextEntryOffset = (i == num_changes-1) ? 0 : ndr_size_FILE_NOTIFY_INFORMATION(&m, 0);
 
                /*
                 * Offset to next entry, only if there is one
                 */
 
-               u32_tmp = (i == num_changes-1) ? 0 : namelen + 12;
-               if (!prs_uint32("offset", ps, 1, &u32_tmp)) goto fail;
-
-               u32_tmp = c->action;
-               if (!prs_uint32("action", ps, 1, &u32_tmp)) goto fail;
+               ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), &m,
+                       (ndr_push_flags_fn_t)ndr_push_FILE_NOTIFY_INFORMATION);
+               if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                       return false;
+               }
 
-               u32_tmp = namelen;
-               if (!prs_uint32("namelen", ps, 1, &u32_tmp)) goto fail;
+               if (DEBUGLEVEL >= 10) {
+                       NDR_PRINT_DEBUG(FILE_NOTIFY_INFORMATION, &m);
+               }
 
-               if (!prs_unistr("name", ps, 1, &uni_name)) goto fail;
+               if (!data_blob_append(talloc_tos(), final_blob,
+                                     blob.data, blob.length)) {
+                       data_blob_free(&blob);
+                       return false;
+               }
 
-               /*
-                * Not NULL terminated, decrease by the 2 UCS2 \0 chars
-                */
-               prs_set_offset(ps, prs_offset(ps)-2);
+               data_blob_free(&blob);
 
-               SAFE_FREE(uni_name.buffer);
+               if (final_blob->length > max_offset) {
+                       /* Too much data for client. */
+                       DEBUG(10, ("Client only wanted %d bytes, trying to "
+                                  "marshall %d bytes\n", (int)max_offset,
+                                  (int)final_blob->length));
+                       return False;
+               }
        }
 
        return True;
-
- fail:
-       SAFE_FREE(uni_name.buffer);
-       return False;
 }
 
 /****************************************************************************
  Setup the common parts of the return packet and send it.
 *****************************************************************************/
 
-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(request_buf, outbuf);
-
-       ERROR_NT(error_code);
-
-       /*
-        * Seems NT needs a transact command with an error code
-        * in it. This is a longer packet than a simple error.
-        */
-       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.");
-}
-
-void change_notify_reply(const char *request_buf,
-                        struct notify_change_buf *notify_buf)
+void change_notify_reply(struct smb_request *req,
+                        NTSTATUS error_code,
+                        uint32_t max_param,
+                        struct notify_change_buf *notify_buf,
+                        void (*reply_fn)(struct smb_request *req,
+                                         NTSTATUS error_code,
+                                         uint8_t *buf, size_t len))
 {
-       char *outbuf = NULL;
-       prs_struct ps;
-       size_t buflen;
+       DATA_BLOB blob = data_blob_null;
 
-       if (notify_buf->num_changes == -1) {
-               change_notify_reply_packet(request_buf, NT_STATUS_OK);
+       if (!NT_STATUS_IS_OK(error_code)) {
+               reply_fn(req, error_code, NULL, 0);
                return;
        }
 
-       if (!prs_init(&ps, 0, NULL, False)
-           || !notify_marshall_changes(notify_buf->num_changes,
-                                       notify_buf->changes, &ps)) {
-               change_notify_reply_packet(request_buf, NT_STATUS_NO_MEMORY);
-               goto done;
+       if (max_param == 0 || notify_buf == NULL) {
+               reply_fn(req, NT_STATUS_OK, NULL, 0);
+               return;
        }
 
-       buflen = smb_size+38+prs_offset(&ps) + 4 /* padding */;
-
-       if (buflen > max_send) {
+       if (!notify_marshall_changes(notify_buf->num_changes, max_param,
+                                       notify_buf->changes, &blob)) {
                /*
                 * We exceed what the client is willing to accept. Send
                 * nothing.
                 */
-               change_notify_reply_packet(request_buf, NT_STATUS_OK);
-               goto done;
+               data_blob_free(&blob);
        }
 
-       if (!(outbuf = SMB_MALLOC_ARRAY(char, buflen))) {
-               change_notify_reply_packet(request_buf, NT_STATUS_NO_MEMORY);
-               goto done;
-       }
+       reply_fn(req, NT_STATUS_OK, blob.data, blob.length);
 
-       construct_reply_common(request_buf, outbuf);
-
-       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.");
-       }
-
- done:
-       SAFE_FREE(outbuf);
-       prs_mem_free(&ps);
+       data_blob_free(&blob);
 
        TALLOC_FREE(notify_buf->changes);
        notify_buf->num_changes = 0;
@@ -202,12 +170,12 @@ void change_notify_reply(const char *request_buf,
 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));
+       DEBUG(10, ("notify_callback called for %s\n", fsp_str_dbg(fsp)));
        notify_fsp(fsp, e->action, e->path);
 }
 
 NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
-                             BOOL recursive)
+                             bool recursive)
 {
        char *fullpath;
        struct notify_entry e;
@@ -220,13 +188,18 @@ NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
                return NT_STATUS_NO_MEMORY;
        }
 
+       /* Do notify operations on the base_name. */
        if (asprintf(&fullpath, "%s/%s", fsp->conn->connectpath,
-                    fsp->fsp_name) == -1) {
+                    fsp->fsp_name->base_name) == -1) {
                DEBUG(0, ("asprintf failed\n"));
+               TALLOC_FREE(fsp->notify);
                return NT_STATUS_NO_MEMORY;
        }
 
+       ZERO_STRUCT(e);
        e.path = fullpath;
+       e.dir_fd = fsp->fh->fd;
+       e.dir_id = fsp->file_id;
        e.filter = filter;
        e.subdir_filter = 0;
        if (recursive) {
@@ -239,41 +212,48 @@ NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
        return status;
 }
 
-NTSTATUS change_notify_add_request(const char *inbuf, 
-                                  uint32 filter, BOOL recursive,
-                                  struct files_struct *fsp)
+NTSTATUS change_notify_add_request(struct smb_request *req,
+                               uint32 max_param,
+                               uint32 filter, bool recursive,
+                               struct files_struct *fsp,
+                               void (*reply_fn)(struct smb_request *req,
+                                       NTSTATUS error_code,
+                                       uint8_t *buf, size_t len))
 {
        struct notify_change_request *request = NULL;
        struct notify_mid_map *map = NULL;
+       struct smbd_server_connection *sconn = req->sconn;
 
-       if (!(request = SMB_MALLOC_P(struct notify_change_request))
-           || !(map = SMB_MALLOC_P(struct notify_mid_map))) {
-               SAFE_FREE(request);
+       DEBUG(10, ("change_notify_add_request: Adding request for %s: "
+                  "max_param = %d\n", fsp_str_dbg(fsp), (int)max_param));
+
+       if (!(request = talloc(NULL, struct notify_change_request))
+           || !(map = talloc(request, struct notify_mid_map))) {
+               TALLOC_FREE(request);
                return NT_STATUS_NO_MEMORY;
        }
 
        request->mid_map = map;
        map->req = request;
 
-       memcpy(request->request_buf, inbuf, sizeof(request->request_buf));
-       request->current_bufsize = 0;
+       request->req = talloc_move(request, &req);
+       request->max_param = max_param;
        request->filter = filter;
        request->fsp = fsp;
+       request->reply_fn = reply_fn;
        request->backend_data = NULL;
-       
+
        DLIST_ADD_END(fsp->notify->requests, request,
                      struct notify_change_request *);
 
-       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));
+       map->mid = request->req->mid;
+       DLIST_ADD(sconn->smb1.notify_mid_maps, map);
 
        return NT_STATUS_OK;
 }
 
-static void change_notify_remove_request(struct notify_change_request *remove_req)
+static void change_notify_remove_request(struct smbd_server_connection *sconn,
+                                        struct notify_change_request *remove_req)
 {
        files_struct *fsp;
        struct notify_change_request *req;
@@ -297,21 +277,20 @@ static void change_notify_remove_request(struct notify_change_request *remove_re
        }
 
        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);
+       DLIST_REMOVE(sconn->smb1.notify_mid_maps, req->mid_map);
+       TALLOC_FREE(req);
 }
 
 /****************************************************************************
  Delete entries by mid from the change notify pending queue. Always send reply.
 *****************************************************************************/
 
-void remove_pending_change_notify_requests_by_mid(uint16 mid)
+void remove_pending_change_notify_requests_by_mid(
+       struct smbd_server_connection *sconn, uint64_t mid)
 {
        struct notify_mid_map *map;
 
-       for (map = notify_changes_by_mid; map; map = map->next) {
+       for (map = sconn->smb1.notify_mid_maps; map; map = map->next) {
                if (map->mid == mid) {
                        break;
                }
@@ -321,8 +300,29 @@ void remove_pending_change_notify_requests_by_mid(uint16 mid)
                return;
        }
 
-       change_notify_reply_packet(map->req->request_buf, NT_STATUS_CANCELLED);
-       change_notify_remove_request(map->req);
+       change_notify_reply(map->req->req,
+                           NT_STATUS_CANCELLED, 0, NULL, map->req->reply_fn);
+       change_notify_remove_request(sconn, map->req);
+}
+
+void smbd_notify_cancel_by_smbreq(const struct smb_request *smbreq)
+{
+       struct smbd_server_connection *sconn = smbreq->sconn;
+       struct notify_mid_map *map;
+
+       for (map = sconn->smb1.notify_mid_maps; map; map = map->next) {
+               if (map->req->req == smbreq) {
+                       break;
+               }
+       }
+
+       if (map == NULL) {
+               return;
+       }
+
+       change_notify_reply(map->req->req,
+                           NT_STATUS_CANCELLED, 0, NULL, map->req->reply_fn);
+       change_notify_remove_request(sconn, map->req);
 }
 
 /****************************************************************************
@@ -337,9 +337,11 @@ void remove_pending_change_notify_requests_by_fid(files_struct *fsp,
        }
 
        while (fsp->notify->requests != NULL) {
-               change_notify_reply_packet(
-                       fsp->notify->requests->request_buf, status);
-               change_notify_remove_request(fsp->notify->requests);
+               change_notify_reply(fsp->notify->requests->req,
+                                   status, 0, NULL,
+                                   fsp->notify->requests->reply_fn);
+               change_notify_remove_request(fsp->conn->sconn,
+                                            fsp->notify->requests);
        }
 }
 
@@ -347,14 +349,33 @@ void notify_fname(connection_struct *conn, uint32 action, uint32 filter,
                  const char *path)
 {
        char *fullpath;
+       char *parent;
+       const char *name;
+
+       if (path[0] == '.' && path[1] == '/') {
+               path += 2;
+       }
+       if (parent_dirname(talloc_tos(), path, &parent, &name)) {
+               struct smb_filename smb_fname_parent;
+
+               ZERO_STRUCT(smb_fname_parent);
+               smb_fname_parent.base_name = parent;
 
-       if (asprintf(&fullpath, "%s/%s", conn->connectpath, path) == -1) {
+               if (SMB_VFS_STAT(conn, &smb_fname_parent) != -1) {
+                       notify_onelevel(conn->notify_ctx, action, filter,
+                           SMB_VFS_FILE_ID_CREATE(conn, &smb_fname_parent.st),
+                           name);
+               }
+       }
+
+       fullpath = talloc_asprintf(talloc_tos(), "%s/%s", conn->connectpath,
+                                  path);
+       if (fullpath == NULL) {
                DEBUG(0, ("asprintf failed\n"));
                return;
        }
-
        notify_trigger(conn->notify_ctx, action, filter, fullpath);
-       SAFE_FREE(fullpath);
+       TALLOC_FREE(fullpath);
 }
 
 static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
@@ -377,18 +398,33 @@ static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
        if ((fsp->notify->num_changes > 1000) || (name == NULL)) {
                /*
                 * The real number depends on the client buf, just provide a
-                * guard against a DoS here.
+                * guard against a DoS here.  If name == NULL the CN backend is
+                * alerting us to a problem.  Possibly dropped events.  Clear
+                * queued changes and send the catch-all response to the client
+                * if a request is pending.
                 */
                TALLOC_FREE(fsp->notify->changes);
                fsp->notify->num_changes = -1;
+               if (fsp->notify->requests != NULL) {
+                       change_notify_reply(fsp->notify->requests->req,
+                                           NT_STATUS_OK,
+                                           fsp->notify->requests->max_param,
+                                           fsp->notify,
+                                           fsp->notify->requests->reply_fn);
+                       change_notify_remove_request(fsp->conn->sconn,
+                                                    fsp->notify->requests);
+               }
                return;
        }
 
+       /* If we've exceeded the server side queue or received a NULL name
+        * from the underlying CN implementation, don't queue up any more
+        * requests until we can send a catch-all response to the client */
        if (fsp->notify->num_changes == -1) {
                return;
        }
 
-       if (!(changes = TALLOC_REALLOC_ARRAY(
+       if (!(changes = talloc_realloc(
                      fsp->notify, fsp->notify->changes,
                      struct notify_change, fsp->notify->num_changes+1))) {
                DEBUG(0, ("talloc_realloc failed\n"));
@@ -431,10 +467,13 @@ static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
         * TODO: do we have to walk the lists of requests pending?
         */
 
-       change_notify_reply(fsp->notify->requests->request_buf,
-                           fsp->notify);
+       change_notify_reply(fsp->notify->requests->req,
+                           NT_STATUS_OK,
+                           fsp->notify->requests->max_param,
+                           fsp->notify,
+                           fsp->notify->requests->reply_fn);
 
-       change_notify_remove_request(fsp->notify->requests);
+       change_notify_remove_request(fsp->conn->sconn, fsp->notify->requests);
 }
 
 char *notify_filter_string(TALLOC_CTX *mem_ctx, uint32 filter)
@@ -481,7 +520,7 @@ struct sys_notify_context *sys_notify_context_create(connection_struct *conn,
 {
        struct sys_notify_context *ctx;
 
-       if (!(ctx = TALLOC_P(mem_ctx, struct sys_notify_context))) {
+       if (!(ctx = talloc(mem_ctx, struct sys_notify_context))) {
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }