X-Git-Url: http://git.samba.org/?a=blobdiff_plain;f=source3%2Fsmbd%2Fnotify.c;h=bf3fff7b97db7f00e54bfb5422b869610c28f0f0;hb=11f2583420310e0278188935f31be3131eb85fd4;hp=5a517654bf363b2db5a4d9c9e958baf4a464a8c3;hpb=4f2635b729e636e123afacb0970c3d49343b3e90;p=samba.git

diff --git a/source3/smbd/notify.c b/source3/smbd/notify.c
index 5a517654bf3..bf3fff7b97d 100644
--- a/source3/smbd/notify.c
+++ b/source3/smbd/notify.c
@@ -20,20 +20,77 @@
 */
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "smbd/globals.h"
+#include "../librpc/gen_ndr/ndr_notify.h"
+#include "librpc/gen_ndr/ndr_file_id.h"
+
+struct notify_change_event {
+	struct timespec when;
+	uint32_t action;
+	const char *name;
+};
+
+struct notify_change_buf {
+	/*
+	 * Filters for reinitializing after notifyd has been restarted
+	 */
+	uint32_t filter;
+	uint32_t subdir_filter;
+
+	/*
+	 * If no requests are pending, changes are queued here. Simple array,
+	 * we only append.
+	 */
+
+	uint32_t max_buffer_size;
+
+	/*
+	 * num_changes == -1 means that we have got a catch-all change, when
+	 * asked we just return NT_STATUS_OK without specific changes.
+	 */
+	int num_changes;
+	struct notify_change_event *changes;
+
+	/*
+	 * If no changes are around requests are queued here. Using a linked
+	 * list, because we have to append at the end and delete from the top.
+	 */
+	struct notify_change_request *requests;
+};
 
 struct notify_change_request {
 	struct notify_change_request *prev, *next;
 	struct files_struct *fsp;	/* backpointer for cancel by mid */
 	struct smb_request *req;
-	uint32 filter;
-	uint32 max_param;
+	uint32_t filter;
+	uint32_t 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 void notify_fsp(files_struct *fsp, struct timespec when,
+		       uint32_t action, const char *name);
+
+bool change_notify_fsp_has_changes(struct files_struct *fsp)
+{
+	if (fsp == NULL) {
+		return false;
+	}
+
+	if (fsp->notify == NULL) {
+		return false;
+	}
+
+	if (fsp->notify->num_changes == 0) {
+		return false;
+	}
 
-static struct notify_mid_map *notify_changes_by_mid;
+	return true;
+}
 
 /*
  * For NTCancel, we need to find the notify_change_request indexed by
@@ -43,11 +100,11 @@ 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,
-					struct notify_change *c2)
+static bool notify_change_record_identical(struct notify_change_event *c1,
+					   struct notify_change_event *c2)
 {
 	/* Note this is deliberately case sensitive. */
 	if (c1->action == c2->action &&
@@ -57,21 +114,39 @@ static bool notify_change_record_identical(struct notify_change *c1,
 	return False;
 }
 
+static int compare_notify_change_events(const void *p1, const void *p2)
+{
+	const struct notify_change_event *e1 = p1;
+	const struct notify_change_event *e2 = p2;
+
+	return timespec_compare(&e1->when, &e2->when);
+}
+
 static bool notify_marshall_changes(int num_changes,
-				uint32 max_offset,
-				struct notify_change *changes,
-				prs_struct *ps)
+				uint32_t max_offset,
+				struct notify_change_event *changes,
+				DATA_BLOB *final_blob)
 {
 	int i;
-	UNISTR uni_name;
 
-	uni_name.buffer = NULL;
+	if (num_changes == -1) {
+		return false;
+	}
+
+	/*
+	 * Sort the notifies by timestamp when the event happened to avoid
+	 * coalescing and thus dropping events.
+	 */
+
+	qsort(changes, num_changes,
+	      sizeof(*changes), compare_notify_change_events);
 
 	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 */
+		enum ndr_err_code ndr_err;
+		struct notify_change_event *c;
+		struct FILE_NOTIFY_INFORMATION m;
+		DATA_BLOB blob;
+		uint16_t pad = 0;
 
 		/* Coalesce any identical records. */
 		while (i+1 < num_changes &&
@@ -82,161 +157,185 @@ static bool notify_marshall_changes(int num_changes,
 
 		c = &changes[i];
 
-		if (!convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE,
-			c->name, strlen(c->name)+1, &uni_name.buffer,
-			&namelen, True) || (uni_name.buffer == NULL)) {
-			goto fail;
-		}
+		m.FileName1 = c->name;
+		m.FileNameLength = strlen_m(c->name)*2;
+		m.Action = c->action;
 
-		namelen -= 2;	/* Dump NULL termination */
+		m._pad = data_blob_null;
 
 		/*
 		 * 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;
+		if (i == (num_changes-1)) {
+			m.NextEntryOffset = 0;
+		} else {
+			if ((m.FileNameLength % 4) == 2) {
+				m._pad = data_blob_const(&pad, 2);
+			}
+			m.NextEntryOffset =
+				ndr_size_FILE_NOTIFY_INFORMATION(&m, 0);
+		}
 
-		u32_tmp = namelen;
-		if (!prs_uint32("namelen", 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;
+		}
 
-		if (!prs_unistr("name", ps, 1, &uni_name)) goto fail;
+		if (DEBUGLEVEL >= 10) {
+			NDR_PRINT_DEBUG(FILE_NOTIFY_INFORMATION, &m);
+		}
 
-		/*
-		 * Not NULL terminated, decrease by the 2 UCS2 \0 chars
-		 */
-		prs_set_offset(ps, prs_offset(ps)-2);
+		if (!data_blob_append(talloc_tos(), final_blob,
+				      blob.data, blob.length)) {
+			data_blob_free(&blob);
+			return false;
+		}
 
-		SAFE_FREE(uni_name.buffer);
+		data_blob_free(&blob);
 
-		if (prs_offset(ps) > max_offset) {
+		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)prs_offset(ps)));
+				   (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(connection_struct *conn,
-				       struct smb_request *req,
-				       NTSTATUS error_code)
+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))
 {
-	reply_outbuf(req, 18, 0);
+	DATA_BLOB blob = data_blob_null;
 
 	if (!NT_STATUS_IS_OK(error_code)) {
-		error_packet_set((char *)req->outbuf, 0, 0, error_code,
-				 __LINE__,__FILE__);
-	}
-
-	show_msg((char *)req->outbuf);
-	if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
-			  req->encrypted)) {
-		exit_server_cleanly("change_notify_reply_packet: srv_send_smb "
-				    "failed.");
+		reply_fn(req, error_code, NULL, 0);
+		return;
 	}
