From dcad0f6fd492506efd9a69b4e32c7bbfa5da90e5 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 29 Sep 2004 13:17:09 +0000 Subject: r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539) --- source4/ntvfs/cifs/vfs_cifs.c | 139 ++++---- source4/ntvfs/config.mk | 1 + source4/ntvfs/ipc/vfs_ipc.c | 131 +++++--- source4/ntvfs/nbench/vfs_nbench.c | 235 +++++++------- source4/ntvfs/ntvfs.h | 117 +++++-- source4/ntvfs/ntvfs_base.c | 54 +++- source4/ntvfs/ntvfs_generic.c | 18 +- source4/ntvfs/ntvfs_interface.c | 566 +++++++++++++++++++++++++++++++++ source4/ntvfs/posix/pvfs_fsinfo.c | 7 +- source4/ntvfs/posix/pvfs_mkdir.c | 10 +- source4/ntvfs/posix/pvfs_open.c | 29 +- source4/ntvfs/posix/pvfs_qfileinfo.c | 16 +- source4/ntvfs/posix/pvfs_read.c | 7 +- source4/ntvfs/posix/pvfs_rename.c | 5 +- source4/ntvfs/posix/pvfs_search.c | 29 +- source4/ntvfs/posix/pvfs_setfileinfo.c | 7 +- source4/ntvfs/posix/pvfs_unlink.c | 5 +- source4/ntvfs/posix/pvfs_write.c | 9 +- source4/ntvfs/posix/vfs_posix.c | 38 ++- source4/ntvfs/posix/vfs_posix.h | 2 - source4/ntvfs/print/vfs_print.c | 12 +- source4/ntvfs/simple/svfs.h | 2 - source4/ntvfs/simple/svfs_util.c | 12 +- source4/ntvfs/simple/vfs_simple.c | 142 +++++---- source4/smb_server/nttrans.c | 2 +- source4/smb_server/reply.c | 78 ++--- source4/smb_server/search.c | 6 +- source4/smb_server/service.c | 17 +- source4/smb_server/smb_server.c | 2 +- source4/smb_server/smb_server.h | 19 +- source4/smb_server/trans2.c | 54 ++-- 31 files changed, 1254 insertions(+), 517 deletions(-) create mode 100644 source4/ntvfs/ntvfs_interface.c diff --git a/source4/ntvfs/cifs/vfs_cifs.c b/source4/ntvfs/cifs/vfs_cifs.c index c0160e6852..65a7c7a206 100644 --- a/source4/ntvfs/cifs/vfs_cifs.c +++ b/source4/ntvfs/cifs/vfs_cifs.c @@ -32,7 +32,7 @@ struct cvfs_private { struct smbcli_tree *tree; struct smbcli_transport *transport; struct smbsrv_tcon *tcon; - const struct ntvfs_ops *ops; + /*const struct ntvfs_ops *ops;*/ }; @@ -89,7 +89,8 @@ static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde, /* connect to a share - used when a tree_connect operation comes in. */ -static NTSTATUS cvfs_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { struct smbsrv_tcon *tcon = req->tcon; NTSTATUS status; @@ -120,7 +121,7 @@ static NTSTATUS cvfs_connect(struct smbsrv_request *req, const char *sharename, } ZERO_STRUCTP(private); - ntvfs_set_private(req->tcon, depth, private); + ntvfs->private_data = private; status = smbcli_tree_full_connection(private, &private->tree, @@ -137,7 +138,7 @@ static NTSTATUS cvfs_connect(struct smbsrv_request *req, const char *sharename, private->transport = private->tree->session->transport; private->tree->session->pid = SVAL(req->in.hdr, HDR_PID); private->tcon = req->tcon; - private->ops = ntvfs_backend_byname("cifs", NTVFS_DISK); + /*private->ops = ntvfs_backend_byname("cifs", NTVFS_DISK);*/ tcon->fs_type = talloc_strdup(tcon, "NTFS"); tcon->dev_type = talloc_strdup(tcon, "A:"); @@ -158,9 +159,10 @@ static NTSTATUS cvfs_connect(struct smbsrv_request *req, const char *sharename, /* disconnect from a share */ -static NTSTATUS cvfs_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS cvfs_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { - struct cvfs_private *private = tcon->ntvfs_private_list[depth]; + struct cvfs_private *private = ntvfs->private_data; smb_tree_disconnect(private->tree); talloc_free(private->tree); @@ -204,9 +206,10 @@ static void async_simple(struct smbcli_request *c_req) delete a file - the dirtype specifies the file types to include in the search. The name can contain CIFS wildcards, but rarely does (except with OS/2 clients) */ -static NTSTATUS cvfs_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +static NTSTATUS cvfs_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; /* see if the front end will allow us to perform this @@ -234,9 +237,10 @@ static void async_ioctl(struct smbcli_request *c_req) /* ioctl interface */ -static NTSTATUS cvfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS cvfs_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; /* see if the front end will allow us to perform this @@ -253,9 +257,10 @@ static NTSTATUS cvfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) /* check if a directory exists */ -static NTSTATUS cvfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +static NTSTATUS cvfs_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -281,9 +286,10 @@ static void async_qpathinfo(struct smbcli_request *c_req) /* return info on a pathname */ -static NTSTATUS cvfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS cvfs_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -309,9 +315,10 @@ static void async_qfileinfo(struct smbcli_request *c_req) /* query info on a open file */ -static NTSTATUS cvfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS cvfs_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -327,9 +334,10 @@ static NTSTATUS cvfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *i /* set info on a pathname */ -static NTSTATUS cvfs_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +static NTSTATUS cvfs_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -356,9 +364,10 @@ static void async_open(struct smbcli_request *c_req) /* open a file */ -static NTSTATUS cvfs_open(struct smbsrv_request *req, union smb_open *io) +static NTSTATUS cvfs_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *io) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -373,9 +382,10 @@ static NTSTATUS cvfs_open(struct smbsrv_request *req, union smb_open *io) /* create a directory */ -static NTSTATUS cvfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +static NTSTATUS cvfs_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -390,9 +400,10 @@ static NTSTATUS cvfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) /* remove a directory */ -static NTSTATUS cvfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +static NTSTATUS cvfs_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -406,9 +417,10 @@ static NTSTATUS cvfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) /* rename a set of files */ -static NTSTATUS cvfs_rename(struct smbsrv_request *req, union smb_rename *ren) +static NTSTATUS cvfs_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -423,7 +435,8 @@ static NTSTATUS cvfs_rename(struct smbsrv_request *req, union smb_rename *ren) /* copy a set of files */ -static NTSTATUS cvfs_copy(struct smbsrv_request *req, struct smb_copy *cp) +static NTSTATUS cvfs_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) { return NT_STATUS_NOT_SUPPORTED; } @@ -442,9 +455,10 @@ static void async_read(struct smbcli_request *c_req) /* read from a file */ -static NTSTATUS cvfs_read(struct smbsrv_request *req, union smb_read *rd) +static NTSTATUS cvfs_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *rd) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -470,9 +484,10 @@ static void async_write(struct smbcli_request *c_req) /* write to a file */ -static NTSTATUS cvfs_write(struct smbsrv_request *req, union smb_write *wr) +static NTSTATUS cvfs_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *wr) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -487,7 +502,8 @@ static NTSTATUS cvfs_write(struct smbsrv_request *req, union smb_write *wr) /* seek in a file */ -static NTSTATUS cvfs_seek(struct smbsrv_request *req, struct smb_seek *io) +static NTSTATUS cvfs_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) { return NT_STATUS_NOT_SUPPORTED; } @@ -495,7 +511,8 @@ static NTSTATUS cvfs_seek(struct smbsrv_request *req, struct smb_seek *io) /* flush a file */ -static NTSTATUS cvfs_flush(struct smbsrv_request *req, struct smb_flush *io) +static NTSTATUS cvfs_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *io) { return NT_STATUS_OK; } @@ -503,9 +520,10 @@ static NTSTATUS cvfs_flush(struct smbsrv_request *req, struct smb_flush *io) /* close a file */ -static NTSTATUS cvfs_close(struct smbsrv_request *req, union smb_close *io) +static NTSTATUS cvfs_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -520,9 +538,10 @@ static NTSTATUS cvfs_close(struct smbsrv_request *req, union smb_close *io) /* exit - closing files open by the pid */ -static NTSTATUS cvfs_exit(struct smbsrv_request *req) +static NTSTATUS cvfs_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -537,7 +556,8 @@ static NTSTATUS cvfs_exit(struct smbsrv_request *req) /* logoff - closing files open by the user */ -static NTSTATUS cvfs_logoff(struct smbsrv_request *req) +static NTSTATUS cvfs_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { /* we can't do this right in the cifs backend .... */ return NT_STATUS_OK; @@ -546,9 +566,10 @@ static NTSTATUS cvfs_logoff(struct smbsrv_request *req) /* lock a byte range */ -static NTSTATUS cvfs_lock(struct smbsrv_request *req, union smb_lock *lck) +static NTSTATUS cvfs_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -562,10 +583,11 @@ static NTSTATUS cvfs_lock(struct smbsrv_request *req, union smb_lock *lck) /* set info on a open file */ -static NTSTATUS cvfs_setfileinfo(struct smbsrv_request *req, +static NTSTATUS cvfs_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -591,9 +613,10 @@ static void async_fsinfo(struct smbcli_request *c_req) /* return filesystem space info */ -static NTSTATUS cvfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +static NTSTATUS cvfs_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -608,7 +631,8 @@ static NTSTATUS cvfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) /* return print queue info */ -static NTSTATUS cvfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +static NTSTATUS cvfs_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) { return NT_STATUS_NOT_SUPPORTED; } @@ -616,29 +640,32 @@ static NTSTATUS cvfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) /* list files in a directory matching a wildcard pattern */ -static NTSTATUS cvfs_search_first(struct smbsrv_request *req, union smb_search_first *io, +static NTSTATUS cvfs_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; return smb_raw_search_first(private->tree, req, io, search_private, callback); } /* continue a search */ -static NTSTATUS cvfs_search_next(struct smbsrv_request *req, union smb_search_next *io, +static NTSTATUS cvfs_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; return smb_raw_search_next(private->tree, req, io, search_private, callback); } /* close a search */ -static NTSTATUS cvfs_search_close(struct smbsrv_request *req, union smb_search_close *io) +static NTSTATUS cvfs_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; return smb_raw_search_close(private->tree, io); } @@ -655,9 +682,10 @@ static void async_trans2(struct smbcli_request *c_req) } /* raw trans2 */ -static NTSTATUS cvfs_trans2(struct smbsrv_request *req, struct smb_trans2 *trans2) +static NTSTATUS cvfs_trans2(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) { - NTVFS_GET_PRIVATE(cvfs_private, private, req); + struct cvfs_private *private = ntvfs->private_data; struct smbcli_request *c_req; if (!req->async.send_fn) { @@ -671,7 +699,8 @@ static NTSTATUS cvfs_trans2(struct smbsrv_request *req, struct smb_trans2 *trans /* SMBtrans - not used on file shares */ -static NTSTATUS cvfs_trans(struct smbsrv_request *req, struct smb_trans2 *trans2) +static NTSTATUS cvfs_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) { return NT_STATUS_ACCESS_DENIED; } @@ -721,7 +750,7 @@ NTSTATUS ntvfs_cifs_init(void) ops.logoff = cvfs_logoff; if (lp_parm_bool(-1, "cifs", "maptrans2", False)) { - ops.trans2 = cvfs_trans2; + ops.trans2 = cvfs_trans2; } /* register ourselves with the NTVFS subsystem. We register diff --git a/source4/ntvfs/config.mk b/source4/ntvfs/config.mk index d00cc2b1f4..e2320e0684 100644 --- a/source4/ntvfs/config.mk +++ b/source4/ntvfs/config.mk @@ -55,6 +55,7 @@ INIT_OBJ_FILES = \ ntvfs/ntvfs_base.o ADD_OBJ_FILES = \ ntvfs/ntvfs_generic.o \ + ntvfs/ntvfs_interface.o \ ntvfs/ntvfs_util.o # # End SUBSYSTEM NTVFS diff --git a/source4/ntvfs/ipc/vfs_ipc.c b/source4/ntvfs/ipc/vfs_ipc.c index 59da6faea5..69fed6f86f 100644 --- a/source4/ntvfs/ipc/vfs_ipc.c +++ b/source4/ntvfs/ipc/vfs_ipc.c @@ -110,7 +110,8 @@ static struct pipe_state *pipe_state_find(struct ipc_private *private, uint16_t /* connect to a share - always works */ -static NTSTATUS ipc_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS ipc_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { struct smbsrv_tcon *tcon = req->tcon; struct ipc_private *private; @@ -123,7 +124,7 @@ static NTSTATUS ipc_connect(struct smbsrv_request *req, const char *sharename, i if (!private) { return NT_STATUS_NO_MEMORY; } - ntvfs_set_private(tcon, depth, private); + ntvfs->private_data = private; private->pipe_list = NULL; private->next_fnum = 1; @@ -135,9 +136,10 @@ static NTSTATUS ipc_connect(struct smbsrv_request *req, const char *sharename, i /* disconnect from a share */ -static NTSTATUS ipc_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS ipc_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { - struct ipc_private *private = tcon->ntvfs_private_list[depth]; + struct ipc_private *private = ntvfs->private_data; /* close any pipes that are open. Discard any unread data */ while (private->pipe_list) { @@ -150,7 +152,8 @@ static NTSTATUS ipc_disconnect(struct smbsrv_tcon *tcon, int depth) /* delete a file */ -static NTSTATUS ipc_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +static NTSTATUS ipc_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { return NT_STATUS_ACCESS_DENIED; } @@ -159,7 +162,8 @@ static NTSTATUS ipc_unlink(struct smbsrv_request *req, struct smb_unlink *unl) /* ioctl interface - we don't do any */ -static NTSTATUS ipc_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS ipc_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { return NT_STATUS_ACCESS_DENIED; } @@ -167,7 +171,8 @@ static NTSTATUS ipc_ioctl(struct smbsrv_request *req, union smb_ioctl *io) /* check if a directory exists */ -static NTSTATUS ipc_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +static NTSTATUS ipc_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) { return NT_STATUS_ACCESS_DENIED; } @@ -175,7 +180,8 @@ static NTSTATUS ipc_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) /* return info on a pathname */ -static NTSTATUS ipc_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS ipc_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { return NT_STATUS_ACCESS_DENIED; } @@ -183,7 +189,8 @@ static NTSTATUS ipc_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *in /* set info on a pathname */ -static NTSTATUS ipc_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +static NTSTATUS ipc_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) { return NT_STATUS_ACCESS_DENIED; } @@ -193,14 +200,15 @@ static NTSTATUS ipc_setpathinfo(struct smbsrv_request *req, union smb_setfileinf /* open a file backend - used for MSRPC pipes */ -static NTSTATUS ipc_open_generic(struct smbsrv_request *req, const char *fname, +static NTSTATUS ipc_open_generic(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *fname, struct pipe_state **ps) { struct pipe_state *p; NTSTATUS status; struct dcesrv_ep_description ep_description; struct auth_session_info *session_info = NULL; - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; p = talloc_p(private, struct pipe_state); if (!p) { @@ -270,12 +278,13 @@ static NTSTATUS ipc_open_generic(struct smbsrv_request *req, const char *fname, /* open a file with ntcreatex - used for MSRPC pipes */ -static NTSTATUS ipc_open_ntcreatex(struct smbsrv_request *req, union smb_open *oi) +static NTSTATUS ipc_open_ntcreatex(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *oi) { struct pipe_state *p; NTSTATUS status; - status = ipc_open_generic(req, oi->ntcreatex.in.fname, &p); + status = ipc_open_generic(ntvfs, req, oi->ntcreatex.in.fname, &p); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -290,7 +299,8 @@ static NTSTATUS ipc_open_ntcreatex(struct smbsrv_request *req, union smb_open *o /* open a file with openx - used for MSRPC pipes */ -static NTSTATUS ipc_open_openx(struct smbsrv_request *req, union smb_open *oi) +static NTSTATUS ipc_open_openx(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *oi) { struct pipe_state *p; NTSTATUS status; @@ -302,7 +312,7 @@ static NTSTATUS ipc_open_openx(struct smbsrv_request *req, union smb_open *oi) fname += 4; - status = ipc_open_generic(req, fname, &p); + status = ipc_open_generic(ntvfs, req, fname, &p); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -318,16 +328,17 @@ static NTSTATUS ipc_open_openx(struct smbsrv_request *req, union smb_open *oi) /* open a file - used for MSRPC pipes */ -static NTSTATUS ipc_open(struct smbsrv_request *req, union smb_open *oi) +static NTSTATUS ipc_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *oi) { NTSTATUS status; switch (oi->generic.level) { case RAW_OPEN_NTCREATEX: - status = ipc_open_ntcreatex(req, oi); + status = ipc_open_ntcreatex(ntvfs, req, oi); break; case RAW_OPEN_OPENX: - status = ipc_open_openx(req, oi); + status = ipc_open_openx(ntvfs, req, oi); break; default: status = NT_STATUS_NOT_SUPPORTED; @@ -340,7 +351,8 @@ static NTSTATUS ipc_open(struct smbsrv_request *req, union smb_open *oi) /* create a directory */ -static NTSTATUS ipc_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +static NTSTATUS ipc_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) { return NT_STATUS_ACCESS_DENIED; } @@ -348,7 +360,8 @@ static NTSTATUS ipc_mkdir(struct smbsrv_request *req, union smb_mkdir *md) /* remove a directory */ -static NTSTATUS ipc_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +static NTSTATUS ipc_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) { return NT_STATUS_ACCESS_DENIED; } @@ -356,7 +369,8 @@ static NTSTATUS ipc_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) /* rename a set of files */ -static NTSTATUS ipc_rename(struct smbsrv_request *req, union smb_rename *ren) +static NTSTATUS ipc_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) { return NT_STATUS_ACCESS_DENIED; } @@ -364,7 +378,8 @@ static NTSTATUS ipc_rename(struct smbsrv_request *req, union smb_rename *ren) /* copy a set of files */ -static NTSTATUS ipc_copy(struct smbsrv_request *req, struct smb_copy *cp) +static NTSTATUS ipc_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) { return NT_STATUS_ACCESS_DENIED; } @@ -372,9 +387,10 @@ static NTSTATUS ipc_copy(struct smbsrv_request *req, struct smb_copy *cp) /* read from a file */ -static NTSTATUS ipc_read(struct smbsrv_request *req, union smb_read *rd) +static NTSTATUS ipc_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *rd) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; DATA_BLOB data; uint16_t fnum; struct pipe_state *p; @@ -424,9 +440,10 @@ static NTSTATUS ipc_read(struct smbsrv_request *req, union smb_read *rd) /* write to a file */ -static NTSTATUS ipc_write(struct smbsrv_request *req, union smb_write *wr) +static NTSTATUS ipc_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *wr) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; DATA_BLOB data; uint16_t fnum; struct pipe_state *p; @@ -477,7 +494,8 @@ static NTSTATUS ipc_write(struct smbsrv_request *req, union smb_write *wr) /* seek in a file */ -static NTSTATUS ipc_seek(struct smbsrv_request *req, struct smb_seek *io) +static NTSTATUS ipc_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) { return NT_STATUS_ACCESS_DENIED; } @@ -485,7 +503,8 @@ static NTSTATUS ipc_seek(struct smbsrv_request *req, struct smb_seek *io) /* flush a file */ -static NTSTATUS ipc_flush(struct smbsrv_request *req, struct smb_flush *io) +static NTSTATUS ipc_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *io) { return NT_STATUS_ACCESS_DENIED; } @@ -493,9 +512,10 @@ static NTSTATUS ipc_flush(struct smbsrv_request *req, struct smb_flush *io) /* close a file */ -static NTSTATUS ipc_close(struct smbsrv_request *req, union smb_close *io) +static NTSTATUS ipc_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; struct pipe_state *p; if (io->generic.level != RAW_CLOSE_CLOSE) { @@ -516,9 +536,10 @@ static NTSTATUS ipc_close(struct smbsrv_request *req, union smb_close *io) /* exit - closing files */ -static NTSTATUS ipc_exit(struct smbsrv_request *req) +static NTSTATUS ipc_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; struct pipe_state *p, *next; for (p=private->pipe_list; p; p=next) { @@ -534,9 +555,10 @@ static NTSTATUS ipc_exit(struct smbsrv_request *req) /* logoff - closing files open by the user */ -static NTSTATUS ipc_logoff(struct smbsrv_request *req) +static NTSTATUS ipc_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; struct pipe_state *p, *next; for (p=private->pipe_list; p; p=next) { @@ -552,7 +574,8 @@ static NTSTATUS ipc_logoff(struct smbsrv_request *req) /* lock a byte range */ -static NTSTATUS ipc_lock(struct smbsrv_request *req, union smb_lock *lck) +static NTSTATUS ipc_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) { return NT_STATUS_ACCESS_DENIED; } @@ -560,7 +583,8 @@ static NTSTATUS ipc_lock(struct smbsrv_request *req, union smb_lock *lck) /* set info on a open file */ -static NTSTATUS ipc_setfileinfo(struct smbsrv_request *req, union smb_setfileinfo *info) +static NTSTATUS ipc_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info) { return NT_STATUS_ACCESS_DENIED; } @@ -568,7 +592,8 @@ static NTSTATUS ipc_setfileinfo(struct smbsrv_request *req, union smb_setfileinf /* query info on a open file */ -static NTSTATUS ipc_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS ipc_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { return NT_STATUS_ACCESS_DENIED; } @@ -577,7 +602,8 @@ static NTSTATUS ipc_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *in /* return filesystem info */ -static NTSTATUS ipc_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +static NTSTATUS ipc_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) { return NT_STATUS_ACCESS_DENIED; } @@ -585,7 +611,8 @@ static NTSTATUS ipc_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) /* return print queue info */ -static NTSTATUS ipc_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +static NTSTATUS ipc_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) { return NT_STATUS_ACCESS_DENIED; } @@ -593,7 +620,8 @@ static NTSTATUS ipc_lpq(struct smbsrv_request *req, union smb_lpq *lpq) /* list files in a directory matching a wildcard pattern */ -NTSTATUS ipc_search_first(struct smbsrv_request *req, union smb_search_first *io, +static NTSTATUS ipc_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { @@ -603,7 +631,8 @@ NTSTATUS ipc_search_first(struct smbsrv_request *req, union smb_search_first *io /* continue listing files in a directory */ -NTSTATUS ipc_search_next(struct smbsrv_request *req, union smb_search_next *io, +static NTSTATUS ipc_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { @@ -613,17 +642,19 @@ NTSTATUS ipc_search_next(struct smbsrv_request *req, union smb_search_next *io, /* end listing files in a directory */ -NTSTATUS ipc_search_close(struct smbsrv_request *req, union smb_search_close *io) +static NTSTATUS ipc_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) { return NT_STATUS_ACCESS_DENIED; } /* SMBtrans - handle a DCERPC command */ -static NTSTATUS ipc_dcerpc_cmd(struct smbsrv_request *req, struct smb_trans2 *trans) +static NTSTATUS ipc_dcerpc_cmd(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans) { struct pipe_state *p; - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; NTSTATUS status; /* the fnum is in setup[1] */ @@ -665,9 +696,10 @@ static NTSTATUS ipc_dcerpc_cmd(struct smbsrv_request *req, struct smb_trans2 *tr /* SMBtrans - set named pipe state */ -static NTSTATUS ipc_set_nm_pipe_state(struct smbsrv_request *req, struct smb_trans2 *trans) +static NTSTATUS ipc_set_nm_pipe_state(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans) { - NTVFS_GET_PRIVATE(ipc_private, private, req); + struct ipc_private *private = ntvfs->private_data; struct pipe_state *p; /* the fnum is in setup[1] */ @@ -691,7 +723,8 @@ static NTSTATUS ipc_set_nm_pipe_state(struct smbsrv_request *req, struct smb_tra /* SMBtrans - used to provide access to SMB pipes */ -static NTSTATUS ipc_trans(struct smbsrv_request *req, struct smb_trans2 *trans) +static NTSTATUS ipc_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans) { NTSTATUS status; @@ -704,10 +737,10 @@ static NTSTATUS ipc_trans(struct smbsrv_request *req, struct smb_trans2 *trans) switch (trans->in.setup[0]) { case TRANSACT_SETNAMEDPIPEHANDLESTATE: - status = ipc_set_nm_pipe_state(req, trans); + status = ipc_set_nm_pipe_state(ntvfs, req, trans); break; case TRANSACT_DCERPCCMD: - status = ipc_dcerpc_cmd(req, trans); + status = ipc_dcerpc_cmd(ntvfs, req, trans); break; default: status = NT_STATUS_INVALID_PARAMETER; diff --git a/source4/ntvfs/nbench/vfs_nbench.c b/source4/ntvfs/nbench/vfs_nbench.c index 90b5d43bd6..06c237afb5 100644 --- a/source4/ntvfs/nbench/vfs_nbench.c +++ b/source4/ntvfs/nbench/vfs_nbench.c @@ -28,11 +28,9 @@ /* this is stored in ntvfs_private */ struct nbench_private { - const struct ntvfs_ops *passthru_ops; int log_fd; }; - /* log one request to the nbench log */ @@ -53,12 +51,6 @@ static void nbench_log(struct nbench_private *private, free(s); } - -/* - this is used to call the next module in the ntvfs chain -*/ -#define PASS_THRU(tcon, op, args) private->passthru_ops->op args; - /* this pass through macro operates on request contexts, and disables async calls. @@ -66,12 +58,10 @@ static void nbench_log(struct nbench_private *private, async calls are a pain for the nbench module as it makes pulling the status code and any result parameters much harder. */ -#define PASS_THRU_REQ(req, op, args) do { \ +#define PASS_THRU_REQ(ntvfs, req, op, args) do { \ void *send_fn_saved = req->async.send_fn; \ req->async.send_fn = NULL; \ - req->ntvfs_depth++; \ - status = PASS_THRU(req->tcon, op, args); \ - req->ntvfs_depth--; \ + status = ntvfs_next_##op args; \ req->async.send_fn = send_fn_saved; \ } while (0) @@ -79,21 +69,20 @@ static void nbench_log(struct nbench_private *private, /* connect to a share - used when a tree_connect operation comes in. */ -static NTSTATUS nbench_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { struct nbench_private *private; - const char *passthru; NTSTATUS status; char *logname = NULL; - const char **handlers = lp_ntvfs_handler(req->tcon->service); private = talloc_p(req->tcon, struct nbench_private); if (!private) { return NT_STATUS_NO_MEMORY; } - asprintf(&logname, "/tmp/nbenchlog%d.%u", depth, getpid()); - private->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644); + asprintf(&logname, "/tmp/nbenchlog%d.%u", ntvfs->depth, getpid()); + private->log_fd = sys_open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644); free(logname); if (private->log_fd == -1) { @@ -101,16 +90,9 @@ static NTSTATUS nbench_connect(struct smbsrv_request *req, const char *sharename return NT_STATUS_UNSUCCESSFUL; } - private->passthru_ops = ntvfs_backend_byname(handlers[depth+1], NTVFS_DISK); + ntvfs->private_data = private; - if (!private->passthru_ops) { - DEBUG(0,("Unable to connect to '%s' pass through backend\n", passthru)); - return NT_STATUS_UNSUCCESSFUL; - } - - ntvfs_set_private(req->tcon, depth, private); - - status = PASS_THRU(req->tcon, connect, (req, sharename, depth+1)); + status = ntvfs_next_connect(ntvfs, req, sharename); return status; } @@ -118,15 +100,16 @@ static NTSTATUS nbench_connect(struct smbsrv_request *req, const char *sharename /* disconnect from a share */ -static NTSTATUS nbench_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { - struct nbench_private *private = tcon->ntvfs_private_list[depth]; + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; close(private->log_fd); - status = PASS_THRU(tcon, disconnect, (tcon, depth+1)); - + status = ntvfs_next_disconnect(ntvfs, tcon); + return status; } @@ -134,12 +117,13 @@ static NTSTATUS nbench_disconnect(struct smbsrv_tcon *tcon, int depth) delete a file - the dirtype specifies the file types to include in the search. The name can contain CIFS wildcards, but rarely does (except with OS/2 clients) */ -static NTSTATUS nbench_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, unlink, (req, unl)); + PASS_THRU_REQ(ntvfs, req, unlink, (ntvfs, req, unl)); nbench_log(private, "Unlink \"%s\" 0x%x %s\n", unl->in.pattern, unl->in.attrib, @@ -151,12 +135,13 @@ static NTSTATUS nbench_unlink(struct smbsrv_request *req, struct smb_unlink *unl /* ioctl interface */ -static NTSTATUS nbench_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, ioctl, (req, io)); + PASS_THRU_REQ(ntvfs, req, ioctl, (ntvfs, req, io)); nbench_log(private, "Ioctl - NOT HANDLED\n"); @@ -166,12 +151,13 @@ static NTSTATUS nbench_ioctl(struct smbsrv_request *req, union smb_ioctl *io) /* check if a directory exists */ -static NTSTATUS nbench_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, chkpath, (req, cp)); + PASS_THRU_REQ(ntvfs, req, chkpath, (ntvfs, req, cp)); nbench_log(private, "Chkpath \"%s\" %s\n", cp->in.path, @@ -183,12 +169,13 @@ static NTSTATUS nbench_chkpath(struct smbsrv_request *req, struct smb_chkpath *c /* return info on a pathname */ -static NTSTATUS nbench_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, qpathinfo, (req, info)); + PASS_THRU_REQ(ntvfs, req, qpathinfo, (ntvfs, req, info)); nbench_log(private, "QUERY_PATH_INFORMATION \"%s\" %d %s\n", info->generic.in.fname, @@ -201,12 +188,13 @@ static NTSTATUS nbench_qpathinfo(struct smbsrv_request *req, union smb_fileinfo /* query info on a open file */ -static NTSTATUS nbench_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS nbench_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, qfileinfo, (req, info)); + PASS_THRU_REQ(ntvfs, req, qfileinfo, (ntvfs, req, info)); nbench_log(private, "QUERY_FILE_INFORMATION %d %d %s\n", info->generic.in.fnum, @@ -220,12 +208,13 @@ static NTSTATUS nbench_qfileinfo(struct smbsrv_request *req, union smb_fileinfo /* set info on a pathname */ -static NTSTATUS nbench_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, setpathinfo, (req, st)); + PASS_THRU_REQ(ntvfs, req, setpathinfo, (ntvfs, req, st)); nbench_log(private, "SET_PATH_INFORMATION \"%s\" %d %s\n", st->generic.file.fname, @@ -238,12 +227,15 @@ static NTSTATUS nbench_setpathinfo(struct smbsrv_request *req, union smb_setfile /* open a file */ -static NTSTATUS nbench_open(struct smbsrv_request *req, union smb_open *io) +static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, open, (req, io)); + PASS_THRU_REQ(ntvfs, req, open, (ntvfs, req, io)); + + DEBUG(0,("%d: %s\n", ntvfs->depth, get_nt_error_c_code(status))); switch (io->generic.level) { case RAW_OPEN_NTCREATEX: @@ -267,12 +259,13 @@ static NTSTATUS nbench_open(struct smbsrv_request *req, union smb_open *io) /* create a directory */ -static NTSTATUS nbench_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, mkdir, (req, md)); + PASS_THRU_REQ(ntvfs, req, mkdir, (ntvfs, req, md)); nbench_log(private, "Mkdir - NOT HANDLED\n"); @@ -282,12 +275,13 @@ static NTSTATUS nbench_mkdir(struct smbsrv_request *req, union smb_mkdir *md) /* remove a directory */ -static NTSTATUS nbench_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, rmdir, (req, rd)); + PASS_THRU_REQ(ntvfs, req, rmdir, (ntvfs, req, rd)); nbench_log(private, "Rmdir \"%s\" %s\n", rd->in.path, @@ -299,12 +293,13 @@ static NTSTATUS nbench_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) /* rename a set of files */ -static NTSTATUS nbench_rename(struct smbsrv_request *req, union smb_rename *ren) +static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, rename, (req, ren)); + PASS_THRU_REQ(ntvfs, req, rename, (ntvfs, req, ren)); switch (ren->generic.level) { case RAW_RENAME_RENAME: @@ -326,12 +321,13 @@ static NTSTATUS nbench_rename(struct smbsrv_request *req, union smb_rename *ren) /* copy a set of files */ -static NTSTATUS nbench_copy(struct smbsrv_request *req, struct smb_copy *cp) +static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, copy, (req, cp)); + PASS_THRU_REQ(ntvfs, req, copy, (ntvfs, req, cp)); nbench_log(private, "Copy - NOT HANDLED\n"); @@ -341,12 +337,13 @@ static NTSTATUS nbench_copy(struct smbsrv_request *req, struct smb_copy *cp) /* read from a file */ -static NTSTATUS nbench_read(struct smbsrv_request *req, union smb_read *rd) +static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *rd) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, read, (req, rd)); + PASS_THRU_REQ(ntvfs, req, read, (ntvfs, req, rd)); switch (rd->generic.level) { case RAW_READ_READX: @@ -369,12 +366,13 @@ static NTSTATUS nbench_read(struct smbsrv_request *req, union smb_read *rd) /* write to a file */ -static NTSTATUS nbench_write(struct smbsrv_request *req, union smb_write *wr) +static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *wr) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, write, (req, wr)); + PASS_THRU_REQ(ntvfs, req, write, (ntvfs, req, wr)); switch (wr->generic.level) { case RAW_WRITE_WRITEX: @@ -407,12 +405,13 @@ static NTSTATUS nbench_write(struct smbsrv_request *req, union smb_write *wr) /* seek in a file */ -static NTSTATUS nbench_seek(struct smbsrv_request *req, struct smb_seek *io) +static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, seek, (req, io)); + PASS_THRU_REQ(ntvfs, req, seek, (ntvfs, req, io)); nbench_log(private, "Seek - NOT HANDLED\n"); @@ -422,12 +421,13 @@ static NTSTATUS nbench_seek(struct smbsrv_request *req, struct smb_seek *io) /* flush a file */ -static NTSTATUS nbench_flush(struct smbsrv_request *req, struct smb_flush *io) +static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, flush, (req, io)); + PASS_THRU_REQ(ntvfs, req, flush, (ntvfs, req, io)); nbench_log(private, "Flush %d %s\n", io->in.fnum, @@ -439,12 +439,13 @@ static NTSTATUS nbench_flush(struct smbsrv_request *req, struct smb_flush *io) /* close a file */ -static NTSTATUS nbench_close(struct smbsrv_request *req, union smb_close *io) +static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, close, (req, io)); + PASS_THRU_REQ(ntvfs, req, close, (ntvfs, req, io)); switch (io->generic.level) { case RAW_CLOSE_CLOSE: @@ -465,12 +466,12 @@ static NTSTATUS nbench_close(struct smbsrv_request *req, union smb_close *io) /* exit - closing files */ -static NTSTATUS nbench_exit(struct smbsrv_request *req) +static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(nbench_private, private, req); NTSTATUS status; - PASS_THRU_REQ(req, exit, (req)); + PASS_THRU_REQ(ntvfs, req, exit, (ntvfs, req)); return status; } @@ -478,12 +479,12 @@ static NTSTATUS nbench_exit(struct smbsrv_request *req) /* logoff - closing files */ -static NTSTATUS nbench_logoff(struct smbsrv_request *req) +static NTSTATUS nbench_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(nbench_private, private, req); NTSTATUS status; - PASS_THRU_REQ(req, logoff, (req)); + PASS_THRU_REQ(ntvfs, req, logoff, (ntvfs, req)); return status; } @@ -491,12 +492,13 @@ static NTSTATUS nbench_logoff(struct smbsrv_request *req) /* lock a byte range */ -static NTSTATUS nbench_lock(struct smbsrv_request *req, union smb_lock *lck) +static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, lock, (req, lck)); + PASS_THRU_REQ(ntvfs, req, lock, (ntvfs, req, lck)); if (lck->generic.level == RAW_LOCK_LOCKX && lck->lockx.in.lock_cnt == 1 && @@ -523,13 +525,14 @@ static NTSTATUS nbench_lock(struct smbsrv_request *req, union smb_lock *lck) /* set info on a open file */ -static NTSTATUS nbench_setfileinfo(struct smbsrv_request *req, - union smb_setfileinfo *info) +static NTSTATUS nbench_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, + union smb_setfileinfo *info) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, setfileinfo, (req, info)); + PASS_THRU_REQ(ntvfs, req, setfileinfo, (ntvfs, req, info)); nbench_log(private, "SET_FILE_INFORMATION %d %d %s\n", info->generic.file.fnum, @@ -543,12 +546,13 @@ static NTSTATUS nbench_setfileinfo(struct smbsrv_request *req, /* return filesystem space info */ -static NTSTATUS nbench_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, fsinfo, (req, fs)); + PASS_THRU_REQ(ntvfs, req, fsinfo, (ntvfs, req, fs)); nbench_log(private, "QUERY_FS_INFORMATION %d %s\n", fs->generic.level, @@ -560,12 +564,13 @@ static NTSTATUS nbench_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) /* return print queue info */ -static NTSTATUS nbench_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, lpq, (req, lpq)); + PASS_THRU_REQ(ntvfs, req, lpq, (ntvfs, req, lpq)); nbench_log(private, "Lpq-%d - NOT HANDLED\n", lpq->generic.level); @@ -575,14 +580,15 @@ static NTSTATUS nbench_lpq(struct smbsrv_request *req, union smb_lpq *lpq) /* list files in a directory matching a wildcard pattern */ -static NTSTATUS nbench_search_first(struct smbsrv_request *req, union smb_search_first *io, - void *search_private, - BOOL (*callback)(void *, union smb_search_data *)) +static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, + void *search_private, + BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, search_first, (req, io, search_private, callback)); + PASS_THRU_REQ(ntvfs, req, search_first, (ntvfs, req, io, search_private, callback)); switch (io->generic.level) { case RAW_SEARCH_BOTH_DIRECTORY_INFO: @@ -603,14 +609,15 @@ static NTSTATUS nbench_search_first(struct smbsrv_request *req, union smb_search } /* continue a search */ -static NTSTATUS nbench_search_next(struct smbsrv_request *req, union smb_search_next *io, - void *search_private, - BOOL (*callback)(void *, union smb_search_data *)) +static NTSTATUS nbench_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, + void *search_private, + BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, search_next, (req, io, search_private, callback)); + PASS_THRU_REQ(ntvfs, req, search_next, (ntvfs, req, io, search_private, callback)); nbench_log(private, "Searchnext-%d - NOT HANDLED\n", io->generic.level); @@ -618,12 +625,13 @@ static NTSTATUS nbench_search_next(struct smbsrv_request *req, union smb_search_ } /* close a search */ -static NTSTATUS nbench_search_close(struct smbsrv_request *req, union smb_search_close *io) +static NTSTATUS nbench_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, search_close, (req, io)); + PASS_THRU_REQ(ntvfs, req, search_close, (ntvfs, req, io)); nbench_log(private, "Searchclose-%d - NOT HANDLED\n", io->generic.level); @@ -631,12 +639,13 @@ static NTSTATUS nbench_search_close(struct smbsrv_request *req, union smb_search } /* SMBtrans - not used on file shares */ -static NTSTATUS nbench_trans(struct smbsrv_request *req, struct smb_trans2 *trans2) +static NTSTATUS nbench_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) { - NTVFS_GET_PRIVATE(nbench_private, private, req); + struct nbench_private *private = ntvfs->private_data; NTSTATUS status; - PASS_THRU_REQ(req, trans, (req,trans2)); + PASS_THRU_REQ(ntvfs, req, trans, (ntvfs, req, trans2)); nbench_log(private, "Trans - NOT HANDLED\n"); diff --git a/source4/ntvfs/ntvfs.h b/source4/ntvfs/ntvfs.h index 96434f44e2..bee10e3c38 100644 --- a/source4/ntvfs/ntvfs.h +++ b/source4/ntvfs/ntvfs.h @@ -2,6 +2,7 @@ Unix SMB/CIFS implementation. NTVFS structures and defines Copyright (C) Andrew Tridgell 2003 + Copyright (C) Stefan Metzmacher 2004 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 @@ -19,9 +20,15 @@ */ /* modules can use the following to determine if the interface has changed */ -#define NTVFS_INTERFACE_VERSION 1 +/* version 1 -> 0 - make module stacking easier -- metze */ +#define NTVFS_INTERFACE_VERSION 0 +struct ntvfs_module_context; +/* each backend has to be one one of the following 3 basic types. In + * earlier versions of Samba backends needed to handle all types, now + * we implement them separately. */ +enum ntvfs_type {NTVFS_DISK, NTVFS_PRINT, NTVFS_IPC}; /* the ntvfs operations structure - contains function pointers to the backend implementations of each operation */ @@ -30,65 +37,105 @@ struct ntvfs_ops { enum ntvfs_type type; /* initial setup */ - NTSTATUS (*connect)(struct smbsrv_request *req, const char *sharename, int depth); - NTSTATUS (*disconnect)(struct smbsrv_tcon *tcon, int depth); + NTSTATUS (*connect)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename); + NTSTATUS (*disconnect)(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon); /* path operations */ - NTSTATUS (*unlink)(struct smbsrv_request *req, struct smb_unlink *unl); - NTSTATUS (*chkpath)(struct smbsrv_request *req, struct smb_chkpath *cp); - NTSTATUS (*qpathinfo)(struct smbsrv_request *req, union smb_fileinfo *st); - NTSTATUS (*setpathinfo)(struct smbsrv_request *req, union smb_setfileinfo *st); - NTSTATUS (*open)(struct smbsrv_request *req, union smb_open *oi); - NTSTATUS (*mkdir)(struct smbsrv_request *req, union smb_mkdir *md); - NTSTATUS (*rmdir)(struct smbsrv_request *req, struct smb_rmdir *rd); - NTSTATUS (*rename)(struct smbsrv_request *req, union smb_rename *ren); - NTSTATUS (*copy)(struct smbsrv_request *req, struct smb_copy *cp); + NTSTATUS (*unlink)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl); + NTSTATUS (*chkpath)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp); + NTSTATUS (*qpathinfo)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *st); + NTSTATUS (*setpathinfo)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st); + NTSTATUS (*open)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *oi); + NTSTATUS (*mkdir)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md); + NTSTATUS (*rmdir)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd); + NTSTATUS (*rename)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren); + NTSTATUS (*copy)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp); /* directory search */ - NTSTATUS (*search_first)(struct smbsrv_request *req, union smb_search_first *io, void *private, + NTSTATUS (*search_first)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *private, BOOL (*callback)(void *private, union smb_search_data *file)); - NTSTATUS (*search_next)(struct smbsrv_request *req, union smb_search_next *io, void *private, + NTSTATUS (*search_next)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *private, BOOL (*callback)(void *private, union smb_search_data *file)); - NTSTATUS (*search_close)(struct smbsrv_request *req, union smb_search_close *io); + NTSTATUS (*search_close)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io); /* operations on open files */ - NTSTATUS (*ioctl)(struct smbsrv_request *req, union smb_ioctl *io); - NTSTATUS (*read)(struct smbsrv_request *req, union smb_read *io); - NTSTATUS (*write)(struct smbsrv_request *req, union smb_write *io); - NTSTATUS (*seek)(struct smbsrv_request *req, struct smb_seek *io); - NTSTATUS (*flush)(struct smbsrv_request *req, struct smb_flush *flush); - NTSTATUS (*close)(struct smbsrv_request *req, union smb_close *io); - NTSTATUS (*exit)(struct smbsrv_request *req); - NTSTATUS (*lock)(struct smbsrv_request *req, union smb_lock *lck); - NTSTATUS (*setfileinfo)(struct smbsrv_request *req, union smb_setfileinfo *info); - NTSTATUS (*qfileinfo)(struct smbsrv_request *req, union smb_fileinfo *info); + NTSTATUS (*ioctl)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io); + NTSTATUS (*read)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *io); + NTSTATUS (*write)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *io); + NTSTATUS (*seek)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io); + NTSTATUS (*flush)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *flush); + NTSTATUS (*close)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io); + NTSTATUS (*exit)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req); + NTSTATUS (*lock)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck); + NTSTATUS (*setfileinfo)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info); + NTSTATUS (*qfileinfo)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info); /* filesystem operations */ - NTSTATUS (*fsinfo)(struct smbsrv_request *req, union smb_fsinfo *fs); + NTSTATUS (*fsinfo)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs); /* printing specific operations */ - NTSTATUS (*lpq)(struct smbsrv_request *req, union smb_lpq *lpq); + NTSTATUS (*lpq)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq); /* trans2 interface - only used by CIFS backend to prover complete passthru for testing */ - NTSTATUS (*trans2)(struct smbsrv_request *req, struct smb_trans2 *trans2); + NTSTATUS (*trans2)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2); /* trans interface - used by IPC backend for pipes and RAP calls */ - NTSTATUS (*trans)(struct smbsrv_request *req, struct smb_trans2 *trans); + NTSTATUS (*trans)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans); /* logoff - called when a vuid is closed */ - NTSTATUS (*logoff)(struct smbsrv_request *req); + NTSTATUS (*logoff)(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req); }; +struct ntvfs_module_context { + struct ntvfs_module_context *prev, *next; + void *private_data; + const struct ntvfs_ops *ops; + int depth; +}; + +struct ntvfs_context { + enum ntvfs_type type; + /* + * linked list of module contexts + */ + struct ntvfs_module_context *modules; +}; /* this structure is used by backends to determine the size of some critical types */ struct ntvfs_critical_sizes { int interface_version; + int sizeof_ntvfs_context; + int sizeof_ntvfs_module_context; int sizeof_ntvfs_ops; - int sizeof_SMB_OFF_T; int sizeof_smbsrv_tcon; int sizeof_smbsrv_request; }; - -/* useful macro for backends */ -#define NTVFS_GET_PRIVATE(struct_name, name, req) \ - struct struct_name *name = req->tcon->ntvfs_private_list[req->ntvfs_depth] diff --git a/source4/ntvfs/ntvfs_base.c b/source4/ntvfs/ntvfs_base.c index 72f4759cd5..acbd02d915 100644 --- a/source4/ntvfs/ntvfs_base.c +++ b/source4/ntvfs/ntvfs_base.c @@ -100,8 +100,9 @@ const struct ntvfs_critical_sizes *ntvfs_interface_version(void) { static const struct ntvfs_critical_sizes critical_sizes = { NTVFS_INTERFACE_VERSION, + sizeof(struct ntvfs_context), + sizeof(struct ntvfs_module_context), sizeof(struct ntvfs_ops), - sizeof(SMB_OFF_T), sizeof(struct smbsrv_tcon), sizeof(struct smbsrv_request), }; @@ -133,28 +134,47 @@ BOOL ntvfs_init(void) /* initialise a connection structure to point at a NTVFS backend */ -NTSTATUS ntvfs_init_connection(struct smbsrv_request *req) +NTSTATUS ntvfs_init_connection(struct smbsrv_request *req, enum ntvfs_type type) { const char **handlers = lp_ntvfs_handler(req->tcon->service); + int i; + struct ntvfs_context *ctx; - req->tcon->ntvfs_ops = ntvfs_backend_byname(handlers[0], req->tcon->type); + if (!handlers) { + return NT_STATUS_FOOBAR; + } - if (!req->tcon->ntvfs_ops) { - DEBUG(1,("ntvfs_init_connection: failed to find backend=%s, type=%d\n", handlers[0], req->tcon->type)); - return NT_STATUS_UNSUCCESSFUL; + ctx = talloc_p(req->tcon, struct ntvfs_context); + if (!ctx) { + return NT_STATUS_NO_MEMORY; } + ctx->type = type; + ctx->modules = NULL; - return NT_STATUS_OK; -} + for (i=0; handlers[i]; i++) { + struct ntvfs_module_context *ntvfs; + ntvfs = talloc_p(ctx, struct ntvfs_module_context); + if (!ntvfs) { + return NT_STATUS_NO_MEMORY; + } -/* - set the private pointer for a backend -*/ -void ntvfs_set_private(struct smbsrv_tcon *tcon, int depth, void *value) -{ - tcon->ntvfs_private_list = talloc_realloc_p(tcon, - tcon->ntvfs_private_list, - void *, depth+1); - tcon->ntvfs_private_list[depth] = value; + ntvfs->ops = ntvfs_backend_byname(handlers[i], ctx->type); + if (!ntvfs->ops) { + DEBUG(1,("ntvfs_init_connection: failed to find backend=%s, type=%d\n", + handlers[i], ctx->type)); + return NT_STATUS_UNSUCCESSFUL; + } + ntvfs->depth = i; + DLIST_ADD_END(ctx->modules, ntvfs, struct ntvfs_module_context *); + } + + if (!ctx->modules) { + talloc_free(ctx); + return NT_STATUS_FOOBAR; + } + + req->tcon->ntvfs_ctx = ctx; + + return NT_STATUS_OK; } diff --git a/source4/ntvfs/ntvfs_generic.c b/source4/ntvfs/ntvfs_generic.c index 731e91f5c9..9e1d653465 100644 --- a/source4/ntvfs/ntvfs_generic.c +++ b/source4/ntvfs/ntvfs_generic.c @@ -58,7 +58,7 @@ static BOOL is_exe_file(const char *fname) NTVFS open generic to any mapper */ NTSTATUS ntvfs_map_open(struct smbsrv_request *req, union smb_open *io, - const struct ntvfs_ops *ops) + struct ntvfs_module_context *ntvfs) { NTSTATUS status; union smb_open io2; @@ -146,7 +146,7 @@ NTSTATUS ntvfs_map_open(struct smbsrv_request *req, union smb_open *io, io2.generic.in.file_attr = io->openx.in.file_attrs; io2.generic.in.fname = io->openx.in.fname; - status = ops->open(req, &io2); + status = ntvfs->ops->open(ntvfs, req, &io2); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -228,7 +228,7 @@ NTSTATUS ntvfs_map_open(struct smbsrv_request *req, union smb_open *io, DEBUG(9,("ntvfs_map_open(OPEN): mapped flags=0x%x to access_mask=0x%x and share_access=0x%x\n", io->open.in.flags, io2.generic.in.access_mask, io2.generic.in.share_access)); - status = ops->open(req, &io2); + status = ntvfs->ops->open(ntvfs, req, &io2); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -251,7 +251,7 @@ NTSTATUS ntvfs_map_open(struct smbsrv_request *req, union smb_open *io, NTVFS fsinfo generic to any mapper */ NTSTATUS ntvfs_map_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs, - const struct ntvfs_ops *ops) + struct ntvfs_module_context *ntvfs) { NTSTATUS status; union smb_fsinfo fs2; @@ -263,7 +263,7 @@ NTSTATUS ntvfs_map_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs, /* ask the backend for the generic info */ fs2.generic.level = RAW_QFS_GENERIC; - status = ops->fsinfo(req, &fs2); + status = ntvfs->ops->fsinfo(ntvfs, req, &fs2); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -593,7 +593,7 @@ NTSTATUS ntvfs_map_fileinfo(struct smbsrv_request *req, union smb_fileinfo *info NTVFS fileinfo generic to any mapper */ NTSTATUS ntvfs_map_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info, - const struct ntvfs_ops *ops) + struct ntvfs_module_context *ntvfs) { NTSTATUS status; union smb_fileinfo info2; @@ -606,7 +606,7 @@ NTSTATUS ntvfs_map_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *inf info2.generic.level = RAW_FILEINFO_GENERIC; info2.generic.in.fnum = info->generic.in.fnum; - status = ops->qfileinfo(req, &info2); + status = ntvfs->ops->qfileinfo(ntvfs, req, &info2); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -617,7 +617,7 @@ NTSTATUS ntvfs_map_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *inf NTVFS pathinfo generic to any mapper */ NTSTATUS ntvfs_map_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info, - const struct ntvfs_ops *ops) + struct ntvfs_module_context *ntvfs) { NTSTATUS status; union smb_fileinfo info2; @@ -630,7 +630,7 @@ NTSTATUS ntvfs_map_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *inf info2.generic.level = RAW_FILEINFO_GENERIC; info2.generic.in.fname = info->generic.in.fname; - status = ops->qpathinfo(req, &info2); + status = ntvfs->ops->qpathinfo(ntvfs, req, &info2); if (!NT_STATUS_IS_OK(status)) { return status; } diff --git a/source4/ntvfs/ntvfs_interface.c b/source4/ntvfs/ntvfs_interface.c new file mode 100644 index 0000000000..06cda11000 --- /dev/null +++ b/source4/ntvfs/ntvfs_interface.c @@ -0,0 +1,566 @@ +/* + Unix SMB/CIFS implementation. + NTVFS interface functions + + Copyright (C) Stefan (metze) Metzmacher 2004 + + 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 + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + 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. +*/ + +#include "includes.h" + +/* connect/disconnect */ +NTSTATUS ntvfs_connect(struct smbsrv_request *req, const char *sharename) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->connect) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->connect(ntvfs, req, sharename); +} + +NTSTATUS ntvfs_disconnect(struct smbsrv_tcon *tcon) +{ + struct ntvfs_module_context *ntvfs = tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->disconnect) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->disconnect(ntvfs, tcon); +} + +/* path operations */ +NTSTATUS ntvfs_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->unlink) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->unlink(ntvfs, req, unl); +} + +NTSTATUS ntvfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->chkpath) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->chkpath(ntvfs, req, cp); +} + +NTSTATUS ntvfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *st) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->qpathinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->qpathinfo(ntvfs, req, st); +} + +NTSTATUS ntvfs_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->setpathinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->setpathinfo(ntvfs, req, st); +} + +NTSTATUS ntvfs_open(struct smbsrv_request *req, union smb_open *oi) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->open) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->open(ntvfs, req, oi); +} + +NTSTATUS ntvfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->mkdir) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->mkdir(ntvfs, req, md); +} + +NTSTATUS ntvfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->rmdir) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->rmdir(ntvfs, req, rd); +} + +NTSTATUS ntvfs_rename(struct smbsrv_request *req, union smb_rename *ren) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->rename) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->rename(ntvfs, req, ren); +} + +NTSTATUS ntvfs_copy(struct smbsrv_request *req, struct smb_copy *cp) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->copy) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->copy(ntvfs, req, cp); +} + +/* directory search */ +NTSTATUS ntvfs_search_first(struct smbsrv_request *req, union smb_search_first *io, void *private, + BOOL ntvfs_callback(void *private, union smb_search_data *file)) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->search_first) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->search_first(ntvfs, req, io, private, ntvfs_callback); +} + +NTSTATUS ntvfs_search_next(struct smbsrv_request *req, union smb_search_next *io, void *private, + BOOL ntvfs_callback(void *private, union smb_search_data *file)) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->search_next) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->search_next(ntvfs, req, io, private, ntvfs_callback); +} + +NTSTATUS ntvfs_search_close(struct smbsrv_request *req, union smb_search_close *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->search_close) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->search_close(ntvfs, req, io); +} + +/* operations on open files */ +NTSTATUS ntvfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->ioctl) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->ioctl(ntvfs, req, io); +} + +NTSTATUS ntvfs_read(struct smbsrv_request *req, union smb_read *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->read) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->read(ntvfs, req, io); +} + +NTSTATUS ntvfs_write(struct smbsrv_request *req, union smb_write *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->write) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->write(ntvfs, req, io); +} + +NTSTATUS ntvfs_seek(struct smbsrv_request *req, struct smb_seek *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->seek) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->seek(ntvfs, req, io); +} + +NTSTATUS ntvfs_flush(struct smbsrv_request *req, struct smb_flush *flush) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->flush) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->flush(ntvfs, req, flush); +} + +NTSTATUS ntvfs_close(struct smbsrv_request *req, union smb_close *io) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->close) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->close(ntvfs, req, io); +} + +NTSTATUS ntvfs_exit(struct smbsrv_request *req) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->exit) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->exit(ntvfs, req); +} + +NTSTATUS ntvfs_lock(struct smbsrv_request *req, union smb_lock *lck) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->lock) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->lock(ntvfs, req, lck); +} + +NTSTATUS ntvfs_setfileinfo(struct smbsrv_request *req, union smb_setfileinfo *info) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->setfileinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->setfileinfo(ntvfs, req, info); +} + +NTSTATUS ntvfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->qfileinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->qfileinfo(ntvfs, req, info); +} + +/* filesystem operations */ +NTSTATUS ntvfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->fsinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->fsinfo(ntvfs, req, fs); +} + +/* printing specific operations */ +NTSTATUS ntvfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->lpq) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->lpq(ntvfs, req, lpq); +} + +/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */ +NTSTATUS ntvfs_trans2(struct smbsrv_request *req, struct smb_trans2 *trans2) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->trans2) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->trans2(ntvfs, req, trans2); +} + +/* trans interface - used by IPC backend for pipes and RAP calls */ +NTSTATUS ntvfs_trans(struct smbsrv_request *req, struct smb_trans2 *trans) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->trans) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->trans(ntvfs, req, trans); +} + +/* logoff - called when a vuid is closed */ +NTSTATUS ntvfs_logoff(struct smbsrv_request *req) +{ + struct ntvfs_module_context *ntvfs = req->tcon->ntvfs_ctx->modules; + if (!ntvfs->ops->logoff) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->ops->logoff(ntvfs, req); +} + +/* initial setup */ +NTSTATUS ntvfs_next_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) +{ + if (!ntvfs->next || !ntvfs->next->ops->connect) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->connect(ntvfs->next, req, sharename); +} + +NTSTATUS ntvfs_next_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) +{ + if (!ntvfs->next || !ntvfs->next->ops->disconnect) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->disconnect(ntvfs->next, tcon); +} + +/* path operations */ +NTSTATUS ntvfs_next_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) +{ + if (!ntvfs->next || !ntvfs->next->ops->unlink) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->unlink(ntvfs->next, req, unl); +} + +NTSTATUS ntvfs_next_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) +{ + if (!ntvfs->next || !ntvfs->next->ops->chkpath) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->chkpath(ntvfs->next, req, cp); +} + +NTSTATUS ntvfs_next_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *st) +{ + if (!ntvfs->next || !ntvfs->next->ops->qpathinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->qpathinfo(ntvfs->next, req, st); +} + +NTSTATUS ntvfs_next_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) +{ + if (!ntvfs->next || !ntvfs->next->ops->setpathinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->setpathinfo(ntvfs->next, req, st); +} + +NTSTATUS ntvfs_next_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *oi) +{ + if (!ntvfs->next || !ntvfs->next->ops->open) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->open(ntvfs->next, req, oi); +} + +NTSTATUS ntvfs_next_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) +{ + if (!ntvfs->next || !ntvfs->next->ops->mkdir) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->mkdir(ntvfs->next, req, md); +} + +NTSTATUS ntvfs_next_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) +{ + if (!ntvfs->next || !ntvfs->next->ops->rmdir) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->rmdir(ntvfs->next, req, rd); +} + +NTSTATUS ntvfs_next_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) +{ + if (!ntvfs->next || !ntvfs->next->ops->rename) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->rename(ntvfs->next, req, ren); +} + +NTSTATUS ntvfs_next_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) +{ + if (!ntvfs->next || !ntvfs->next->ops->copy) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->copy(ntvfs->next, req, cp); +} + +/* directory search */ +NTSTATUS ntvfs_next_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *private, + BOOL (*callback)(void *private, union smb_search_data *file)) +{ + if (!ntvfs->next || !ntvfs->next->ops->search_first) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->search_first(ntvfs->next, req, io, private, callback); +} + +NTSTATUS ntvfs_next_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *private, + BOOL (*callback)(void *private, union smb_search_data *file)) +{ + if (!ntvfs->next || !ntvfs->next->ops->search_next) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->search_next(ntvfs->next, req, io, private, callback); +} + +NTSTATUS ntvfs_next_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->search_close) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->search_close(ntvfs->next, req, io); +} + +/* operations on open files */ +NTSTATUS ntvfs_next_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->ioctl) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->ioctl(ntvfs->next, req, io); +} + +NTSTATUS ntvfs_next_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->read) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->read(ntvfs->next, req, io); +} + +NTSTATUS ntvfs_next_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->write) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->write(ntvfs->next, req, io); +} + +NTSTATUS ntvfs_next_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->seek) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->seek(ntvfs->next, req, io); +} + +NTSTATUS ntvfs_next_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *flush) +{ + if (!ntvfs->next || !ntvfs->next->ops->flush) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->flush(ntvfs->next, req, flush); +} + +NTSTATUS ntvfs_next_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) +{ + if (!ntvfs->next || !ntvfs->next->ops->close) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->close(ntvfs->next, req, io); +} + +NTSTATUS ntvfs_next_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) +{ + if (!ntvfs->next || !ntvfs->next->ops->exit) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->exit(ntvfs->next, req); +} + +NTSTATUS ntvfs_next_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) +{ + if (!ntvfs->next || !ntvfs->next->ops->lock) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->lock(ntvfs->next, req, lck); +} + +NTSTATUS ntvfs_next_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info) +{ + if (!ntvfs->next || !ntvfs->next->ops->setfileinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->setfileinfo(ntvfs->next, req, info); +} + +NTSTATUS ntvfs_next_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) +{ + if (!ntvfs->next || !ntvfs->next->ops->qfileinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->qfileinfo(ntvfs->next, req, info); +} + +/* filesystem operations */ +NTSTATUS ntvfs_next_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) +{ + if (!ntvfs->next || !ntvfs->next->ops->fsinfo) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->fsinfo(ntvfs->next, req, fs); +} + +/* printing specific operations */ +NTSTATUS ntvfs_next_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) +{ + if (!ntvfs->next || !ntvfs->next->ops->lpq) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->lpq(ntvfs->next, req, lpq); +} + +/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */ +NTSTATUS ntvfs_next_trans2(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) +{ + if (!ntvfs->next || !ntvfs->next->ops->trans2) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->trans2(ntvfs->next, req, trans2); +} + +/* trans interface - used by IPC backend for pipes and RAP calls */ +NTSTATUS ntvfs_next_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans) +{ + if (!ntvfs->next || !ntvfs->next->ops->trans) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->trans(ntvfs->next, req, trans); +} + +/* logoff - called when a vuid is closed */ +NTSTATUS ntvfs_next_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) +{ + if (!ntvfs->next || !ntvfs->next->ops->logoff) { + return NT_STATUS_NOT_IMPLEMENTED; + } + return ntvfs->next->ops->logoff(ntvfs->next, req); +} diff --git a/source4/ntvfs/posix/pvfs_fsinfo.c b/source4/ntvfs/posix/pvfs_fsinfo.c index f1c42e8920..a9153b4c19 100644 --- a/source4/ntvfs/posix/pvfs_fsinfo.c +++ b/source4/ntvfs/posix/pvfs_fsinfo.c @@ -27,13 +27,14 @@ /* return filesystem space info */ -NTSTATUS pvfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +NTSTATUS pvfs_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct stat st; if (fs->generic.level != RAW_QFS_GENERIC) { - return ntvfs_map_fsinfo(req, fs, pvfs->ops); + return ntvfs_map_fsinfo(req, fs, ntvfs); } if (sys_fsusage(pvfs->base_directory, diff --git a/source4/ntvfs/posix/pvfs_mkdir.c b/source4/ntvfs/posix/pvfs_mkdir.c index de51d2e8fd..d7dcc7dd50 100644 --- a/source4/ntvfs/posix/pvfs_mkdir.c +++ b/source4/ntvfs/posix/pvfs_mkdir.c @@ -26,9 +26,10 @@ /* create a directory */ -NTSTATUS pvfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +NTSTATUS pvfs_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; NTSTATUS status; struct pvfs_filename *name; @@ -60,9 +61,10 @@ NTSTATUS pvfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) /* remove a directory */ -NTSTATUS pvfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +NTSTATUS pvfs_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; NTSTATUS status; struct pvfs_filename *name; diff --git a/source4/ntvfs/posix/pvfs_open.c b/source4/ntvfs/posix/pvfs_open.c index f3bec4085e..560d194a34 100644 --- a/source4/ntvfs/posix/pvfs_open.c +++ b/source4/ntvfs/posix/pvfs_open.c @@ -27,9 +27,9 @@ /* find open file handle given fnum */ -struct pvfs_file *pvfs_find_fd(struct smbsrv_request *req, uint16_t fnum) +struct pvfs_file *pvfs_find_fd(struct pvfs_state *pvfs, + struct smbsrv_request *req, uint16_t fnum) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); struct pvfs_file *f; for (f=pvfs->open_files;f;f=f->next) { if (f->fnum == fnum) { @@ -63,16 +63,17 @@ static int pvfs_fd_destructor(void *p) TODO: this is a temporary implementation derived from the simple backend its purpose is to allow other tests to run */ -NTSTATUS pvfs_open(struct smbsrv_request *req, union smb_open *io) +NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *io) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; int fd, flags; struct pvfs_filename *name; struct pvfs_file *f; NTSTATUS status; if (io->generic.level != RAW_OPEN_GENERIC) { - return ntvfs_map_open(req, io, pvfs->ops); + return ntvfs_map_open(req, io, ntvfs); } /* resolve the cifs name to a posix name */ @@ -179,9 +180,10 @@ do_open: /* close a file */ -NTSTATUS pvfs_close(struct smbsrv_request *req, union smb_close *io) +NTSTATUS pvfs_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_file *f; NTSTATUS status; @@ -190,7 +192,7 @@ NTSTATUS pvfs_close(struct smbsrv_request *req, union smb_close *io) return NT_STATUS_INVALID_LEVEL; } - f = pvfs_find_fd(req, io->close.in.fnum); + f = pvfs_find_fd(pvfs, req, io->close.in.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } @@ -213,9 +215,10 @@ NTSTATUS pvfs_close(struct smbsrv_request *req, union smb_close *io) /* logoff - close all file descriptors open by a vuid */ -NTSTATUS pvfs_logoff(struct smbsrv_request *req) +NTSTATUS pvfs_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_file *f, *next; for (f=pvfs->open_files;f;f=next) { @@ -234,9 +237,10 @@ NTSTATUS pvfs_logoff(struct smbsrv_request *req) /* exit - close files for the current pid */ -NTSTATUS pvfs_exit(struct smbsrv_request *req) +NTSTATUS pvfs_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_file *f, *next; for (f=pvfs->open_files;f;f=next) { @@ -250,4 +254,3 @@ NTSTATUS pvfs_exit(struct smbsrv_request *req) return NT_STATUS_OK; } - diff --git a/source4/ntvfs/posix/pvfs_qfileinfo.c b/source4/ntvfs/posix/pvfs_qfileinfo.c index 81706bcfe8..30390722d1 100644 --- a/source4/ntvfs/posix/pvfs_qfileinfo.c +++ b/source4/ntvfs/posix/pvfs_qfileinfo.c @@ -78,14 +78,15 @@ static NTSTATUS pvfs_map_fileinfo(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx, /* return info on a pathname */ -NTSTATUS pvfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) +NTSTATUS pvfs_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_filename *name; NTSTATUS status; if (info->generic.level != RAW_FILEINFO_GENERIC) { - return ntvfs_map_qpathinfo(req, info, pvfs->ops); + return ntvfs_map_qpathinfo(req, info, ntvfs); } /* resolve the cifs name to a posix name */ @@ -104,17 +105,18 @@ NTSTATUS pvfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) /* query info on a open file */ -NTSTATUS pvfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +NTSTATUS pvfs_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_file *f; NTSTATUS status; if (info->generic.level != RAW_FILEINFO_GENERIC) { - return ntvfs_map_qfileinfo(req, info, pvfs->ops); + return ntvfs_map_qfileinfo(req, info, ntvfs); } - f = pvfs_find_fd(req, info->generic.in.fnum); + f = pvfs_find_fd(pvfs, req, info->generic.in.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } diff --git a/source4/ntvfs/posix/pvfs_read.c b/source4/ntvfs/posix/pvfs_read.c index 72ac00a32d..e0c7e0b1f2 100644 --- a/source4/ntvfs/posix/pvfs_read.c +++ b/source4/ntvfs/posix/pvfs_read.c @@ -26,9 +26,10 @@ /* read from a file */ -NTSTATUS pvfs_read(struct smbsrv_request *req, union smb_read *rd) +NTSTATUS pvfs_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *rd) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; ssize_t ret; struct pvfs_file *f; @@ -37,7 +38,7 @@ NTSTATUS pvfs_read(struct smbsrv_request *req, union smb_read *rd) } - f = pvfs_find_fd(req, rd->readx.in.fnum); + f = pvfs_find_fd(pvfs, req, rd->readx.in.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } diff --git a/source4/ntvfs/posix/pvfs_rename.c b/source4/ntvfs/posix/pvfs_rename.c index a58a1e9c6e..51393c9499 100644 --- a/source4/ntvfs/posix/pvfs_rename.c +++ b/source4/ntvfs/posix/pvfs_rename.c @@ -26,9 +26,10 @@ /* rename a set of files */ -NTSTATUS pvfs_rename(struct smbsrv_request *req, union smb_rename *ren) +NTSTATUS pvfs_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; NTSTATUS status; struct pvfs_filename *name1, *name2; diff --git a/source4/ntvfs/posix/pvfs_search.c b/source4/ntvfs/posix/pvfs_search.c index 414b010263..f8d538bab2 100644 --- a/source4/ntvfs/posix/pvfs_search.c +++ b/source4/ntvfs/posix/pvfs_search.c @@ -250,12 +250,13 @@ again: /* list files in a directory matching a wildcard pattern - old SMBsearch interface */ -static NTSTATUS pvfs_search_first_old(struct smbsrv_request *req, union smb_search_first *io, +static NTSTATUS pvfs_search_first_old(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { struct pvfs_dir *dir; - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_search_state *search; uint_t reply_count; uint16_t search_attrib; @@ -327,11 +328,12 @@ static NTSTATUS pvfs_search_first_old(struct smbsrv_request *req, union smb_sear } /* continue a old style search */ -static NTSTATUS pvfs_search_next_old(struct smbsrv_request *req, union smb_search_next *io, +static NTSTATUS pvfs_search_next_old(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_search_state *search; struct pvfs_dir *dir; uint_t reply_count, max_count; @@ -374,12 +376,13 @@ static NTSTATUS pvfs_search_next_old(struct smbsrv_request *req, union smb_searc /* list files in a directory matching a wildcard pattern */ -NTSTATUS pvfs_search_first(struct smbsrv_request *req, union smb_search_first *io, +NTSTATUS pvfs_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { struct pvfs_dir *dir; - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_search_state *search; uint_t reply_count; uint16_t search_attrib, max_count; @@ -388,7 +391,7 @@ NTSTATUS pvfs_search_first(struct smbsrv_request *req, union smb_search_first *i struct pvfs_filename *name; if (io->generic.level >= RAW_SEARCH_SEARCH) { - return pvfs_search_first_old(req, io, search_private, callback); + return pvfs_search_first_old(ntvfs, req, io, search_private, callback); } search_attrib = io->t2ffirst.in.search_attrib; @@ -466,11 +469,12 @@ NTSTATUS pvfs_search_first(struct smbsrv_request *req, union smb_search_first *i } /* continue a search */ -NTSTATUS pvfs_search_next(struct smbsrv_request *req, union smb_search_next *io, +NTSTATUS pvfs_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_search_state *search; struct pvfs_dir *dir; uint_t reply_count; @@ -479,7 +483,7 @@ NTSTATUS pvfs_search_next(struct smbsrv_request *req, union smb_search_next *io, int i; if (io->generic.level >= RAW_SEARCH_SEARCH) { - return pvfs_search_next_old(req, io, search_private, callback); + return pvfs_search_next_old(ntvfs, req, io, search_private, callback); } handle = io->t2fnext.in.handle; @@ -545,9 +549,10 @@ found: } /* close a search */ -NTSTATUS pvfs_search_close(struct smbsrv_request *req, union smb_search_close *io) +NTSTATUS pvfs_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_search_state *search; uint16_t handle; diff --git a/source4/ntvfs/posix/pvfs_setfileinfo.c b/source4/ntvfs/posix/pvfs_setfileinfo.c index 2ea2fdaf8e..f1d5d14089 100644 --- a/source4/ntvfs/posix/pvfs_setfileinfo.c +++ b/source4/ntvfs/posix/pvfs_setfileinfo.c @@ -26,14 +26,15 @@ /* set info on a open file */ -NTSTATUS pvfs_setfileinfo(struct smbsrv_request *req, +NTSTATUS pvfs_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info) { - NTVFS_GET_PRIVATE(pvfs_private, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct utimbuf unix_times; struct pvfs_file *f; - f = pvfs_find_fd(req, info->generic.file.fnum); + f = pvfs_find_fd(pvfs, req, info->generic.file.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } diff --git a/source4/ntvfs/posix/pvfs_unlink.c b/source4/ntvfs/posix/pvfs_unlink.c index 9e0353c041..0f4ff8b148 100644 --- a/source4/ntvfs/posix/pvfs_unlink.c +++ b/source4/ntvfs/posix/pvfs_unlink.c @@ -61,9 +61,10 @@ static NTSTATUS pvfs_unlink_one(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx, delete a file - the dirtype specifies the file types to include in the search. The name can contain CIFS wildcards, but rarely does (except with OS/2 clients) */ -NTSTATUS pvfs_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +NTSTATUS pvfs_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_dir *dir; NTSTATUS status; uint32_t i, total_deleted=0; diff --git a/source4/ntvfs/posix/pvfs_write.c b/source4/ntvfs/posix/pvfs_write.c index 02ba1b8228..a49f4fe947 100644 --- a/source4/ntvfs/posix/pvfs_write.c +++ b/source4/ntvfs/posix/pvfs_write.c @@ -27,15 +27,16 @@ /* write to a file */ -NTSTATUS pvfs_write(struct smbsrv_request *req, union smb_write *wr) +NTSTATUS pvfs_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *wr) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; ssize_t ret; struct pvfs_file *f; switch (wr->generic.level) { case RAW_WRITE_WRITEX: - f = pvfs_find_fd(req, wr->writex.in.fnum); + f = pvfs_find_fd(pvfs, req, wr->writex.in.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } @@ -53,7 +54,7 @@ NTSTATUS pvfs_write(struct smbsrv_request *req, union smb_write *wr) return NT_STATUS_OK; case RAW_WRITE_WRITE: - f = pvfs_find_fd(req, wr->write.in.fnum); + f = pvfs_find_fd(pvfs, req, wr->write.in.fnum); if (!f) { return NT_STATUS_INVALID_HANDLE; } diff --git a/source4/ntvfs/posix/vfs_posix.c b/source4/ntvfs/posix/vfs_posix.c index 7ae7c6759a..44875f1879 100644 --- a/source4/ntvfs/posix/vfs_posix.c +++ b/source4/ntvfs/posix/vfs_posix.c @@ -50,7 +50,8 @@ static void pvfs_setup_options(struct pvfs_state *pvfs) directory exists (tho it doesn't need to be accessible by the user, that comes later) */ -static NTSTATUS pvfs_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS pvfs_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { struct smbsrv_tcon *tcon = req->tcon; struct pvfs_state *pvfs; @@ -71,7 +72,6 @@ static NTSTATUS pvfs_connect(struct smbsrv_request *req, const char *sharename, pvfs->tcon = tcon; pvfs->base_directory = base_directory; - pvfs->ops = ntvfs_backend_byname("posix", NTVFS_DISK); /* the directory must exist. Note that we deliberately don't check that it is readable */ @@ -84,7 +84,7 @@ static NTSTATUS pvfs_connect(struct smbsrv_request *req, const char *sharename, tcon->fs_type = talloc_strdup(tcon, "NTFS"); tcon->dev_type = talloc_strdup(tcon, "A:"); - ntvfs_set_private(tcon, depth, pvfs); + ntvfs->private_data = pvfs; pvfs_setup_options(pvfs); @@ -94,7 +94,8 @@ static NTSTATUS pvfs_connect(struct smbsrv_request *req, const char *sharename, /* disconnect from a share */ -static NTSTATUS pvfs_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS pvfs_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { return NT_STATUS_OK; } @@ -102,7 +103,8 @@ static NTSTATUS pvfs_disconnect(struct smbsrv_tcon *tcon, int depth) /* ioctl interface - we don't do any */ -static NTSTATUS pvfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS pvfs_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { return NT_STATUS_INVALID_PARAMETER; } @@ -110,9 +112,10 @@ static NTSTATUS pvfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) /* check if a directory exists */ -static NTSTATUS pvfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +static NTSTATUS pvfs_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) { - NTVFS_GET_PRIVATE(pvfs_state, pvfs, req); + struct pvfs_state *pvfs = ntvfs->private_data; struct pvfs_filename *name; NTSTATUS status; @@ -136,7 +139,8 @@ static NTSTATUS pvfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) /* copy a set of files */ -static NTSTATUS pvfs_copy(struct smbsrv_request *req, struct smb_copy *cp) +static NTSTATUS pvfs_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) { DEBUG(0,("pvfs_copy not implemented\n")); return NT_STATUS_NOT_SUPPORTED; @@ -145,7 +149,8 @@ static NTSTATUS pvfs_copy(struct smbsrv_request *req, struct smb_copy *cp) /* seek in a file */ -static NTSTATUS pvfs_seek(struct smbsrv_request *req, struct smb_seek *io) +static NTSTATUS pvfs_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) { DEBUG(0,("pvfs_seek not implemented\n")); return NT_STATUS_NOT_SUPPORTED; @@ -154,7 +159,8 @@ static NTSTATUS pvfs_seek(struct smbsrv_request *req, struct smb_seek *io) /* flush a file */ -static NTSTATUS pvfs_flush(struct smbsrv_request *req, struct smb_flush *io) +static NTSTATUS pvfs_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *io) { DEBUG(0,("pvfs_flush not implemented\n")); return NT_STATUS_NOT_IMPLEMENTED; @@ -163,7 +169,8 @@ static NTSTATUS pvfs_flush(struct smbsrv_request *req, struct smb_flush *io) /* lock a byte range */ -static NTSTATUS pvfs_lock(struct smbsrv_request *req, union smb_lock *lck) +static NTSTATUS pvfs_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) { DEBUG(0,("pvfs_lock not implemented\n")); return NT_STATUS_NOT_IMPLEMENTED; @@ -172,7 +179,8 @@ static NTSTATUS pvfs_lock(struct smbsrv_request *req, union smb_lock *lck) /* set info on a pathname */ -static NTSTATUS pvfs_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +static NTSTATUS pvfs_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) { DEBUG(0,("pvfs_setpathinfo not implemented\n")); return NT_STATUS_NOT_SUPPORTED; @@ -181,13 +189,15 @@ static NTSTATUS pvfs_setpathinfo(struct smbsrv_request *req, union smb_setfilein /* return print queue info */ -static NTSTATUS pvfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +static NTSTATUS pvfs_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) { return NT_STATUS_NOT_SUPPORTED; } /* SMBtrans - not used on file shares */ -static NTSTATUS pvfs_trans(struct smbsrv_request *req, struct smb_trans2 *trans2) +static NTSTATUS pvfs_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) { return NT_STATUS_ACCESS_DENIED; } diff --git a/source4/ntvfs/posix/vfs_posix.h b/source4/ntvfs/posix/vfs_posix.h index 96ab7f85b2..0daacf2c33 100644 --- a/source4/ntvfs/posix/vfs_posix.h +++ b/source4/ntvfs/posix/vfs_posix.h @@ -49,8 +49,6 @@ struct pvfs_state { } search; struct pvfs_file *open_files; - - const struct ntvfs_ops *ops; }; diff --git a/source4/ntvfs/print/vfs_print.c b/source4/ntvfs/print/vfs_print.c index 0e6824a14e..d487392e6f 100644 --- a/source4/ntvfs/print/vfs_print.c +++ b/source4/ntvfs/print/vfs_print.c @@ -29,7 +29,8 @@ in. For printing shares this should check that the spool directory is available */ -static NTSTATUS print_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS print_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { return NT_STATUS_OK; } @@ -37,7 +38,8 @@ static NTSTATUS print_connect(struct smbsrv_request *req, const char *sharename, /* disconnect from a share */ -static NTSTATUS print_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS print_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { return NT_STATUS_OK; } @@ -45,7 +47,8 @@ static NTSTATUS print_disconnect(struct smbsrv_tcon *tcon, int depth) /* lots of operations are not allowed on printing shares - mostly return NT_STATUS_ACCESS_DENIED */ -static NTSTATUS print_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +static NTSTATUS print_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { return NT_STATUS_ACCESS_DENIED; } @@ -54,7 +57,8 @@ static NTSTATUS print_unlink(struct smbsrv_request *req, struct smb_unlink *unl) /* ioctl - used for job query */ -static NTSTATUS print_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS print_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { char *p; diff --git a/source4/ntvfs/simple/svfs.h b/source4/ntvfs/simple/svfs.h index d3bafb42e3..8e462d99f4 100644 --- a/source4/ntvfs/simple/svfs.h +++ b/source4/ntvfs/simple/svfs.h @@ -10,8 +10,6 @@ struct svfs_private { uint16_t next_search_handle; struct svfs_file *open_files; - - const struct ntvfs_ops *ops; }; struct svfs_dir { diff --git a/source4/ntvfs/simple/svfs_util.c b/source4/ntvfs/simple/svfs_util.c index b6b7171487..2ac12b1918 100644 --- a/source4/ntvfs/simple/svfs_util.c +++ b/source4/ntvfs/simple/svfs_util.c @@ -29,9 +29,10 @@ /* convert a windows path to a unix path - don't do any manging or case sensitive handling */ -char *svfs_unix_path(struct smbsrv_request *req, const char *name) +char *svfs_unix_path(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *name) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; char *ret; if (*name != '\\') { @@ -135,14 +136,15 @@ struct svfs_dir *svfs_list_unix(TALLOC_CTX *mem_ctx, struct smbsrv_request *req, returned names are separate unix and DOS names. The returned names are relative to the directory */ -struct svfs_dir *svfs_list(TALLOC_CTX *mem_ctx, struct smbsrv_request *req, const char *pattern) +struct svfs_dir *svfs_list(struct ntvfs_module_context *ntvfs, struct smbsrv_request *req, const char *pattern) { + struct svfs_private *private = ntvfs->private_data; char *unix_path; - unix_path = svfs_unix_path(req, pattern); + unix_path = svfs_unix_path(ntvfs, req, pattern); if (!unix_path) { return NULL; } - return svfs_list_unix(mem_ctx, req, unix_path); + return svfs_list_unix(private, req, unix_path); } diff --git a/source4/ntvfs/simple/vfs_simple.c b/source4/ntvfs/simple/vfs_simple.c index f60646ed77..7f5d447a09 100644 --- a/source4/ntvfs/simple/vfs_simple.c +++ b/source4/ntvfs/simple/vfs_simple.c @@ -61,7 +61,8 @@ static ssize_t pwrite(int __fd, const void *__buf, size_t __nbytes, off_t __offs directory exists (tho it doesn't need to be accessible by the user, that comes later) */ -static NTSTATUS svfs_connect(struct smbsrv_request *req, const char *sharename, int depth) +static NTSTATUS svfs_connect(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, const char *sharename) { struct stat st; struct smbsrv_tcon *tcon = req->tcon; @@ -72,7 +73,6 @@ static NTSTATUS svfs_connect(struct smbsrv_request *req, const char *sharename, private->next_search_handle = 0; private->connectpath = talloc_strdup(tcon, lp_pathname(tcon->service)); private->open_files = NULL; - private->ops = ntvfs_backend_byname("simple", NTVFS_DISK); private->search = NULL; /* the directory must exist */ @@ -85,7 +85,7 @@ static NTSTATUS svfs_connect(struct smbsrv_request *req, const char *sharename, tcon->fs_type = talloc_strdup(tcon, "NTFS"); tcon->dev_type = talloc_strdup(tcon, "A:"); - ntvfs_set_private(tcon, depth, private); + ntvfs->private_data = private; DEBUG(0,("WARNING: ntvfs simple: connect to share [%s] with ROOT privileges!!!\n",sharename)); @@ -95,7 +95,8 @@ static NTSTATUS svfs_connect(struct smbsrv_request *req, const char *sharename, /* disconnect from a share */ -static NTSTATUS svfs_disconnect(struct smbsrv_tcon *tcon, int depth) +static NTSTATUS svfs_disconnect(struct ntvfs_module_context *ntvfs, + struct smbsrv_tcon *tcon) { return NT_STATUS_OK; } @@ -118,13 +119,14 @@ static struct svfs_file *find_fd(struct svfs_private *private, int fd) delete a file - the dirtype specifies the file types to include in the search. The name can contain CIFS wildcards, but rarely does (except with OS/2 clients) */ -static NTSTATUS svfs_unlink(struct smbsrv_request *req, struct smb_unlink *unl) +static NTSTATUS svfs_unlink(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_unlink *unl) { char *unix_path; CHECK_READ_ONLY(req); - unix_path = svfs_unix_path(req, unl->in.pattern); + unix_path = svfs_unix_path(ntvfs, req, unl->in.pattern); /* ignoring wildcards ... */ if (unlink(unix_path) == -1) { @@ -138,7 +140,8 @@ static NTSTATUS svfs_unlink(struct smbsrv_request *req, struct smb_unlink *unl) /* ioctl interface - we don't do any */ -static NTSTATUS svfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) +static NTSTATUS svfs_ioctl(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_ioctl *io) { return NT_STATUS_INVALID_PARAMETER; } @@ -146,12 +149,13 @@ static NTSTATUS svfs_ioctl(struct smbsrv_request *req, union smb_ioctl *io) /* check if a directory exists */ -static NTSTATUS svfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) +static NTSTATUS svfs_chkpath(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_chkpath *cp) { char *unix_path; struct stat st; - unix_path = svfs_unix_path(req, cp->in.path); + unix_path = svfs_unix_path(ntvfs, req, cp->in.path); if (stat(unix_path, &st) == -1) { return map_nt_error_from_unix(errno); @@ -167,7 +171,8 @@ static NTSTATUS svfs_chkpath(struct smbsrv_request *req, struct smb_chkpath *cp) /* approximately map a struct stat to a generic fileinfo struct */ -static NTSTATUS svfs_map_fileinfo(struct smbsrv_request *req, union smb_fileinfo *info, +static NTSTATUS svfs_map_fileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info, struct stat *st, const char *unix_path) { struct svfs_dir *dir = NULL; @@ -242,18 +247,18 @@ static NTSTATUS svfs_map_fileinfo(struct smbsrv_request *req, union smb_fileinfo /* return info on a pathname */ -static NTSTATUS svfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS svfs_qpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(svfs_private, private, req); char *unix_path; struct stat st; DEBUG(19,("svfs_qpathinfo: file %s level 0x%x\n", info->generic.in.fname, info->generic.level)); if (info->generic.level != RAW_FILEINFO_GENERIC) { - return ntvfs_map_qpathinfo(req, info, private->ops); + return ntvfs_map_qpathinfo(req, info, ntvfs); } - unix_path = svfs_unix_path(req, info->generic.in.fname); + unix_path = svfs_unix_path(ntvfs, req, info->generic.in.fname); DEBUG(19,("svfs_qpathinfo: file %s\n", unix_path)); if (stat(unix_path, &st) == -1) { DEBUG(19,("svfs_qpathinfo: file %s errno=%d\n", unix_path, errno)); @@ -262,20 +267,21 @@ static NTSTATUS svfs_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *i return map_nt_error_from_unix(errno); } DEBUG(19,("svfs_qpathinfo: file %s, stat done\n", unix_path)); - return svfs_map_fileinfo(req, info, &st, unix_path); + return svfs_map_fileinfo(ntvfs, req, info, &st, unix_path); } /* query info on a open file */ -static NTSTATUS svfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info) +static NTSTATUS svfs_qfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fileinfo *info) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct svfs_file *f; struct stat st; if (info->generic.level != RAW_FILEINFO_GENERIC) { - return ntvfs_map_qfileinfo(req, info, private->ops); + return ntvfs_map_qfileinfo(req, info, ntvfs); } f = find_fd(private, info->generic.in.fnum); @@ -289,16 +295,17 @@ static NTSTATUS svfs_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *i return map_nt_error_from_unix(errno); } - return svfs_map_fileinfo(req, info, &st, f->name); + return svfs_map_fileinfo(ntvfs, req,info, &st, f->name); } /* open a file */ -static NTSTATUS svfs_open(struct smbsrv_request *req, union smb_open *io) +static NTSTATUS svfs_open(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_open *io) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; char *unix_path; struct stat st; int fd, flags; @@ -306,7 +313,7 @@ static NTSTATUS svfs_open(struct smbsrv_request *req, union smb_open *io) int create_flags, rdwr_flags; if (io->generic.level != RAW_OPEN_GENERIC) { - return ntvfs_map_open(req, io, private->ops); + return ntvfs_map_open(req, io, ntvfs); } if (lp_readonly(req->tcon->service)) { @@ -317,7 +324,7 @@ static NTSTATUS svfs_open(struct smbsrv_request *req, union smb_open *io) rdwr_flags = O_RDWR; } - unix_path = svfs_unix_path(req, io->ntcreatex.in.fname); + unix_path = svfs_unix_path(ntvfs, req, io->ntcreatex.in.fname); switch (io->generic.in.open_disposition) { case NTCREATEX_DISP_SUPERSEDE: @@ -402,7 +409,8 @@ do_open: /* create a directory */ -static NTSTATUS svfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) +static NTSTATUS svfs_mkdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_mkdir *md) { char *unix_path; @@ -412,7 +420,7 @@ static NTSTATUS svfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) return NT_STATUS_INVALID_LEVEL; } - unix_path = svfs_unix_path(req, md->mkdir.in.path); + unix_path = svfs_unix_path(ntvfs, req, md->mkdir.in.path); if (mkdir(unix_path, 0777) == -1) { return map_nt_error_from_unix(errno); @@ -424,13 +432,14 @@ static NTSTATUS svfs_mkdir(struct smbsrv_request *req, union smb_mkdir *md) /* remove a directory */ -static NTSTATUS svfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) +static NTSTATUS svfs_rmdir(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_rmdir *rd) { char *unix_path; CHECK_READ_ONLY(req); - unix_path = svfs_unix_path(req, rd->in.path); + unix_path = svfs_unix_path(ntvfs, req, rd->in.path); if (rmdir(unix_path) == -1) { return map_nt_error_from_unix(errno); @@ -442,7 +451,8 @@ static NTSTATUS svfs_rmdir(struct smbsrv_request *req, struct smb_rmdir *rd) /* rename a set of files */ -static NTSTATUS svfs_rename(struct smbsrv_request *req, union smb_rename *ren) +static NTSTATUS svfs_rename(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_rename *ren) { char *unix_path1, *unix_path2; @@ -452,8 +462,8 @@ static NTSTATUS svfs_rename(struct smbsrv_request *req, union smb_rename *ren) return NT_STATUS_INVALID_LEVEL; } - unix_path1 = svfs_unix_path(req, ren->rename.in.pattern1); - unix_path2 = svfs_unix_path(req, ren->rename.in.pattern2); + unix_path1 = svfs_unix_path(ntvfs, req, ren->rename.in.pattern1); + unix_path2 = svfs_unix_path(ntvfs, req, ren->rename.in.pattern2); if (rename(unix_path1, unix_path2) != 0) { return map_nt_error_from_unix(errno); @@ -465,7 +475,8 @@ static NTSTATUS svfs_rename(struct smbsrv_request *req, union smb_rename *ren) /* copy a set of files */ -static NTSTATUS svfs_copy(struct smbsrv_request *req, struct smb_copy *cp) +static NTSTATUS svfs_copy(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_copy *cp) { return NT_STATUS_NOT_SUPPORTED; } @@ -473,7 +484,8 @@ static NTSTATUS svfs_copy(struct smbsrv_request *req, struct smb_copy *cp) /* read from a file */ -static NTSTATUS svfs_read(struct smbsrv_request *req, union smb_read *rd) +static NTSTATUS svfs_read(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_read *rd) { ssize_t ret; @@ -499,7 +511,8 @@ static NTSTATUS svfs_read(struct smbsrv_request *req, union smb_read *rd) /* write to a file */ -static NTSTATUS svfs_write(struct smbsrv_request *req, union smb_write *wr) +static NTSTATUS svfs_write(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_write *wr) { ssize_t ret; @@ -545,7 +558,8 @@ static NTSTATUS svfs_write(struct smbsrv_request *req, union smb_write *wr) /* seek in a file */ -static NTSTATUS svfs_seek(struct smbsrv_request *req, struct smb_seek *io) +static NTSTATUS svfs_seek(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_seek *io) { return NT_STATUS_NOT_SUPPORTED; } @@ -553,7 +567,8 @@ static NTSTATUS svfs_seek(struct smbsrv_request *req, struct smb_seek *io) /* flush a file */ -static NTSTATUS svfs_flush(struct smbsrv_request *req, struct smb_flush *io) +static NTSTATUS svfs_flush(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_flush *io) { fsync(io->in.fnum); return NT_STATUS_OK; @@ -562,9 +577,10 @@ static NTSTATUS svfs_flush(struct smbsrv_request *req, struct smb_flush *io) /* close a file */ -static NTSTATUS svfs_close(struct smbsrv_request *req, union smb_close *io) +static NTSTATUS svfs_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_close *io) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct svfs_file *f; if (io->generic.level != RAW_CLOSE_CLOSE) { @@ -591,7 +607,8 @@ static NTSTATUS svfs_close(struct smbsrv_request *req, union smb_close *io) /* exit - closing files */ -static NTSTATUS svfs_exit(struct smbsrv_request *req) +static NTSTATUS svfs_exit(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { return NT_STATUS_NOT_SUPPORTED; } @@ -599,7 +616,8 @@ static NTSTATUS svfs_exit(struct smbsrv_request *req) /* logoff - closing files */ -static NTSTATUS svfs_logoff(struct smbsrv_request *req) +static NTSTATUS svfs_logoff(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req) { return NT_STATUS_NOT_SUPPORTED; } @@ -607,7 +625,8 @@ static NTSTATUS svfs_logoff(struct smbsrv_request *req) /* lock a byte range */ -static NTSTATUS svfs_lock(struct smbsrv_request *req, union smb_lock *lck) +static NTSTATUS svfs_lock(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lock *lck) { DEBUG(0,("REWRITE: not doing byte range locking!\n")); return NT_STATUS_OK; @@ -616,7 +635,8 @@ static NTSTATUS svfs_lock(struct smbsrv_request *req, union smb_lock *lck) /* set info on a pathname */ -static NTSTATUS svfs_setpathinfo(struct smbsrv_request *req, union smb_setfileinfo *st) +static NTSTATUS svfs_setpathinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *st) { CHECK_READ_ONLY(req); @@ -626,7 +646,8 @@ static NTSTATUS svfs_setpathinfo(struct smbsrv_request *req, union smb_setfilein /* set info on a open file */ -static NTSTATUS svfs_setfileinfo(struct smbsrv_request *req, +static NTSTATUS svfs_setfileinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_setfileinfo *info) { struct utimbuf unix_times; @@ -669,13 +690,14 @@ static NTSTATUS svfs_setfileinfo(struct smbsrv_request *req, /* return filesystem space info */ -static NTSTATUS svfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) +static NTSTATUS svfs_fsinfo(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsinfo *fs) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct stat st; if (fs->generic.level != RAW_QFS_GENERIC) { - return ntvfs_map_fsinfo(req, fs, private->ops); + return ntvfs_map_fsinfo(req, fs, ntvfs); } if (sys_fsusage(private->connectpath, @@ -710,13 +732,14 @@ static NTSTATUS svfs_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs) /* return filesystem attribute info */ -static NTSTATUS svfs_fsattr(struct smbsrv_request *req, union smb_fsattr *fs) +static NTSTATUS svfs_fsattr(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_fsattr *fs) { struct stat st; - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; if (fs->generic.level != RAW_FSATTR_GENERIC) { - return ntvfs_map_fsattr(req, fs); + return ntvfs_map_fsattr(req, fs, ntvfs); } if (stat(private->connectpath, &st) != 0) { @@ -741,7 +764,8 @@ static NTSTATUS svfs_fsattr(struct smbsrv_request *req, union smb_fsattr *fs) /* return print queue info */ -static NTSTATUS svfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) +static NTSTATUS svfs_lpq(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_lpq *lpq) { return NT_STATUS_NOT_SUPPORTED; } @@ -749,13 +773,14 @@ static NTSTATUS svfs_lpq(struct smbsrv_request *req, union smb_lpq *lpq) /* list files in a directory matching a wildcard pattern */ -static NTSTATUS svfs_search_first(struct smbsrv_request *req, union smb_search_first *io, +static NTSTATUS svfs_search_first(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_first *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { struct svfs_dir *dir; int i; - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct search_state *search; union smb_search_data file; uint_t max_count; @@ -771,7 +796,7 @@ static NTSTATUS svfs_search_first(struct smbsrv_request *req, union smb_search_f max_count = io->t2ffirst.in.max_count; - dir = svfs_list(private, req, io->t2ffirst.in.pattern); + dir = svfs_list(ntvfs, req, io->t2ffirst.in.pattern); if (!dir) { return NT_STATUS_FOOBAR; } @@ -818,13 +843,14 @@ static NTSTATUS svfs_search_first(struct smbsrv_request *req, union smb_search_f } /* continue a search */ -static NTSTATUS svfs_search_next(struct smbsrv_request *req, union smb_search_next *io, +static NTSTATUS svfs_search_next(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_next *io, void *search_private, BOOL (*callback)(void *, union smb_search_data *)) { struct svfs_dir *dir; int i; - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct search_state *search; union smb_search_data file; uint_t max_count; @@ -905,9 +931,10 @@ found: } /* close a search */ -static NTSTATUS svfs_search_close(struct smbsrv_request *req, union smb_search_close *io) +static NTSTATUS svfs_search_close(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, union smb_search_close *io) { - NTVFS_GET_PRIVATE(svfs_private, private, req); + struct svfs_private *private = ntvfs->private_data; struct search_state *search; for (search=private->search; search; search = search->next) { @@ -926,7 +953,8 @@ static NTSTATUS svfs_search_close(struct smbsrv_request *req, union smb_search_c } /* SMBtrans - not used on file shares */ -static NTSTATUS svfs_trans(struct smbsrv_request *req, struct smb_trans2 *trans2) +static NTSTATUS svfs_trans(struct ntvfs_module_context *ntvfs, + struct smbsrv_request *req, struct smb_trans2 *trans2) { return NT_STATUS_ACCESS_DENIED; } diff --git a/source4/smb_server/nttrans.c b/source4/smb_server/nttrans.c index 683e9e3386..0150eff0fa 100644 --- a/source4/smb_server/nttrans.c +++ b/source4/smb_server/nttrans.c @@ -94,7 +94,7 @@ static NTSTATUS nttrans_ioctl(struct smbsrv_request *req, nttrans_setup_reply(req, trans, 0, 0, 1); trans->out.setup[0] = 0; - return req->tcon->ntvfs_ops->ioctl(req, &nt); + return ntvfs_ioctl(req, &nt); } /* diff --git a/source4/smb_server/reply.c b/source4/smb_server/reply.c index 94317bfc39..2a5a7064bd 100644 --- a/source4/smb_server/reply.c +++ b/source4/smb_server/reply.c @@ -240,7 +240,7 @@ void reply_ioctl(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->ioctl(req, io); + req->async.status = ntvfs_ioctl(req, io); REQ_ASYNC_TAIL; } @@ -259,7 +259,7 @@ void reply_chkpth(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; - req->async.status = req->tcon->ntvfs_ops->chkpath(req, io); + req->async.status = ntvfs_chkpath(req, io); REQ_ASYNC_TAIL; } @@ -308,7 +308,7 @@ void reply_getatr(struct smbsrv_request *req) req->async.private = st; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->qpathinfo(req, st); + req->async.status = ntvfs_qpathinfo(req, st); REQ_ASYNC_TAIL; } @@ -339,7 +339,7 @@ void reply_setatr(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->setpathinfo(req, st); + req->async.status = ntvfs_setpathinfo(req, st); REQ_ASYNC_TAIL; } @@ -383,7 +383,7 @@ void reply_dskattr(struct smbsrv_request *req) req->async.private = fs; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->fsinfo(req, fs); + req->async.status = ntvfs_fsinfo(req, fs); REQ_ASYNC_TAIL; } @@ -437,7 +437,7 @@ void reply_open(struct smbsrv_request *req) req->async.private = oi; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, oi); + req->async.status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -512,7 +512,7 @@ void reply_open_and_X(struct smbsrv_request *req) req->async.private = oi; /* call the backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, oi); + req->async.status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -562,7 +562,7 @@ void reply_mknew(struct smbsrv_request *req) req->async.private = oi; /* call the backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, oi); + req->async.status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -615,7 +615,7 @@ void reply_ctemp(struct smbsrv_request *req) req->async.private = oi; /* call the backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, oi); + req->async.status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -639,7 +639,7 @@ void reply_unlink(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->unlink(req, unl); + req->async.status = ntvfs_unlink(req, unl); REQ_ASYNC_TAIL; } @@ -688,7 +688,7 @@ void reply_readbraw(struct smbsrv_request *req) io.readbraw.out.data = req->out.buffer + NBT_HDR_SIZE; /* call the backend */ - status = req->tcon->ntvfs_ops->read(req, &io); + status = ntvfs_read(req, &io); if (!NT_STATUS_IS_OK(status)) { goto failed; @@ -762,7 +762,7 @@ void reply_lockread(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->read(req, io); + req->async.status = ntvfs_read(req, io); REQ_ASYNC_TAIL; } @@ -820,7 +820,7 @@ void reply_read(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->read(req, io); + req->async.status = ntvfs_read(req, io); REQ_ASYNC_TAIL; } @@ -891,7 +891,7 @@ void reply_read_and_X(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->read(req, io); + req->async.status = ntvfs_read(req, io); REQ_ASYNC_TAIL; } @@ -957,7 +957,7 @@ void reply_writeunlock(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->write(req, io); + req->async.status = ntvfs_write(req, io); REQ_ASYNC_TAIL; } @@ -1014,7 +1014,7 @@ void reply_write(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->write(req, io); + req->async.status = ntvfs_write(req, io); REQ_ASYNC_TAIL; } @@ -1080,7 +1080,7 @@ void reply_write_and_X(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->write(req, io); + req->async.status = ntvfs_write(req, io); REQ_ASYNC_TAIL; } @@ -1121,7 +1121,7 @@ void reply_lseek(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->seek(req, io); + req->async.status = ntvfs_seek(req, io); REQ_ASYNC_TAIL; } @@ -1142,7 +1142,7 @@ void reply_flush(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->flush(req, io); + req->async.status = ntvfs_flush(req, io); REQ_ASYNC_TAIL; } @@ -1159,7 +1159,7 @@ void reply_exit(struct smbsrv_request *req) for (tcon=req->smb_conn->tree.tcons;tcon;tcon=tcon->next) { req->tcon = tcon; - status = tcon->ntvfs_ops->exit(req); + status = ntvfs_exit(req); req->tcon = NULL; if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -1192,7 +1192,7 @@ void reply_close(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->close(req, io); + req->async.status = ntvfs_close(req, io); REQ_ASYNC_TAIL; } @@ -1247,7 +1247,7 @@ void reply_writeclose(struct smbsrv_request *req) req->async.private = io; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->write(req, io); + req->async.status = ntvfs_write(req, io); REQ_ASYNC_TAIL; } @@ -1271,7 +1271,7 @@ void reply_lock(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->lock(req, lck); + req->async.status = ntvfs_lock(req, lck); REQ_ASYNC_TAIL; } @@ -1296,7 +1296,7 @@ void reply_unlock(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->lock(req, lck); + req->async.status = ntvfs_lock(req, lck); REQ_ASYNC_TAIL; } @@ -1385,7 +1385,7 @@ void reply_printopen(struct smbsrv_request *req) req->async.private = oi; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, oi); + req->async.status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -1407,7 +1407,7 @@ void reply_printclose(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->close(req, io); + req->async.status = ntvfs_close(req, io); REQ_ASYNC_TAIL; } @@ -1476,7 +1476,7 @@ void reply_printqueue(struct smbsrv_request *req) req->async.private = lpq; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->lpq(req, lpq); + req->async.status = ntvfs_lpq(req, lpq); REQ_ASYNC_TAIL; } @@ -1513,7 +1513,7 @@ void reply_printwrite(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->write(req, io); + req->async.status = ntvfs_write(req, io); REQ_ASYNC_TAIL; } @@ -1536,7 +1536,7 @@ void reply_mkdir(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->mkdir(req, io); + req->async.status = ntvfs_mkdir(req, io); REQ_ASYNC_TAIL; } @@ -1558,7 +1558,7 @@ void reply_rmdir(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->rmdir(req, io); + req->async.status = ntvfs_rmdir(req, io); REQ_ASYNC_TAIL; } @@ -1591,7 +1591,7 @@ void reply_mv(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->rename(req, io); + req->async.status = ntvfs_rename(req, io); REQ_ASYNC_TAIL; } @@ -1626,7 +1626,7 @@ void reply_ntrename(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->rename(req, io); + req->async.status = ntvfs_rename(req, io); REQ_ASYNC_TAIL; } @@ -1677,7 +1677,7 @@ void reply_copy(struct smbsrv_request *req) req->async.private = cp; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->copy(req, cp); + req->async.status = ntvfs_copy(req, cp); REQ_ASYNC_TAIL; } @@ -1777,7 +1777,7 @@ void reply_lockingX(struct smbsrv_request *req) req->async.private = lck; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->lock(req, lck); + req->async.status = ntvfs_lock(req, lck); REQ_ASYNC_TAIL; } @@ -1812,7 +1812,7 @@ void reply_setattrE(struct smbsrv_request *req) req->async.send_fn = reply_simple_send; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->setfileinfo(req, info); + req->async.status = ntvfs_setfileinfo(req, info); REQ_ASYNC_TAIL; } @@ -1879,7 +1879,7 @@ void reply_getattrE(struct smbsrv_request *req) req->async.private = info; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->qfileinfo(req, info); + req->async.status = ntvfs_qfileinfo(req, info); REQ_ASYNC_TAIL; } @@ -2116,7 +2116,7 @@ void reply_ulogoffX(struct smbsrv_request *req) if ((vuid != 0) && (lp_security() != SEC_SHARE)) { for (tcon=req->smb_conn->tree.tcons;tcon;tcon=tcon->next) { req->tcon = tcon; - status = tcon->ntvfs_ops->logoff(req); + status = ntvfs_logoff(req); req->tcon = NULL; if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -2152,7 +2152,7 @@ void reply_findclose(struct smbsrv_request *req) io.findclose.in.handle = SVAL(req->in.vwv, VWV(0)); /* call backend */ - status = req->tcon->ntvfs_ops->search_close(req, &io); + status = ntvfs_search_close(req, &io); if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -2250,7 +2250,7 @@ void reply_ntcreate_and_X(struct smbsrv_request *req) req->async.private = io; /* call the backend */ - req->async.status = req->tcon->ntvfs_ops->open(req, io); + req->async.status = ntvfs_open(req, io); REQ_ASYNC_TAIL; } diff --git a/source4/smb_server/search.c b/source4/smb_server/search.c index acd1b6d417..6a8653c749 100644 --- a/source4/smb_server/search.c +++ b/source4/smb_server/search.c @@ -174,7 +174,7 @@ void reply_search(struct smbsrv_request *req) sn->search_next.in.search_attrib = SVAL(req->in.vwv, VWV(1)); /* call backend */ - status = req->tcon->ntvfs_ops->search_next(req, sn, &state, find_callback); + status = ntvfs_search_next(req, sn, &state, find_callback); SSVAL(req->out.vwv, VWV(0), sn->search_next.out.count); } else { /* do a search first operation */ @@ -183,7 +183,7 @@ void reply_search(struct smbsrv_request *req) sf->search_first.in.max_count = SVAL(req->in.vwv, VWV(0)); /* call backend */ - status = req->tcon->ntvfs_ops->search_first(req, sf, &state, find_callback); + status = ntvfs_search_first(req, sf, &state, find_callback); SSVAL(req->out.vwv, VWV(0), sf->search_first.out.count); } @@ -272,7 +272,7 @@ void reply_fclose(struct smbsrv_request *req) req->async.private = sc; /* call backend */ - req->async.status = req->tcon->ntvfs_ops->search_close(req, sc); + req->async.status = ntvfs_search_close(req, sc); REQ_ASYNC_TAIL; } diff --git a/source4/smb_server/service.c b/source4/smb_server/service.c index 5f698fe20b..8519869e6b 100644 --- a/source4/smb_server/service.c +++ b/source4/smb_server/service.c @@ -158,7 +158,6 @@ static NTSTATUS make_connection_snum(struct smbsrv_request *req, req->tcon = tcon; tcon->service = snum; - tcon->type = type; /* * New code to check if there's a share security descripter @@ -180,7 +179,7 @@ static NTSTATUS make_connection_snum(struct smbsrv_request *req, } /* init ntvfs function pointers */ - status = ntvfs_init_connection(req); + status = ntvfs_init_connection(req, type); if (!NT_STATUS_IS_OK(status)) { DEBUG(0, ("ntvfs_init_connection failed for service %s\n", lp_servicename(SNUM(tcon)))); conn_free(req->smb_conn, tcon); @@ -188,13 +187,11 @@ static NTSTATUS make_connection_snum(struct smbsrv_request *req, } /* Invoke NTVFS connection hook */ - if (tcon->ntvfs_ops->connect) { - status = tcon->ntvfs_ops->connect(req, lp_servicename(snum), 0); - if (!NT_STATUS_IS_OK(status)) { - DEBUG(0,("make_connection: NTVFS make connection failed!\n")); - conn_free(req->smb_conn, tcon); - return status; - } + status = ntvfs_connect(req, lp_servicename(snum)); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0,("make_connection: NTVFS make connection failed!\n")); + conn_free(req->smb_conn, tcon); + return status; } return NT_STATUS_OK; @@ -259,7 +256,7 @@ void close_cnum(struct smbsrv_tcon *tcon) lp_servicename(SNUM(tcon)))); /* tell the ntvfs backend that we are disconnecting */ - tcon->ntvfs_ops->disconnect(tcon, 0); + ntvfs_disconnect(tcon); conn_free(tcon->smb_conn, tcon); } diff --git a/source4/smb_server/smb_server.c b/source4/smb_server/smb_server.c index 883be01b41..28ca4d880a 100644 --- a/source4/smb_server/smb_server.c +++ b/source4/smb_server/smb_server.c @@ -512,7 +512,7 @@ static void switch_message(int type, struct smbsrv_request *req) } /* ipc services are limited */ - if (req->tcon && req->tcon->type == NTVFS_IPC && (flags & AS_USER) && !(flags & CAN_IPC)) { + if (req->tcon && req->tcon->ntvfs_ctx->type == NTVFS_IPC && (flags & AS_USER) && !(flags & CAN_IPC)) { req_reply_error(req, NT_STATUS_ACCESS_DENIED); return; } diff --git a/source4/smb_server/smb_server.h b/source4/smb_server/smb_server.h index 1f7df36a9b..c40633eb06 100644 --- a/source4/smb_server/smb_server.h +++ b/source4/smb_server/smb_server.h @@ -46,15 +46,9 @@ struct smbsrv_session { struct auth_session_info *session_info; }; - -/* each backend has to be one one of the following 3 basic types. In - * earlier versions of Samba backends needed to handle all types, now - * we implement them separately. */ -enum ntvfs_type {NTVFS_DISK, NTVFS_PRINT, NTVFS_IPC}; - /* we need a forward declaration of the ntvfs_ops strucutre to prevent include recursion */ -struct ntvfs_ops; +struct ntvfs_context; struct smbsrv_tcon { struct smbsrv_tcon *next, *prev; @@ -62,17 +56,13 @@ struct smbsrv_tcon { /* the server context that this was created on */ struct smbsrv_connection *smb_conn; - /* an array of private structures used by the active NTVFS backends */ - void **ntvfs_private_list; - uint16_t cnum; /* an index passed over the wire (the TID) */ int service; - enum ntvfs_type type; BOOL read_only; BOOL admin_user; - /* the NTVFS operations - see source/ntvfs/ and include/ntvfs.h for details */ - const struct ntvfs_ops *ntvfs_ops; + /* the NTVFS context - see source/ntvfs/ for details */ + struct ntvfs_context *ntvfs_ctx; /* the reported filesystem type */ char *fs_type; @@ -93,9 +83,6 @@ struct smbsrv_request { /* the session context is derived from the vuid */ struct smbsrv_session *session; - /* the ntvfs chaining depth */ - int ntvfs_depth; - /* a set of flags to control usage of the request. See REQ_CONTROL_* */ unsigned control_flags; diff --git a/source4/smb_server/trans2.c b/source4/smb_server/trans2.c index 34e79061df..b8b3035286 100644 --- a/source4/smb_server/trans2.c +++ b/source4/smb_server/trans2.c @@ -215,7 +215,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_ALLOCATION: fsinfo.allocation.level = RAW_QFS_ALLOCATION; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -233,7 +233,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_VOLUME: fsinfo.volume.level = RAW_QFS_VOLUME; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -253,7 +253,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_VOLUME_INFORMATION: fsinfo.volume_info.level = RAW_QFS_VOLUME_INFO; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -273,7 +273,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_SIZE_INFORMATION: fsinfo.size_info.level = RAW_QFS_SIZE_INFO; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -291,7 +291,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_DEVICE_INFORMATION: fsinfo.device_info.level = RAW_QFS_DEVICE_INFO; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -305,7 +305,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_ATTRIBUTE_INFORMATION: fsinfo.attribute_info.level = RAW_QFS_ATTRIBUTE_INFO; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -326,7 +326,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_QUOTA_INFORMATION: fsinfo.quota_information.level = RAW_QFS_QUOTA_INFORMATION; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -346,7 +346,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_FULL_SIZE_INFORMATION: fsinfo.full_size_information.level = RAW_QFS_FULL_SIZE_INFORMATION; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -364,7 +364,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr case SMB_QFS_OBJECTID_INFORMATION: fsinfo.objectid_information.level = RAW_QFS_OBJECTID_INFORMATION; - status = req->tcon->ntvfs_ops->fsinfo(req, &fsinfo); + status = ntvfs_fsinfo(req, &fsinfo); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -641,7 +641,7 @@ static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct smb_trans2 * } /* call the backend */ - status = req->tcon->ntvfs_ops->qpathinfo(req, &st); + status = ntvfs_qpathinfo(req, &st); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -677,7 +677,7 @@ static NTSTATUS trans2_qfileinfo(struct smbsrv_request *req, struct smb_trans2 * } /* call the backend */ - status = req->tcon->ntvfs_ops->qfileinfo(req, &st); + status = ntvfs_qfileinfo(req, &st); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -813,7 +813,7 @@ static NTSTATUS trans2_setfileinfo(struct smbsrv_request *req, struct smb_trans2 return status; } - status = req->tcon->ntvfs_ops->setfileinfo(req, &st); + status = ntvfs_setfileinfo(req, &st); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -852,7 +852,7 @@ static NTSTATUS trans2_setpathinfo(struct smbsrv_request *req, struct smb_trans2 return status; } - status = req->tcon->ntvfs_ops->setpathinfo(req, &st); + status = ntvfs_setpathinfo(req, &st); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -1114,7 +1114,7 @@ static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct smb_trans2 * trans2_setup_reply(req, trans, 10, 0, 0); /* call the backend */ - status = req->tcon->ntvfs_ops->search_first(req, &search, &state, find_callback); + status = ntvfs_search_first(req, &search, &state, find_callback); if (!NT_STATUS_IS_OK(status)) { trans2_setup_reply(req, trans, 0, 0, 0); return status; @@ -1175,7 +1175,7 @@ static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct smb_trans2 *t trans2_setup_reply(req, trans, 8, 0, 0); /* call the backend */ - status = req->tcon->ntvfs_ops->search_next(req, &search, &state, find_callback); + status = ntvfs_search_next(req, &search, &state, find_callback); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -1196,9 +1196,12 @@ static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct smb_trans2 *t */ static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *trans) { - if (req->tcon->ntvfs_ops->trans2 != NULL) { - /* direct trans2 pass thru */ - return req->tcon->ntvfs_ops->trans2(req, trans); + NTSTATUS status; + + /* direct trans2 pass thru */ + status = ntvfs_trans2(req, trans); + if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) { + return status; } /* must have at least one setup word */ @@ -1228,19 +1231,6 @@ static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *tr return NT_STATUS_FOOBAR; } - -/* - backend for trans requests -*/ -static NTSTATUS trans_backend(struct smbsrv_request *req, struct smb_trans2 *trans) -{ - if (!req->tcon->ntvfs_ops->trans) { - return NT_STATUS_NOT_IMPLEMENTED; - } - return req->tcon->ntvfs_ops->trans(req, trans); -} - - /**************************************************************************** Reply to an SMBtrans or SMBtrans2 request ****************************************************************************/ @@ -1308,7 +1298,7 @@ void reply_trans_generic(struct smbsrv_request *req, uint8_t command) /* its a full request, give it to the backend */ if (command == SMBtrans) { - status = trans_backend(req, &trans); + status = ntvfs_trans(req, &trans); } else { status = trans2_backend(req, &trans); } -- cgit