*/
#include "includes.h"
+#include "events.h"
+#include "libcli/raw/libcliraw.h"
+#include "smb_server/smb_server.h"
/* this is stored in ntvfs_private */
struct cvfs_private {
struct smbcli_tree *tree;
struct smbcli_transport *transport;
struct smbsrv_tcon *tcon;
- const char *map_calls;
+ BOOL map_generic;
};
void *parms;
};
+#define SETUP_PID private->tree->session->pid = SVAL(req->in.hdr, HDR_PID)
+
/*
an idle function to cope with messages from the smbd client while
waiting for a reply from the server
static void idle_func(struct smbcli_transport *transport, void *p_private)
{
struct cvfs_private *private = p_private;
- if (socket_pending(private->tcon->smb_conn->connection->socket->fde->fd)) {
+ int fd = socket_get_fd(private->tcon->smb_conn->connection->socket);
+
+ if (socket_pending(fd)) {
smbd_process_async(private->tcon->smb_conn);
}
}
/*
a handler for read events on a connection to a backend server
*/
-static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde, time_t t, uint16_t flags)
+static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde,
+ struct timeval t, uint16_t flags)
{
struct cvfs_private *private = fde->private;
struct smbsrv_tcon *tcon = private->tcon;
if (!smbcli_transport_process(private->transport)) {
/* the connection to our server is dead */
- close_cnum(tcon);
+ talloc_free(tcon);
}
}
/*
connect to a share - used when a tree_connect operation comes in.
*/
-static NTSTATUS cvfs_connect(struct smbsrv_request *req, const char *sharename)
+static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs,
+ struct smbsrv_request *req, const char *sharename)
{
struct smbsrv_tcon *tcon = req->tcon;
NTSTATUS status;
struct cvfs_private *private;
- const char *map_calls;
const char *host, *user, *pass, *domain, *remote_share;
/* Here we need to determine which server to connect to.
return NT_STATUS_INVALID_PARAMETER;
}
- private = talloc(req->tcon, sizeof(struct cvfs_private));
+ private = talloc_p(req->tcon, struct cvfs_private);
if (!private) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCTP(private);
- req->tcon->ntvfs_private = (void *)private;
+ ntvfs->private_data = private;
- status = smbcli_tree_full_connection(&private->tree,
- "vfs_cifs",
- host,
- 0,
- remote_share, "?????",
- user, domain,
- pass);
+ status = smbcli_tree_full_connection(private,
+ &private->tree,
+ "vfs_cifs",
+ host,
+ 0,
+ remote_share, "?????",
+ user, domain,
+ pass);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
private->transport = private->tree->session->transport;
- private->tree->session->pid = SVAL(req->in.hdr, HDR_PID);
+ SETUP_PID;
private->tcon = req->tcon;
tcon->fs_type = talloc_strdup(tcon, "NTFS");
tcon->dev_type = talloc_strdup(tcon, "A:");
- map_calls = lp_parm_string(req->tcon->service, "cifs", "map calls");
- if (map_calls) {
- private->map_calls = talloc_strdup(tcon, map_calls);
- }
-
- /* if we are mapping trans2, then we need to give a trans2
- pointer in the operations structure */
- if (private->map_calls && in_list("trans2", private->map_calls, True)) {
- struct ntvfs_ops *ops = talloc_memdup(tcon, tcon->ntvfs_ops,sizeof(*ops));
- static NTSTATUS cvfs_trans2(struct smbsrv_request *,struct smb_trans2 *);
- if (!ops) {
- return NT_STATUS_NO_MEMORY;
- }
- ops->trans2 = cvfs_trans2;
- tcon->ntvfs_ops = ops;
- }
-
/* we need to receive oplock break requests from the server */
smbcli_oplock_handler(private->transport, oplock_handler, private);
- smbcli_transport_idle_handler(private->transport, idle_func, 1, private);
+ smbcli_transport_idle_handler(private->transport, idle_func, 50000, private);
- private->transport->event.fde->handler = cifs_socket_handler;
- private->transport->event.fde->private = private;
+ private->transport->socket->event.fde->handler = cifs_socket_handler;
+ private->transport->socket->event.fde->private = private;
- private->transport->event.ctx = event_context_merge(tcon->smb_conn->connection->event.ctx,
- private->transport->event.ctx);
+ private->transport->socket->event.ctx = event_context_merge(tcon->smb_conn->connection->event.ctx,
+ private->transport->socket->event.ctx);
+ talloc_reference(private, private->transport->socket->event.ctx);
+ private->map_generic = lp_parm_bool(req->tcon->service,
+ "cifs", "mapgeneric", False);
return NT_STATUS_OK;
}
/*
disconnect from a share
*/
-static NTSTATUS cvfs_disconnect(struct smbsrv_tcon *tcon)
+static NTSTATUS cvfs_disconnect(struct ntvfs_module_context *ntvfs,
+ struct smbsrv_tcon *tcon)
{
- struct cvfs_private *private = tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
- smb_tree_disconnect(private->tree);
- smbcli_tree_close(private->tree);
+ talloc_free(private);
return NT_STATUS_OK;
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smbcli_request_simple_recv(c_req);
- req->async.send_fn(req);
+ req->async_states->status = smbcli_request_simple_recv(c_req);
+ req->async_states->send_fn(req);
}
c_req->async.private = async; \
} \
c_req->async.fn = async_fn; \
- req->control_flags |= REQ_CONTROL_ASYNC; \
+ req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC; \
return NT_STATUS_OK; \
} while (0)
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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
+ SETUP_PID;
+
/* see if the front end will allow us to perform this
function asynchronously. */
- if (!req->async.send_fn) {
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_unlink(private->tree, unl);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_ioctl_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_ioctl_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
+ SETUP_PID;
+
/* see if the front end will allow us to perform this
function asynchronously. */
- if (!req->async.send_fn) {
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_ioctl(private->tree, req, 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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_chkpath(private->tree, cp);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_pathinfo_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_pathinfo_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_pathinfo(private->tree, req, info);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_fileinfo_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_fileinfo_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_fileinfo(private->tree, req, info);
}
/*
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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_setpathinfo(private->tree, st);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_open_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_open_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (private->map_calls && in_list("open", private->map_calls, True) &&
- io->generic.level != RAW_OPEN_GENERIC) {
- return ntvfs_map_open(req, io);
+ SETUP_PID;
+
+ if (io->generic.level != RAW_OPEN_GENERIC &&
+ private->map_generic) {
+ return ntvfs_map_open(req, io, ntvfs);
}
- if (!req->async.send_fn) {
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_open(private->tree, req, 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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_mkdir(private->tree, 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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_rmdir(private->tree, rd);
}
c_req = smb_raw_rmdir_send(private->tree, 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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_rename(private->tree, 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;
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_read_recv(c_req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_read_recv(c_req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (rd->generic.level != RAW_READ_GENERIC &&
+ private->map_generic) {
+ return ntvfs_map_read(req, rd, ntvfs);
+ }
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_read(private->tree, rd);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_write_recv(c_req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_write_recv(c_req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (wr->generic.level != RAW_WRITE_GENERIC &&
+ private->map_generic) {
+ return ntvfs_map_write(req, wr, ntvfs);
+ }
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_write(private->tree, 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;
+ struct cvfs_private *private = ntvfs->private_data;
+ struct smbcli_request *c_req;
+
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
+ return smb_raw_seek(private->tree, io);
+ }
+
+ c_req = smb_raw_seek_send(private->tree, io);
+
+ SIMPLE_ASYNC_TAIL;
}
/*
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;
+ struct cvfs_private *private = ntvfs->private_data;
+ struct smbcli_request *c_req;
+
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
+ return smb_raw_flush(private->tree, io);
+ }
+
+ c_req = smb_raw_flush_send(private->tree, io);
+
+ SIMPLE_ASYNC_TAIL;
}
/*
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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (io->generic.level != RAW_CLOSE_GENERIC &&
+ private->map_generic) {
+ return ntvfs_map_close(req, io, ntvfs);
+ }
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_close(private->tree, io);
}
}
/*
- exit - closing files?
+ 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)
{
- return NT_STATUS_NOT_SUPPORTED;
+ struct cvfs_private *private = ntvfs->private_data;
+ struct smbcli_request *c_req;
+
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
+ return smb_raw_exit(private->tree->session);
+ }
+
+ c_req = smb_raw_exit_send(private->tree->session);
+
+ SIMPLE_ASYNC_TAIL;
+}
+
+/*
+ logoff - closing files open by the user
+*/
+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;
+}
+
+/*
+ setup for an async call - nothing to do yet
+*/
+static NTSTATUS cvfs_async_setup(struct ntvfs_module_context *ntvfs,
+ struct smbsrv_request *req,
+ void *private)
+{
+ return NT_STATUS_OK;
+}
+
+/*
+ cancel an async call
+*/
+static NTSTATUS cvfs_cancel(struct ntvfs_module_context *ntvfs,
+ struct smbsrv_request *req)
+{
+ return NT_STATUS_NOT_IMPLEMENTED;
}
/*
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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (lck->generic.level != RAW_LOCK_GENERIC &&
+ private->map_generic) {
+ return ntvfs_map_lock(req, lck, ntvfs);
+ }
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_lock(private->tree, 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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_setfileinfo(private->tree, info);
}
c_req = smb_raw_setfileinfo_send(private->tree, info);
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_fsinfo_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_fsinfo_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_fsinfo(private->tree, req, 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;
}
/*
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 *))
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
+
+ SETUP_PID;
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 *))
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
+
+ SETUP_PID;
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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
+
+ SETUP_PID;
return smb_raw_search_close(private->tree, io);
}
{
struct async_info *async = c_req->async.private;
struct smbsrv_request *req = async->req;
- req->async.status = smb_raw_trans2_recv(c_req, req, async->parms);
- req->async.send_fn(req);
+ req->async_states->status = smb_raw_trans2_recv(c_req, req, async->parms);
+ req->async_states->send_fn(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)
{
- struct cvfs_private *private = req->tcon->ntvfs_private;
+ struct cvfs_private *private = ntvfs->private_data;
struct smbcli_request *c_req;
- if (!req->async.send_fn) {
+ SETUP_PID;
+
+ if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
return smb_raw_trans2(private->tree, req, trans2);
}
/* 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;
}
ops.chkpath = cvfs_chkpath;
ops.qpathinfo = cvfs_qpathinfo;
ops.setpathinfo = cvfs_setpathinfo;
- ops.open = cvfs_open;
+ ops.openfile = cvfs_open;
ops.mkdir = cvfs_mkdir;
ops.rmdir = cvfs_rmdir;
ops.rename = cvfs_rename;
ops.search_next = cvfs_search_next;
ops.search_close = cvfs_search_close;
ops.trans = cvfs_trans;
+ ops.logoff = cvfs_logoff;
+ ops.async_setup = cvfs_async_setup;
+ ops.cancel = cvfs_cancel;
- /* only define this one for trans2 testing */
- ops.trans2 = NULL;
+ if (lp_parm_bool(-1, "cifs", "maptrans2", False)) {
+ ops.trans2 = cvfs_trans2;
+ }
/* register ourselves with the NTVFS subsystem. We register
under the name 'cifs'. */
- ret = register_backend("ntvfs", &ops);
+ ret = ntvfs_register(&ops);
if (!NT_STATUS_IS_OK(ret)) {
DEBUG(0,("Failed to register CIFS backend!\n"));