Merge branch 'v4-0-test' of ssh://git.samba.org/data/git/samba into v4-0-gmake3

(This used to be commit ac27a1451dfe5c0c957e93fdc84602c3c1c7deac)

6 files changed, 141 insertions, 182 deletions

diff --git a/source4/cluster/ctdb/opendb_ctdb.c b/source4/cluster/ctdb/opendb_ctdb.c
index fe48f98760..a7b8ddf760 100644
--- a/source4/cluster/ctdb/opendb_ctdb.c
+++ b/source4/cluster/ctdb/opendb_ctdb.c
@@ -261,6 +261,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
 	return NT_STATUS_OK;
 }
 
+#if 0
 /*
   send an oplock break to a client
 */
@@ -271,6 +272,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
 	return messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, e->server, 
 				  MSG_NTVFS_OPLOCK_BREAK, e->file_handle);
 }
+#endif
 
 /*
   register an open file in the open files database. This implements the share_access
@@ -281,104 +283,16 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
 */
 static NTSTATUS odb_ctdb_open_file(struct odb_lock *lck,
 				   void *file_handle, const char *path,
-				   uint32_t stream_id, uint32_t share_access,
-				   uint32_t access_mask, bool delete_on_close,
-				   uint32_t open_disposition, bool break_to_none,
 				   bool allow_level_II_oplock,
 				   uint32_t oplock_level, uint32_t *oplock_granted)
 
 {
-	struct odb_context *odb = lck->odb;
-	struct opendb_entry e;
-	int i;
-	struct opendb_file file;
-	NTSTATUS status;
-
-	if (odb->oplocks == false) {
-		oplock_level = OPLOCK_NONE;
-	}
-
-	status = odb_pull_record(lck, &file);
-	if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-		/* initialise a blank structure */
-		ZERO_STRUCT(file);
-		file.path = path;
-	} else {
-		NT_STATUS_NOT_OK_RETURN(status);
-	}
-
-	/* see if it conflicts */
-	e.server          = odb->ntvfs_ctx->server_id;
-	e.file_handle     = file_handle;
-	e.stream_id       = stream_id;
-	e.share_access    = share_access;
-	e.access_mask     = access_mask;
-	e.delete_on_close = delete_on_close;
-	e.oplock_level    = OPLOCK_NONE;
-		
-	/* see if anyone has an oplock, which we need to break */
-	for (i=0;i<file.num_entries;i++) {
-		if (file.entries[i].oplock_level == OPLOCK_BATCH) {
-			/* a batch oplock caches close calls, which
-			   means the client application might have
-			   already closed the file. We have to allow
-			   this close to propogate by sending a oplock
-			   break request and suspending this call
-			   until the break is acknowledged or the file
-			   is closed */
-			odb_oplock_break_send(odb, &file.entries[i]);
-			return NT_STATUS_OPLOCK_NOT_GRANTED;
-		}
-	}
-
-	if (file.delete_on_close || 
-	    (file.num_entries != 0 && delete_on_close)) {
-		/* while delete on close is set, no new opens are allowed */
-		return NT_STATUS_DELETE_PENDING;
-	}
-
-	/* check for sharing violations */
-	for (i=0;i<file.num_entries;i++) {
-		status = share_conflict(&file.entries[i], &e);
-		NT_STATUS_NOT_OK_RETURN(status);
-	}
-
-	/* we now know the open could succeed, but we need to check
-	   for any exclusive oplocks. We can't grant a second open
-	   till these are broken. Note that we check for batch oplocks
-	   before checking for sharing violations, and check for
-	   exclusive oplocks afterwards. */
-	for (i=0;i<file.num_entries;i++) {
-		if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
-			odb_oplock_break_send(odb, &file.entries[i]);
-			return NT_STATUS_OPLOCK_NOT_GRANTED;
-		}
-	}
-
 	/*
-	  possibly grant an exclusive or batch oplock if this is the only client
-	  with the file open. We don't yet grant levelII oplocks.
-	*/
-	if (oplock_granted != NULL) {
-		if ((oplock_level == OPLOCK_BATCH ||
-		     oplock_level == OPLOCK_EXCLUSIVE) &&
-		    file.num_entries == 0) {
-			(*oplock_granted) = oplock_level;
-		} else {
-			(*oplock_granted) = OPLOCK_NONE;
-		}
-		e.oplock_level = (*oplock_granted);
-	}
-
-	/* it doesn't conflict, so add it to the end */
-	file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
-				      file.num_entries+1);
-	NT_STATUS_HAVE_NO_MEMORY(file.entries);
-
-	file.entries[file.num_entries] = e;
-	file.num_entries++;
-
-	return odb_push_record(lck, &file);
+	 * as this file will went away and isn't used yet,
+	 * copy the implementation from the tdb backend
+	 * --metze
+	 */
+	return NT_STATUS_FOOBAR;
 }
 
 