-	TALLOC_FREE(req->outbuf);
-}
-
-void change_notify_reply(connection_struct *conn,
-			 struct smb_request *req, uint32 max_param,
-			 struct notify_change_buf *notify_buf)
-{
-	prs_struct ps;
 
-	if (notify_buf->num_changes == -1) {
-		change_notify_reply_packet(conn, req, NT_STATUS_OK);
-		notify_buf->num_changes = 0;
+	if (notify_buf == NULL) {
+		reply_fn(req, NT_STATUS_OK, NULL, 0);
 		return;
 	}
 
-	prs_init_empty(&ps, NULL, MARSHALL);
+	max_param = MIN(max_param, notify_buf->max_buffer_size);
 
 	if (!notify_marshall_changes(notify_buf->num_changes, max_param,
-					notify_buf->changes, &ps)) {
+					notify_buf->changes, &blob)) {
 		/*
 		 * We exceed what the client is willing to accept. Send
 		 * nothing.
 		 */
-		change_notify_reply_packet(conn, req, NT_STATUS_OK);
-		goto done;
+		data_blob_free(&blob);
 	}
 
-	send_nt_replies(conn, req, NT_STATUS_OK, prs_data_p(&ps),
-			prs_offset(&ps), NULL, 0);
+	reply_fn(req, NT_STATUS_OK, blob.data, blob.length);
 
- done:
-	prs_mem_free(&ps);
+	data_blob_free(&blob);
 
 	TALLOC_FREE(notify_buf->changes);
 	notify_buf->num_changes = 0;
 }
 
