#include "system/filesys.h"
#include "dlinklist.h"
#include "messages.h"
+#include "librpc/gen_ndr/ndr_xattr.h"
/*
create file handles with convenient numbers for sniffers
struct pvfs_file_handle *h = p;
if (h->create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {
+ NTSTATUS status = pvfs_xattr_unlink_hook(h->pvfs, h->name->full_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("Warning: xattr rmdir hook failed for '%s' - %s\n",
+ h->name->full_name, nt_errstr(status)));
+ }
if (rmdir(h->name->full_name) != 0) {
DEBUG(0,("pvfs_close: failed to rmdir '%s' - %s\n",
h->name->full_name, strerror(errno)));
return 0;
}
+/*
+ setup any EAs and the ACL on newly created files/directories
+*/
+static NTSTATUS pvfs_open_setup_eas_acl(struct pvfs_state *pvfs,
+ struct smbsrv_request *req,
+ struct pvfs_filename *name,
+ int fd, int fnum,
+ union smb_open *io)
+{
+ NTSTATUS status;
+
+ /* setup any EAs that were asked for */
+ if (io->ntcreatex.in.ea_list) {
+ status = pvfs_setfileinfo_ea_set(pvfs, name, fd,
+ io->ntcreatex.in.ea_list->num_eas,
+ io->ntcreatex.in.ea_list->eas);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+ }
+
+ /* setup an initial sec_desc if requested */
+ if (io->ntcreatex.in.sec_desc) {
+ union smb_setfileinfo set;
+
+ set.set_secdesc.file.fnum = fnum;
+ set.set_secdesc.in.secinfo_flags = SECINFO_DACL;
+ set.set_secdesc.in.sd = io->ntcreatex.in.sec_desc;
+
+ status = pvfs_acl_set(pvfs, req, name, fd, &set);
+ } else {
+ /* otherwise setup an inherited acl from the parent */
+ status = pvfs_acl_inherit(pvfs, req, name, fd);
+ }
+
+ return status;
+}
/*
open a directory
int fnum;
NTSTATUS status;
uint32_t create_action;
+ uint32_t access_mask = io->generic.in.access_mask;
+
+ if (name->stream_name) {
+ return NT_STATUS_NOT_A_DIRECTORY;
+ }
/* if the client says it must be a directory, and it isn't,
then fail */
return NT_STATUS_TOO_MANY_OPENED_FILES;
}
+ if (name->exists) {
+ /* check the security descriptor */
+ status = pvfs_access_check(pvfs, req, name, &access_mask);
+ if (!NT_STATUS_IS_OK(status)) {
+ idr_remove(pvfs->idtree_fnum, fnum);
+ return status;
+ }
+ }
+
f->fnum = fnum;
f->session = req->session;
f->smbpid = req->smbpid;
f->lock_count = 0;
f->share_access = io->generic.in.share_access;
f->impersonation = io->generic.in.impersonation;
+ f->access_mask = access_mask;
- f->handle->pvfs = pvfs;
- f->handle->name = talloc_steal(f->handle, name);
- f->handle->fd = -1;
- f->handle->locking_key = data_blob(NULL, 0);
- f->handle->create_options = io->generic.in.create_options;
- f->handle->seek_offset = 0;
- f->handle->position = 0;
- f->handle->mode = 0;
+ f->handle->pvfs = pvfs;
+ f->handle->name = talloc_steal(f->handle, name);
+ f->handle->fd = -1;
+ f->handle->odb_locking_key = data_blob(NULL, 0);
+ f->handle->brl_locking_key = data_blob(NULL, 0);
+ f->handle->create_options = io->generic.in.create_options;
+ f->handle->seek_offset = 0;
+ f->handle->position = 0;
+ f->handle->mode = 0;
+ f->handle->sticky_write_time = False;
DLIST_ADD(pvfs->open_files, f);
uint32_t attrib = io->generic.in.file_attr | FILE_ATTRIBUTE_DIRECTORY;
mode_t mode = pvfs_fileperms(pvfs, attrib);
if (mkdir(name->full_name, mode) == -1) {
+ idr_remove(pvfs->idtree_fnum, fnum);
return pvfs_map_errno(pvfs,errno);
}
- status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname,
- PVFS_RESOLVE_NO_WILDCARD, &name);
+
+ pvfs_xattr_unlink_hook(pvfs, name->full_name);
+
+ status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname, 0, &name);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto cleanup_delete;
+ }
+
+ status = pvfs_open_setup_eas_acl(pvfs, req, name, -1, fnum, io);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ goto cleanup_delete;
}
+
create_action = NTCREATEX_ACTION_CREATED;
} else {
create_action = NTCREATEX_ACTION_EXISTED;
}
if (!name->exists) {
+ idr_remove(pvfs->idtree_fnum, fnum);
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/* the open succeeded, keep this handle permanently */
talloc_steal(pvfs, f);
- io->generic.out.oplock_level = NO_OPLOCK;
+ io->generic.out.oplock_level = OPLOCK_NONE;
io->generic.out.fnum = f->fnum;
io->generic.out.create_action = create_action;
io->generic.out.create_time = name->dos.create_time;
io->generic.out.is_directory = 1;
return NT_STATUS_OK;
+
+cleanup_delete:
+ idr_remove(pvfs->idtree_fnum, fnum);
+ rmdir(name->full_name);
+ return status;
}
/*
{
struct pvfs_file_handle *h = p;
+ /* the write time is no longer sticky */
+ if (h->sticky_write_time) {
+ NTSTATUS status;
+ status = pvfs_dosattrib_load(h->pvfs, h->name, h->fd);
+ if (NT_STATUS_IS_OK(status)) {
+ h->name->dos.flags &= ~XATTR_ATTRIB_FLAG_STICKY_WRITE_TIME;
+ pvfs_dosattrib_save(h->pvfs, h->name, h->fd);
+ }
+ }
+
+ if ((h->create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
+ h->name->stream_name) {
+ NTSTATUS status;
+ status = pvfs_stream_delete(h->pvfs, h->name, h->fd);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("Failed to delete stream '%s' on close of '%s'\n",
+ h->name->stream_name, h->name->full_name));
+ }
+ }
+
if (h->fd != -1) {
if (close(h->fd) != 0) {
DEBUG(0,("pvfs_handle_destructor: close(%d) failed for %s - %s\n",
h->fd = -1;
}
- if (h->create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {
+ if ((h->create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
+ h->name->stream_name == NULL) {
+ NTSTATUS status;
+ status = pvfs_xattr_unlink_hook(h->pvfs, h->name->full_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("Warning: xattr unlink hook failed for '%s' - %s\n",
+ h->name->full_name, nt_errstr(status)));
+ }
if (unlink(h->name->full_name) != 0) {
DEBUG(0,("pvfs_close: failed to delete '%s' - %s\n",
h->name->full_name, strerror(errno)));
struct odb_lock *lck;
NTSTATUS status;
- lck = odb_lock(h, h->pvfs->odb_context, &h->locking_key);
+ lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
if (lck == NULL) {
DEBUG(0,("Unable to lock opendb for close\n"));
return 0;
/*
- form the lock context used for byte range locking and opendb
- locking. Note that we must zero here to take account of
- possible padding on some architectures
+ form the lock context used for opendb locking. Note that we must
+ zero here to take account of possible padding on some architectures
*/
static NTSTATUS pvfs_locking_key(struct pvfs_filename *name,
TALLOC_CTX *mem_ctx, DATA_BLOB *key)
return NT_STATUS_OK;
}
+/*
+ form the lock context used for byte range locking. This is separate
+ from the locking key used for opendb locking as it needs to take
+ account of file streams (each stream is a separate byte range
+ locking space)
+*/
+static NTSTATUS pvfs_brl_locking_key(struct pvfs_filename *name,
+ TALLOC_CTX *mem_ctx, DATA_BLOB *key)
+{
+ DATA_BLOB odb_key;
+ NTSTATUS status;
+ status = pvfs_locking_key(name, mem_ctx, &odb_key);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+ if (name->stream_name == NULL) {
+ *key = odb_key;
+ return NT_STATUS_OK;
+ }
+ *key = data_blob_talloc(mem_ctx, NULL,
+ odb_key.length + strlen(name->stream_name) + 1);
+ if (key->data == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ memcpy(key->data, odb_key.data, odb_key.length);
+ memcpy(key->data + odb_key.length,
+ name->stream_name, strlen(name->stream_name)+1);
+ data_blob_free(&odb_key);
+ return NT_STATUS_OK;
+}
+
/*
create a new file
return NT_STATUS_CANNOT_DELETE;
}
- if (access_mask & SEC_RIGHT_MAXIMUM_ALLOWED) {
- access_mask = GENERIC_RIGHTS_FILE_READ | GENERIC_RIGHTS_FILE_WRITE;
+ if (access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
+ access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
}
- if (access_mask & SA_RIGHT_FILE_WRITE_APPEND) {
+ if (access_mask & (SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)) {
flags = O_RDWR;
} else {
flags = O_RDONLY;
return pvfs_map_errno(pvfs, errno);
}
+ pvfs_xattr_unlink_hook(pvfs, name->full_name);
+
+ /* if this was a stream create then create the stream as well */
+ if (name->stream_name) {
+ status = pvfs_stream_create(pvfs, name, fd);
+ if (!NT_STATUS_IS_OK(status)) {
+ idr_remove(pvfs->idtree_fnum, fnum);
+ close(fd);
+ return status;
+ }
+ }
+
/* re-resolve the open fd */
status = pvfs_resolve_name_fd(pvfs, fd, name);
if (!NT_STATUS_IS_OK(status)) {
name->dos.attrib = attrib;
status = pvfs_dosattrib_save(pvfs, name, fd);
if (!NT_STATUS_IS_OK(status)) {
- idr_remove(pvfs->idtree_fnum, fnum);
- close(fd);
- return status;
+ goto cleanup_delete;
+ }
+
+
+ status = pvfs_open_setup_eas_acl(pvfs, req, name, fd, fnum, io);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto cleanup_delete;
}
/* form the lock context used for byte range locking and
opendb locking */
- status = pvfs_locking_key(name, f->handle, &f->handle->locking_key);
+ status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
if (!NT_STATUS_IS_OK(status)) {
- idr_remove(pvfs->idtree_fnum, fnum);
- close(fd);
- return status;
+ goto cleanup_delete;
+ }
+
+ status = pvfs_brl_locking_key(name, f->handle, &f->handle->brl_locking_key);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto cleanup_delete;
}
/* grab a lock on the open file record */
- lck = odb_lock(req, pvfs->odb_context, &f->handle->locking_key);
+ lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
if (lck == NULL) {
DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
name->full_name));
/* we were supposed to do a blocking lock, so something
is badly wrong! */
- idr_remove(pvfs->idtree_fnum, fnum);
- close(fd);
- return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto cleanup_delete;
}
- status = odb_open_file(lck, f->handle,
+ status = odb_open_file(lck, f->handle, name->stream_id,
share_access, create_options, access_mask);
talloc_free(lck);
if (!NT_STATUS_IS_OK(status)) {
- /* bad news, we must have hit a race */
+ /* 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 */
idr_remove(pvfs->idtree_fnum, fnum);
close(fd);
return status;
f->handle->position = 0;
f->handle->mode = 0;
f->handle->have_opendb_entry = True;
+ f->handle->sticky_write_time = False;
DLIST_ADD(pvfs->open_files, f);
talloc_set_destructor(f, pvfs_fnum_destructor);
talloc_set_destructor(f->handle, pvfs_handle_destructor);
- io->generic.out.oplock_level = NO_OPLOCK;
+
+ if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
+ io->generic.out.oplock_level = OPLOCK_EXCLUSIVE;
+ } else {
+ io->generic.out.oplock_level = OPLOCK_NONE;
+ }
io->generic.out.fnum = f->fnum;
io->generic.out.create_action = NTCREATEX_ACTION_CREATED;
io->generic.out.create_time = name->dos.create_time;
talloc_steal(pvfs, f);
return NT_STATUS_OK;
+
+cleanup_delete:
+ idr_remove(pvfs->idtree_fnum, fnum);
+ close(fd);
+ unlink(name->full_name);
+ return status;
}
struct smbsrv_request *req;
union smb_open *io;
void *wait_handle;
- DATA_BLOB locking_key;
+ DATA_BLOB odb_locking_key;
};
/* destroy a pending open request */
{
struct pvfs_open_retry *r = ptr;
struct pvfs_state *pvfs = r->ntvfs->private_data;
- if (r->locking_key.data) {
+ if (r->odb_locking_key.data) {
struct odb_lock *lck;
- lck = odb_lock(r->req, pvfs->odb_context, &r->locking_key);
+ lck = odb_lock(r->req, pvfs->odb_context, &r->odb_locking_key);
if (lck != NULL) {
odb_remove_pending(lck, r);
}
/* the pending odb entry is already removed. We use a null locking
key to indicate this */
- data_blob_free(&r->locking_key);
+ data_blob_free(&r->odb_locking_key);
talloc_free(r);
/* try the open again, which could trigger another retry setup
(f2->handle->create_options &
(NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
- (f2->access_mask & SA_RIGHT_FILE_WRITE_DATA) &&
+ (f2->access_mask & SEC_FILE_WRITE_DATA) &&
StrCaseCmp(f2->handle->name->original_name,
io->generic.in.fname)==0) {
break;
name = f->handle->name;
- io->generic.out.oplock_level = NO_OPLOCK;
+ io->generic.out.oplock_level = OPLOCK_NONE;
io->generic.out.fnum = f->fnum;
io->generic.out.create_action = NTCREATEX_ACTION_EXISTED;
io->generic.out.create_time = name->dos.create_time;
r->ntvfs = ntvfs;
r->req = req;
r->io = io;
- r->locking_key = data_blob_talloc(r,
- f->handle->locking_key.data,
- f->handle->locking_key.length);
+ r->odb_locking_key = data_blob_talloc(r,
+ f->handle->odb_locking_key.data,
+ f->handle->odb_locking_key.length);
end_time = timeval_add(&req->request_time, 0, pvfs->sharing_violation_delay);
return NT_STATUS_NO_MEMORY;
}
- return NT_STATUS_OK;
-}
+ talloc_steal(pvfs, r);
-/*
- special handling for t2open
-*/
-static NTSTATUS pvfs_open_t2open(struct ntvfs_module_context *ntvfs,
- struct smbsrv_request *req, union smb_open *io)
-{
- struct pvfs_state *pvfs = ntvfs->private_data;
- struct pvfs_filename *name;
- NTSTATUS status;
-
- status = pvfs_resolve_name(pvfs, req, io->t2open.in.fname,
- PVFS_RESOLVE_NO_WILDCARD, &name);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
-
- if (io->t2open.in.open_func & OPENX_OPEN_FUNC_CREATE) {
- if (!name->exists) return NT_STATUS_ACCESS_DENIED;
- }
- if (io->t2open.in.open_func & OPENX_OPEN_FUNC_TRUNC) {
- if (name->exists) return NT_STATUS_ACCESS_DENIED;
- return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- }
- if ((io->t2open.in.open_func & 0xF) == OPENX_OPEN_FUNC_FAIL) {
- if (!name->exists) return NT_STATUS_ACCESS_DENIED;
- return NT_STATUS_OBJECT_NAME_COLLISION;
- }
-
- talloc_free(name);
-
- return ntvfs_map_open(req, io, ntvfs);
+ return NT_STATUS_OK;
}
/*
uint32_t create_options;
uint32_t share_access;
uint32_t access_mask;
-
- if (io->generic.level == RAW_OPEN_T2OPEN) {
- return pvfs_open_t2open(ntvfs, req, io);
- }
+ BOOL stream_existed;
/* use the generic mapping code to avoid implementing all the
different open calls. */
- if (io->generic.level != RAW_OPEN_GENERIC) {
+ if (io->generic.level != RAW_OPEN_GENERIC &&
+ io->generic.level != RAW_OPEN_NTTRANS_CREATE) {
return ntvfs_map_open(req, io, ntvfs);
}
/* resolve the cifs name to a posix name */
- status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname,
- PVFS_RESOLVE_NO_WILDCARD, &name);
+ status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname,
+ PVFS_RESOLVE_STREAMS, &name);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return pvfs_open_directory(pvfs, req, name, io);
}
+ /* FILE_ATTRIBUTE_DIRECTORY is ignored if the above test for directory
+ open doesn't match */
+ io->generic.in.file_attr &= ~FILE_ATTRIBUTE_DIRECTORY;
+
create_options = io->generic.in.create_options;
share_access = io->generic.in.share_access;
access_mask = io->generic.in.access_mask;
- if (access_mask & SEC_RIGHT_MAXIMUM_ALLOWED) {
- if (name->exists && (name->dos.attrib & FILE_ATTRIBUTE_READONLY)) {
- access_mask = GENERIC_RIGHTS_FILE_READ;
- } else {
- access_mask = GENERIC_RIGHTS_FILE_READ | GENERIC_RIGHTS_FILE_WRITE;
- }
- }
-
/* certain create options are not allowed */
if ((create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
- !(access_mask & STD_RIGHT_DELETE_ACCESS)) {
+ !(access_mask & SEC_STD_DELETE)) {
return NT_STATUS_INVALID_PARAMETER;
}
break;
case NTCREATEX_DISP_OPEN:
- if (!name->exists) {
+ if (!name->stream_exists) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
flags = 0;
break;
case NTCREATEX_DISP_OVERWRITE:
- if (!name->exists) {
+ if (!name->stream_exists) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
flags = O_TRUNC;
break;
case NTCREATEX_DISP_CREATE:
- if (name->exists) {
+ if (name->stream_exists) {
return NT_STATUS_OBJECT_NAME_COLLISION;
}
flags = 0;
return NT_STATUS_INVALID_PARAMETER;
}
- if (access_mask & SA_RIGHT_FILE_WRITE_APPEND) {
- flags |= O_RDWR;
- } else {
- flags |= O_RDONLY;
- }
-
/* handle creating a new file separately */
if (!name->exists) {
status = pvfs_create_file(pvfs, req, name, io);
}
/* try re-resolving the name */
- status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname,
- PVFS_RESOLVE_NO_WILDCARD, &name);
+ status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname, 0, &name);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_CANNOT_DELETE;
}
+ /* check the security descriptor */
+ status = pvfs_access_check(pvfs, req, name, &access_mask);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
f = talloc_p(req, struct pvfs_file);
if (f == NULL) {
return NT_STATUS_NO_MEMORY;
f->handle->create_options = io->generic.in.create_options;
f->handle->seek_offset = 0;
f->handle->position = 0;
+ f->handle->mode = 0;
f->handle->have_opendb_entry = False;
+ f->handle->sticky_write_time = False;
/* form the lock context used for byte range locking and
opendb locking */
- status = pvfs_locking_key(name, f->handle, &f->handle->locking_key);
+ status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
+ if (!NT_STATUS_IS_OK(status)) {
+ idr_remove(pvfs->idtree_fnum, f->fnum);
+ return status;
+ }
+
+ status = pvfs_brl_locking_key(name, f->handle, &f->handle->brl_locking_key);
if (!NT_STATUS_IS_OK(status)) {
idr_remove(pvfs->idtree_fnum, f->fnum);
return status;
}
/* get a lock on this file before the actual open */
- lck = odb_lock(req, pvfs->odb_context, &f->handle->locking_key);
+ lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
if (lck == NULL) {
DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
name->full_name));
/* see if we are allowed to open at the same time as existing opens */
- status = odb_open_file(lck, f->handle,
+ status = odb_open_file(lck, f->handle, f->handle->name->stream_id,
share_access, create_options, access_mask);
/* on a sharing violation we need to retry when the file is closed by
f->handle->have_opendb_entry = True;
+ if (access_mask & (SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)) {
+ flags |= O_RDWR;
+ } else {
+ flags |= O_RDONLY;
+ }
+
/* do the actual open */
fd = open(f->handle->name->full_name, flags);
if (fd == -1) {
f->handle->fd = fd;
+ stream_existed = name->stream_exists;
+
+ /* if this was a stream create then create the stream as well */
+ if (!name->stream_exists) {
+ status = pvfs_stream_create(pvfs, f->handle->name, fd);
+ if (!NT_STATUS_IS_OK(status)) {
+ talloc_free(lck);
+ return status;
+ }
+ }
+
/* re-resolve the open fd */
status = pvfs_resolve_name_fd(f->pvfs, fd, f->handle->name);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- if (io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE ||
- io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE_IF) {
+ if (f->handle->name->stream_id == 0 &&
+ (io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE ||
+ io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE_IF)) {
/* for overwrite we need to replace file permissions */
uint32_t attrib = io->ntcreatex.in.file_attr | FILE_ATTRIBUTE_ARCHIVE;
mode_t mode = pvfs_fileperms(pvfs, attrib);
if (fchmod(fd, mode) == -1) {
talloc_free(lck);
- return map_nt_error_from_unix(errno);
+ return pvfs_map_errno(pvfs, errno);
}
name->dos.attrib = attrib;
status = pvfs_dosattrib_save(pvfs, name, fd);
talloc_free(lck);
- io->generic.out.oplock_level = NO_OPLOCK;
+ if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
+ io->generic.out.oplock_level = OPLOCK_EXCLUSIVE;
+ } else {
+ io->generic.out.oplock_level = OPLOCK_NONE;
+ }
io->generic.out.fnum = f->fnum;
- io->generic.out.create_action = NTCREATEX_ACTION_EXISTED;
+ io->generic.out.create_action = stream_existed?
+ NTCREATEX_ACTION_EXISTED:NTCREATEX_ACTION_CREATED;
io->generic.out.create_time = name->dos.create_time;
io->generic.out.access_time = name->dos.access_time;
io->generic.out.write_time = name->dos.write_time;
unix_times.actime = 0;
unix_times.modtime = io->close.in.write_time;
utime(f->handle->name->full_name, &unix_times);
+ } else if (f->handle->sticky_write_time) {
+ unix_times.actime = 0;
+ unix_times.modtime = nt_time_to_unix(f->handle->name->dos.write_time);
+ utime(f->handle->name->full_name, &unix_times);
}
-
+
talloc_free(f);
return NT_STATUS_OK;
return NT_STATUS_CANNOT_DELETE;
}
- lck = odb_lock(req, pvfs->odb_context, &f->handle->locking_key);
+ lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
if (lck == NULL) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
determine if a file can be deleted, or if it is prevented by an
already open file
*/
-NTSTATUS pvfs_can_delete(struct pvfs_state *pvfs, struct pvfs_filename *name)
+NTSTATUS pvfs_can_delete(struct pvfs_state *pvfs,
+ struct smbsrv_request *req,
+ struct pvfs_filename *name)
{
NTSTATUS status;
DATA_BLOB key;
NTCREATEX_SHARE_ACCESS_WRITE |
NTCREATEX_SHARE_ACCESS_DELETE,
NTCREATEX_OPTIONS_DELETE_ON_CLOSE,
- STD_RIGHT_DELETE_ACCESS);
+ SEC_STD_DELETE);
+
+ if (NT_STATUS_IS_OK(status)) {
+ status = pvfs_access_check_simple(pvfs, req, name, SEC_STD_DELETE);
+ }
return status;
}
status = odb_can_open(pvfs->odb_context, &key,
NTCREATEX_SHARE_ACCESS_READ |
- NTCREATEX_SHARE_ACCESS_WRITE |
- NTCREATEX_SHARE_ACCESS_DELETE,
+ NTCREATEX_SHARE_ACCESS_WRITE,
0,
- STD_RIGHT_DELETE_ACCESS);
+ SEC_STD_DELETE);
return status;
}
git.samba.org / samba.git / blobdiff