diff --git a/source4/ntvfs/cifs/vfs_cifs.c b/source4/ntvfs/cifs/vfs_cifs.c
index 901dd2cf7c..58183b5e60 100644
--- a/source4/ntvfs/cifs/vfs_cifs.c
+++ b/source4/ntvfs/cifs/vfs_cifs.c
@@ -207,7 +207,11 @@ static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs,
 	io.in.service = remote_share;
 	io.in.service_type = "?????";
 	lp_smbcli_options(ntvfs->ctx->lp_ctx, &io.in.options);
-	
+
+	if (!(ntvfs->ctx->client_caps & NTVFS_CLIENT_CAP_LEVEL_II_OPLOCKS)) {
+		io.in.options.use_level2_oplocks = false;
+	}
+
 	creq = smb_composite_connect_send(&io, private, 
 					  lp_resolve_context(ntvfs->ctx->lp_ctx),
 					  ntvfs->ctx->event_ctx);
diff --git a/source4/ntvfs/common/opendb.c b/source4/ntvfs/common/opendb.c
index a7e5458aaf..1cc077137c 100644
--- a/source4/ntvfs/common/opendb.c
+++ b/source4/ntvfs/common/opendb.c
@@ -87,23 +87,21 @@ _PUBLIC_ DATA_BLOB odb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
 }
 
 /*
-  register an open file in the open files database. This implements the share_access
-  rules
+  register an open file in the open files database.
+  The share_access rules are implemented by odb_can_open()
+  and it's needed to call odb_can_open() before
+  odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
 
   Note that the path is only used by the delete on close logic, not
   for comparing with other filenames
 */
 _PUBLIC_ NTSTATUS odb_open_file(struct odb_lock *lck,
 				void *file_handle, const char *path,
-				uint32_t stream_id, uint32_t share_access,
-				uint32_t access_mask, bool delete_on_close,
-				uint32_t open_disposition, bool break_to_none,
 				bool allow_level_II_oplock,
 				uint32_t oplock_level, uint32_t *oplock_granted)
 {
-	return ops->odb_open_file(lck, file_handle, path, stream_id, share_access,
-				  access_mask, delete_on_close, open_disposition,
-				  break_to_none, allow_level_II_oplock,
+	return ops->odb_open_file(lck, file_handle, path,
+				  allow_level_II_oplock,
 				  oplock_level, oplock_granted);
 }
 
diff --git a/source4/ntvfs/common/opendb.h b/source4/ntvfs/common/opendb.h
index 1c7f815dea..fb3223aea9 100644
--- a/source4/ntvfs/common/opendb.h
+++ b/source4/ntvfs/common/opendb.h
@@ -27,9 +27,6 @@ struct opendb_ops {
 	DATA_BLOB (*odb_get_key)(TALLOC_CTX *mem_ctx, struct odb_lock *lck);
 	NTSTATUS (*odb_open_file)(struct odb_lock *lck,
 				  void *file_handle, const char *path,
-				  uint32_t stream_id, uint32_t share_access,
-				  uint32_t access_mask, bool delete_on_close,
-				  uint32_t open_disposition, bool break_to_none,
 				  bool allow_level_II_oplock,
 				  uint32_t oplock_level, uint32_t *oplock_granted);
 	NTSTATUS (*odb_open_file_pending)(struct odb_lock *lck, void *private);
diff --git a/source4/ntvfs/common/opendb_tdb.c b/source4/ntvfs/common/opendb_tdb.c
index 0736af3d1e..f71416ec83 100644
--- a/source4/ntvfs/common/opendb_tdb.c
+++ b/source4/ntvfs/common/opendb_tdb.c
@@ -63,6 +63,11 @@ struct odb_context {
 struct odb_lock {
 	struct odb_context *odb;
 	TDB_DATA key;
+
+	struct {
+		struct opendb_entry *e;
+		bool attrs_only;
+	} can_open;
 };
 
 /*
@@ -130,6 +135,8 @@ static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
 		return NULL;
 	}
 
+	ZERO_STRUCT(lck->can_open);
+
 	talloc_set_destructor(lck, odb_lock_destructor);
 	
 	return lck;
@@ -263,7 +270,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
 /*
   send an oplock break to a client
 */
-static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
+static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
 				      struct opendb_entry *e,
 				      uint8_t level)
 {
@@ -280,7 +287,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
 
 	blob = data_blob_const(&op_break, sizeof(op_break));
 
-	status = messaging_send(odb->ntvfs_ctx->msg_ctx, e->server,
+	status = messaging_send(msg_ctx, e->server,
 				MSG_NTVFS_OPLOCK_BREAK, &blob);
 	NT_STATUS_NOT_OK_RETURN(status);
 
@@ -348,7 +355,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
 			    !file->entries[i].allow_level_II_oplock) {
 				oplock_return = OPLOCK_BREAK_TO_NONE;
 			}
-			odb_oplock_break_send(odb, &file->entries[i],
+			odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+					      &file->entries[i],
 					      oplock_return);
 			return NT_STATUS_OPLOCK_NOT_GRANTED;
 		}
@@ -396,7 +404,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
 			    !file->entries[i].allow_level_II_oplock) {
 				oplock_return = OPLOCK_BREAK_TO_NONE;
 			}
-			odb_oplock_break_send(odb, &file->entries[i],
+			odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+					      &file->entries[i],
 					      oplock_return);
 			return NT_STATUS_OPLOCK_NOT_GRANTED;
 		}