-static void notify_callback(void *private_data, const struct notify_event *e)
+struct notify_fsp_state {
+	struct files_struct *notified_fsp;
+	struct timespec when;
+	const struct notify_event *e;
+};
+
+static struct files_struct *notify_fsp_cb(struct files_struct *fsp,
+					  void *private_data)
 {
-	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);
+	struct notify_fsp_state *state = private_data;
+
+	if (fsp == state->notified_fsp) {
+		DBG_DEBUG("notify_callback called for %s\n", fsp_str_dbg(fsp));
+		notify_fsp(fsp, state->when, state->e->action, state->e->path);
+		return fsp;
+	}
+
+	return NULL;
 }
 
-NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
-			      bool recursive)
+void notify_callback(struct smbd_server_connection *sconn,
+		     void *private_data, struct timespec when,
+		     const struct notify_event *e)
 {
-	char *fullpath;
-	struct notify_entry e;
-	NTSTATUS status;
+	struct notify_fsp_state state = {
+		.notified_fsp = private_data, .when = when, .e = e
+	};
+	files_forall(sconn, notify_fsp_cb, &state);
+}
 
-	SMB_ASSERT(fsp->notify == NULL);
+NTSTATUS change_notify_create(struct files_struct *fsp,
+			      uint32_t max_buffer_size,
+			      uint32_t filter,
+			      bool recursive)
+{
+	size_t len = fsp_fullbasepath(fsp, NULL, 0);
+	char fullpath[len+1];
+	NTSTATUS status = NT_STATUS_NOT_IMPLEMENTED;
+
+	if (fsp->notify != NULL) {
+		DEBUG(1, ("change_notify_create: fsp->notify != NULL, "
+			  "fname = %s\n", fsp->fsp_name->base_name));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
 
-	if (!(fsp->notify = TALLOC_ZERO_P(NULL, struct notify_change_buf))) {
+	if (!(fsp->notify = talloc_zero(NULL, struct notify_change_buf))) {
 		DEBUG(0, ("talloc failed\n"));
 		return NT_STATUS_NO_MEMORY;
 	}
+	fsp->notify->filter = filter;
+	fsp->notify->subdir_filter = recursive ? filter : 0;
+	fsp->notify->max_buffer_size = max_buffer_size;
 
-	if (asprintf(&fullpath, "%s/%s", fsp->conn->connectpath,
-		     fsp->fsp_name) == -1) {
-		DEBUG(0, ("asprintf failed\n"));
-		return NT_STATUS_NO_MEMORY;
-	}
+	fsp_fullbasepath(fsp, fullpath, sizeof(fullpath));
 
-	ZERO_STRUCT(e);
-	e.path = fullpath;
-	e.filter = filter;
-	e.subdir_filter = 0;
-	if (recursive) {
-		e.subdir_filter = filter;
+	/*
+	 * Avoid /. at the end of the path name. notify can't deal with it.
+	 */
+	if (len > 1 && fullpath[len-1] == '.' && fullpath[len-2] == '/') {
+		fullpath[len-2] = '\0';
 	}
 
-	status = notify_add(fsp->conn->notify_ctx, &e, notify_callback, fsp);
-	SAFE_FREE(fullpath);
+	if ((fsp->notify->filter != 0) ||
+	    (fsp->notify->subdir_filter != 0)) {
+		status = notify_add(fsp->conn->sconn->notify_ctx,
+				    fullpath, fsp->notify->filter,
+				    fsp->notify->subdir_filter, fsp);
+	}
 
 	return status;
 }
 
 NTSTATUS change_notify_add_request(struct smb_request *req,
-				uint32 max_param,
-				uint32 filter, bool recursive,
-				struct files_struct *fsp)
+				uint32_t max_param,
+				uint32_t 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;
 
 	DEBUG(10, ("change_notify_add_request: Adding request for %s: "
-		   "max_param = %d\n", fsp->fsp_name, (int)max_param));
+		   "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))) {
@@ -251,21 +350,19 @@ NTSTATUS change_notify_add_request(struct smb_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 *);
+	DLIST_ADD_END(fsp->notify->requests, request);
 
 	map->mid = request->req->mid;
-	DLIST_ADD(notify_changes_by_mid, map);
-
-	/* Push the MID of this packet on the signing queue. */
-	srv_defer_sign_response(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;
@@ -289,19 +386,54 @@ 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);
+	DLIST_REMOVE(sconn->smb1.notify_mid_maps, req->mid_map);
 	TALLOC_FREE(req);
 }
 
+static void smbd_notify_cancel_by_map(struct notify_mid_map *map)
+{
+	struct smb_request *smbreq = map->req->req;
+	struct smbd_server_connection *sconn = smbreq->sconn;
+	struct smbd_smb2_request *smb2req = smbreq->smb2req;
+	NTSTATUS notify_status = NT_STATUS_CANCELLED;
+
+	if (smb2req != NULL) {
+		NTSTATUS sstatus;
+
+		if (smb2req->session == NULL) {
+			sstatus = NT_STATUS_USER_SESSION_DELETED;
+		} else {
+			sstatus = smb2req->session->status;
+		}
+
+		if (NT_STATUS_EQUAL(sstatus, NT_STATUS_NETWORK_SESSION_EXPIRED)) {
+			sstatus = NT_STATUS_OK;
+		}
+
+		if (!NT_STATUS_IS_OK(sstatus)) {
+			notify_status = STATUS_NOTIFY_CLEANUP;
+		} else if (smb2req->tcon == NULL) {
+			notify_status = STATUS_NOTIFY_CLEANUP;
+		} else if (!NT_STATUS_IS_OK(smb2req->tcon->status)) {
+			notify_status = STATUS_NOTIFY_CLEANUP;
+		}
+	}
+
+	change_notify_reply(smbreq, notify_status,
+			    0, NULL, map->req->reply_fn);
+	change_notify_remove_request(sconn, map->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;
 		}
@@ -311,9 +443,117 @@ void remove_pending_change_notify_requests_by_mid(uint16 mid)
 		return;
 	}
 
-	change_notify_reply_packet(map->req->fsp->conn, map->req->req,
-				   NT_STATUS_CANCELLED);
-	change_notify_remove_request(map->req);
+	smbd_notify_cancel_by_map(map);
+}
+
+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;
+	}
+
+	smbd_notify_cancel_by_map(map);
+}
+
+static struct files_struct *smbd_notify_cancel_deleted_fn(
+	struct files_struct *fsp, void *private_data)
+{
+	struct file_id *fid = talloc_get_type_abort(
+		private_data, struct file_id);
+
+	if (file_id_equal(&fsp->file_id, fid)) {
+		remove_pending_change_notify_requests_by_fid(
+			fsp, NT_STATUS_DELETE_PENDING);
+	}
+	return NULL;
+}
+
+void smbd_notify_cancel_deleted(struct messaging_context *msg,
+				void *private_data, uint32_t msg_type,
+				struct server_id server_id, DATA_BLOB *data)
+{
+	struct smbd_server_connection *sconn = talloc_get_type_abort(
+		private_data, struct smbd_server_connection);
+	struct file_id *fid;
+	enum ndr_err_code ndr_err;
+
+	fid = talloc(talloc_tos(), struct file_id);
+	if (fid == NULL) {
+		DEBUG(1, ("talloc failed\n"));
+		return;
+	}
+
+	ndr_err = ndr_pull_struct_blob_all(
+		data, fid, fid, (ndr_pull_flags_fn_t)ndr_pull_file_id);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		DEBUG(10, ("%s: ndr_pull_file_id failed: %s\n", __func__,
+			   ndr_errstr(ndr_err)));
+		goto done;
+	}
+
+	files_forall(sconn, smbd_notify_cancel_deleted_fn, fid);
+
+done:
+	TALLOC_FREE(fid);
+}
+
+static struct files_struct *smbd_notifyd_reregister(struct files_struct *fsp,
+						    void *private_data)
+{
+	DBG_DEBUG("reregister %s\n", fsp->fsp_name->base_name);
+
+	if ((fsp->conn->sconn->notify_ctx != NULL) &&
+	    (fsp->notify != NULL) &&
+	    ((fsp->notify->filter != 0) ||
+	     (fsp->notify->subdir_filter != 0))) {
+		size_t len = fsp_fullbasepath(fsp, NULL, 0);
+		char fullpath[len+1];
+
+		NTSTATUS status;
+
+		fsp_fullbasepath(fsp, fullpath, sizeof(fullpath));
+		if (len > 1 && fullpath[len-1] == '.' &&
+		    fullpath[len-2] == '/') {
+			fullpath[len-2] = '\0';
+		}
+
+		status = notify_add(fsp->conn->sconn->notify_ctx,
+				    fullpath, fsp->notify->filter,
+				    fsp->notify->subdir_filter, fsp);
+		if (!NT_STATUS_IS_OK(status)) {
+			DBG_DEBUG("notify_add failed: %s\n",
+				  nt_errstr(status));
+		}
+	}
+	return NULL;
+}
+
+void smbd_notifyd_restarted(struct messaging_context *msg,
+			    void *private_data, uint32_t msg_type,
+			    struct server_id server_id, DATA_BLOB *data)
+{
+	struct smbd_server_connection *sconn = talloc_get_type_abort(
+		private_data, struct smbd_server_connection);
+
+	TALLOC_FREE(sconn->notify_ctx);
+
+	sconn->notify_ctx = notify_init(sconn, sconn->msg_ctx,
+					sconn, notify_callback);
+	if (sconn->notify_ctx == NULL) {
+		DBG_DEBUG("notify_init failed\n");
+		return;
+	}
+
+	files_forall(sconn, smbd_notifyd_reregister, sconn->notify_ctx);
 }
 
 /****************************************************************************
@@ -328,29 +568,30 @@ void remove_pending_change_notify_requests_by_fid(files_struct *fsp,
 	}
 
 	while (fsp->notify->requests != NULL) {
-		change_notify_reply_packet(
-			fsp->conn, fsp->notify->requests->req, 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);
 	}
 }
 
-void notify_fname(connection_struct *conn, uint32 action, uint32 filter,
+void notify_fname(connection_struct *conn, uint32_t action, uint32_t filter,
 		  const char *path)
 {
-	char *fullpath;
+	struct notify_context *notify_ctx = conn->sconn->notify_ctx;
 
-	if (asprintf(&fullpath, "%s/%s", conn->connectpath, path) == -1) {
-		DEBUG(0, ("asprintf failed\n"));
-		return;
+	if (path[0] == '.' && path[1] == '/') {
+		path += 2;
 	}
 
-	notify_trigger(conn->notify_ctx, action, filter, fullpath);
-	SAFE_FREE(fullpath);
+	notify_trigger(notify_ctx, action, filter, conn->connectpath, path);
 }
 
-static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
+static void notify_fsp(files_struct *fsp, struct timespec when,
+		       uint32_t action, const char *name)
 {
-	struct notify_change *change, *changes;
+	struct notify_change_event *change, *changes;
 	char *tmp;
 
 	if (fsp->notify == NULL) {
@@ -368,20 +609,36 @@ 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))) {
+		      struct notify_change_event,
+		      fsp->notify->num_changes+1))) {
 		DEBUG(0, ("talloc_realloc failed\n"));
 		return;
 	}
@@ -398,6 +655,7 @@ static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
 	string_replace(tmp, '/', '\\');
 	change->name = tmp;	
 
+	change->when = when;
 	change->action = action;
 	fsp->notify->num_changes += 1;
 
@@ -422,15 +680,16 @@ 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->conn,
-			    fsp->notify->requests->req,
+	change_notify_reply(fsp->notify->requests->req,
+			    NT_STATUS_OK,
 			    fsp->notify->requests->max_param,
-			    fsp->notify);
+			    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)
+char *notify_filter_string(TALLOC_CTX *mem_ctx, uint32_t filter)
 {
 	char *result = NULL;
 
@@ -468,31 +727,17 @@ char *notify_filter_string(TALLOC_CTX *mem_ctx, uint32 filter)
 	return result;
 }
 
-struct sys_notify_context *sys_notify_context_create(connection_struct *conn,
-						     TALLOC_CTX *mem_ctx, 
-						     struct event_context *ev)
+struct sys_notify_context *sys_notify_context_create(TALLOC_CTX *mem_ctx,
+						     struct tevent_context *ev)
 {
 	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;
 	}
 
 	ctx->ev = ev;
-	ctx->conn = conn;
 	ctx->private_data = NULL;
 	return ctx;
 }
-
-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);
-}
-