@@ -409,30 +418,35 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
 }
 
 /*
-  register an open file in the open files database. This implements the share_access
-  rules
+  register an open file in the open files database.
+  The share_access rules are implemented by odb_can_open()
+  and it's needed to call odb_can_open() before
+  odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
 
   Note that the path is only used by the delete on close logic, not
   for comparing with other filenames
 */
 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
 				  void *file_handle, const char *path,
-				  uint32_t stream_id, uint32_t share_access,
-				  uint32_t access_mask, bool delete_on_close,
-				  uint32_t open_disposition, bool break_to_none,
 				  bool allow_level_II_oplock,
 				  uint32_t oplock_level, uint32_t *oplock_granted)
 {
 	struct odb_context *odb = lck->odb;
-	struct opendb_entry e;
 	struct opendb_file file;
 	NTSTATUS status;
-	bool attrs_only = false;
+
+	if (!lck->can_open.e) {
+		return NT_STATUS_INTERNAL_ERROR;
+	}
 
 	if (odb->oplocks == false) {
 		oplock_level = OPLOCK_NONE;
 	}
 
+	if (!oplock_granted) {
+		oplock_level = OPLOCK_NONE;
+	}
+
 	status = odb_pull_record(lck, &file);
 	if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 		/* initialise a blank structure */
@@ -442,67 +456,55 @@ static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
 		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
-	/* see if it conflicts */
-	status = odb_tdb_open_can_internal(odb, &file, stream_id,
-					   share_access, access_mask,
-					   delete_on_close, open_disposition,
-					   break_to_none, &attrs_only);
-	NT_STATUS_NOT_OK_RETURN(status);
-
-	/* see if it conflicts */
-	e.server		= odb->ntvfs_ctx->server_id;
-	e.file_handle		= file_handle;
-	e.stream_id		= stream_id;
-	e.share_access		= share_access;
-	e.access_mask		= access_mask;
-	e.delete_on_close	= delete_on_close;
-	e.allow_level_II_oplock	= allow_level_II_oplock;
-	e.oplock_level		= OPLOCK_NONE;
-
 	/*
 	  possibly grant an exclusive, batch or level2 oplock
 	*/
+	if (lck->can_open.attrs_only) {
+		oplock_level	= OPLOCK_NONE;
+	} else if (oplock_level == OPLOCK_EXCLUSIVE) {
+		if (file.num_entries == 0) {
+			oplock_level	= OPLOCK_EXCLUSIVE;
+		} else if (allow_level_II_oplock) {
+			oplock_level	= OPLOCK_LEVEL_II;
+		} else {
+			oplock_level	= OPLOCK_NONE;
+		}
+	} else if (oplock_level == OPLOCK_BATCH) {
+		if (file.num_entries == 0) {
+			oplock_level	= OPLOCK_BATCH;
+		} else if (allow_level_II_oplock) {
+			oplock_level	= OPLOCK_LEVEL_II;
+		} else {
+			oplock_level	= OPLOCK_NONE;
+		}
+	} else if (oplock_level == OPLOCK_LEVEL_II) {
+		oplock_level	= OPLOCK_LEVEL_II;
+	} else {
+		oplock_level	= OPLOCK_NONE;
+	}
+
 	if (oplock_granted) {
-		if (attrs_only) {
-			e.oplock_level	= OPLOCK_NONE;
-			*oplock_granted	= NO_OPLOCK_RETURN;
-		} else if (oplock_level == OPLOCK_EXCLUSIVE) {
-			if (file.num_entries == 0) {
-				e.oplock_level	= OPLOCK_EXCLUSIVE;
-				*oplock_granted	= EXCLUSIVE_OPLOCK_RETURN;
-			} else if (allow_level_II_oplock) {
-				e.oplock_level	= OPLOCK_LEVEL_II;
-				*oplock_granted	= LEVEL_II_OPLOCK_RETURN;
-			} else {
-				e.oplock_level	= OPLOCK_NONE;
-				*oplock_granted	= NO_OPLOCK_RETURN;
-			}
+		if (oplock_level == OPLOCK_EXCLUSIVE) {
+			*oplock_granted	= EXCLUSIVE_OPLOCK_RETURN;
 		} else if (oplock_level == OPLOCK_BATCH) {
-			if (file.num_entries == 0) {
-				e.oplock_level	= OPLOCK_BATCH;
-				*oplock_granted	= BATCH_OPLOCK_RETURN;
-			} else if (allow_level_II_oplock) {
-				e.oplock_level	= OPLOCK_LEVEL_II;
-				*oplock_granted	= LEVEL_II_OPLOCK_RETURN;
-			} else {
-				e.oplock_level	= OPLOCK_NONE;
-				*oplock_granted	= NO_OPLOCK_RETURN;
-			}
+			*oplock_granted	= BATCH_OPLOCK_RETURN;
 		} else if (oplock_level == OPLOCK_LEVEL_II) {
-			e.oplock_level	= OPLOCK_LEVEL_II;
 			*oplock_granted	= LEVEL_II_OPLOCK_RETURN;
 		} else {
-			e.oplock_level	= OPLOCK_NONE;
 			*oplock_granted	= NO_OPLOCK_RETURN;
 		}
 	}
 
+	lck->can_open.e->file_handle		= file_handle;
+	lck->can_open.e->allow_level_II_oplock	= allow_level_II_oplock;
+	lck->can_open.e->oplock_level		= oplock_level;
+
 	/* it doesn't conflict, so add it to the end */
 	file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
 				      file.num_entries+1);
 	NT_STATUS_HAVE_NO_MEMORY(file.entries);
 
-	file.entries[file.num_entries] = e;
+	file.entries[file.num_entries] = *lck->can_open.e;
 	file.num_entries++;
 
 	return odb_push_record(lck, &file);
@@ -655,7 +657,8 @@ static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
 			 * and we just send a break to none to all of them
 			 * without waiting for a release
 			 */
-			odb_oplock_break_send(odb, &file.entries[i],
+			odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+					      &file.entries[i],
 					      OPLOCK_BREAK_TO_NONE);
 			file.entries[i].oplock_level = OPLOCK_NONE;
 			modified = true;
@@ -804,20 +807,32 @@ static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
 	struct odb_context *odb = lck->odb;
 	NTSTATUS status;
 	struct opendb_file file;
-	bool attrs_only = false;
 
 	status = odb_pull_record(lck, &file);
 	if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-		return NT_STATUS_OK;
+		goto ok;
 	}
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	status = odb_tdb_open_can_internal(odb, &file, stream_id,
 					   share_access, access_mask,
 					   delete_on_close, open_disposition,
-					   break_to_none, &attrs_only);
+					   break_to_none, &lck->can_open.attrs_only);
 	NT_STATUS_NOT_OK_RETURN(status);
 
+ok:
+	lck->can_open.e	= talloc(lck, struct opendb_entry);
+	NT_STATUS_HAVE_NO_MEMORY(lck->can_open.e);
+
+	lck->can_open.e->server			= odb->ntvfs_ctx->server_id;
+	lck->can_open.e->file_handle		= NULL;
+	lck->can_open.e->stream_id		= stream_id;
+	lck->can_open.e->share_access		= share_access;
+	lck->can_open.e->access_mask		= access_mask;
+	lck->can_open.e->delete_on_close	= delete_on_close;
+	lck->can_open.e->allow_level_II_oplock	= false;
+	lck->can_open.e->oplock_level		= OPLOCK_NONE;
+
 	return NT_STATUS_OK;
 }
 
diff --git a/source4/ntvfs/posix/pvfs_open.c b/source4/ntvfs/posix/pvfs_open.c
index 47b44b9634..2e757e1742 100644
--- a/source4/ntvfs/posix/pvfs_open.c
+++ b/source4/ntvfs/posix/pvfs_open.c
@@ -290,10 +290,17 @@ static NTSTATUS pvfs_open_directory(struct pvfs_state *pvfs,
 		}
 		
 		/* see if we are allowed to open at the same time as existing opens */
-		status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
-				       share_access, access_mask, del_on_close, 
-				       io->generic.in.open_disposition,
-				       false, false, OPLOCK_NONE, NULL);
+		status = odb_can_open(lck, name->stream_id,
+				      share_access, access_mask, del_on_close,
+				      io->generic.in.open_disposition, false);
+		if (!NT_STATUS_IS_OK(status)) {
+			talloc_free(lck);
+			return status;
+		}
+
+		/* now really mark the file as open */
+		status = odb_open_file(lck, f->handle, name->full_name,
+				       false, OPLOCK_NONE, NULL);
 
 		if (!NT_STATUS_IS_OK(status)) {
 			talloc_free(lck);
@@ -344,10 +351,16 @@ static NTSTATUS pvfs_open_directory(struct pvfs_state *pvfs,
 			return NT_STATUS_INTERNAL_DB_CORRUPTION;
 		}
 
-		status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
-				       share_access, access_mask, del_on_close, 
-				       io->generic.in.open_disposition,
-				       false, false, OPLOCK_NONE, NULL);
+		status = odb_can_open(lck, name->stream_id,
+				      share_access, access_mask, del_on_close,
+				      io->generic.in.open_disposition, false);
+
+		if (!NT_STATUS_IS_OK(status)) {
+			goto cleanup_delete;
+		}
+
+		status = odb_open_file(lck, f->handle, name->full_name,
+				       false, OPLOCK_NONE, NULL);
 
 		if (!NT_STATUS_IS_OK(status)) {
 			goto cleanup_delete;
@@ -663,10 +676,20 @@ static NTSTATUS pvfs_create_file(struct pvfs_state *pvfs,
 		allow_level_II_oplock = true;
 	}
 
-	status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
-			       share_access, access_mask, del_on_close, 
-			       io->generic.in.open_disposition,
-			       false, allow_level_II_oplock,
+	status = odb_can_open(lck, name->stream_id,
+			      share_access, access_mask, del_on_close,
+			      io->generic.in.open_disposition, false);
+	if (!NT_STATUS_IS_OK(status)) {
+		talloc_free(lck);
+		/* bad news, we must have hit a race - we don't delete the file
+		   here as the most likely scenario is that someone else created
+		   the file at the same time */
+		close(fd);
+		return status;
+	}
+
+	status = odb_open_file(lck, f->handle, name->full_name,
+			       allow_level_II_oplock,
 			       oplock_level, &oplock_granted);
 	talloc_free(lck);
 	if (!NT_STATUS_IS_OK(status)) {
@@ -801,7 +824,7 @@ static void pvfs_odb_retry_callback(void *_r, enum pvfs_wait_notice reason)
 
 /*
   setup for a retry of a request that was rejected
-  by odb_open_file() or odb_can_open()
+  by odb_can_open()
 */
 NTSTATUS pvfs_odb_retry_setup(struct ntvfs_module_context *ntvfs,
 			      struct ntvfs_request *req,
@@ -1253,11 +1276,9 @@ NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
 	}
 
 	/* see if we are allowed to open at the same time as existing opens */
-	status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
-			       share_access, access_mask, del_on_close,
-			       io->generic.in.open_disposition,
-			       false, allow_level_II_oplock,
-			       oplock_level, &oplock_granted);
+	status = odb_can_open(lck, name->stream_id,
+			      share_access, access_mask, del_on_close,
+			      io->generic.in.open_disposition, false);
 
 	/*
 	 * on a sharing violation we need to retry when the file is closed by
@@ -1276,6 +1297,16 @@ NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
 		return status;
 	}
 
+	/* now really mark the file as open */
+	status = odb_open_file(lck, f->handle, name->full_name,
+			       allow_level_II_oplock,
+			       oplock_level, &oplock_granted);
+
+	if (!NT_STATUS_IS_OK(status)) {
+		talloc_free(lck);
+		return status;
+	}
+
 	if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
 		oplock_granted = OPLOCK_BATCH;
 	} else if (oplock_granted != OPLOCK_NONE) {