ops.type = NTVFS_DISK;
/* fill in all the operations */
- ops.connect = cvfs_connect;
- ops.disconnect = cvfs_disconnect;
- ops.unlink = cvfs_unlink;
- ops.chkpath = cvfs_chkpath;
- ops.qpathinfo = cvfs_qpathinfo;
- ops.setpathinfo = cvfs_setpathinfo;
- ops.open = cvfs_open;
- ops.mkdir = cvfs_mkdir;
- ops.rmdir = cvfs_rmdir;
- ops.rename = cvfs_rename;
- ops.copy = cvfs_copy;
- ops.ioctl = cvfs_ioctl;
- ops.read = cvfs_read;
- ops.write = cvfs_write;
- ops.seek = cvfs_seek;
- ops.flush = cvfs_flush;
- ops.close = cvfs_close;
- ops.exit = cvfs_exit;
- ops.lock = cvfs_lock;
- ops.setfileinfo = cvfs_setfileinfo;
- ops.qfileinfo = cvfs_qfileinfo;
- ops.fsinfo = cvfs_fsinfo;
- ops.lpq = cvfs_lpq;
- ops.search_first = cvfs_search_first;
- 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;
- ops.notify = cvfs_notify;
- ops.trans2 = cvfs_trans2;
+ ops.connect_fn = cvfs_connect;
+ ops.disconnect_fn = cvfs_disconnect;
+ ops.unlink_fn = cvfs_unlink;
+ ops.chkpath_fn = cvfs_chkpath;
+ ops.qpathinfo_fn = cvfs_qpathinfo;
+ ops.setpathinfo_fn = cvfs_setpathinfo;
+ ops.open_fn = cvfs_open;
+ ops.mkdir_fn = cvfs_mkdir;
+ ops.rmdir_fn = cvfs_rmdir;
+ ops.rename_fn = cvfs_rename;
+ ops.copy_fn = cvfs_copy;
+ ops.ioctl_fn = cvfs_ioctl;
+ ops.read_fn = cvfs_read;
+ ops.write_fn = cvfs_write;
+ ops.seek_fn = cvfs_seek;
+ ops.flush_fn = cvfs_flush;
+ ops.close_fn = cvfs_close;
+ ops.exit_fn = cvfs_exit;
+ ops.lock_fn = cvfs_lock;
+ ops.setfileinfo_fn = cvfs_setfileinfo;
+ ops.qfileinfo_fn = cvfs_qfileinfo;
+ ops.fsinfo_fn = cvfs_fsinfo;
+ ops.lpq_fn = cvfs_lpq;
+ ops.search_first_fn = cvfs_search_first;
+ ops.search_next_fn = cvfs_search_next;
+ ops.search_close_fn = cvfs_search_close;
+ ops.trans_fn = cvfs_trans;
+ ops.logoff_fn = cvfs_logoff;
+ ops.async_setup_fn = cvfs_async_setup;
+ ops.cancel_fn = cvfs_cancel;
+ ops.notify_fn = cvfs_notify;
+ ops.trans2_fn = cvfs_trans2;
/* register ourselves with the NTVFS subsystem. We register
under the name 'cifs'. */
ZERO_STRUCT(ops);
/* fill in all the operations */
- ops.connect = cifspsx_connect;
- ops.disconnect = cifspsx_disconnect;
- ops.unlink = cifspsx_unlink;
- ops.chkpath = cifspsx_chkpath;
- ops.qpathinfo = cifspsx_qpathinfo;
- ops.setpathinfo = cifspsx_setpathinfo;
- ops.open = cifspsx_open;
- ops.mkdir = cifspsx_mkdir;
- ops.rmdir = cifspsx_rmdir;
- ops.rename = cifspsx_rename;
- ops.copy = cifspsx_copy;
- ops.ioctl = cifspsx_ioctl;
- ops.read = cifspsx_read;
- ops.write = cifspsx_write;
- ops.seek = cifspsx_seek;
- ops.flush = cifspsx_flush;
- ops.close = cifspsx_close;
- ops.exit = cifspsx_exit;
- ops.lock = cifspsx_lock;
- ops.setfileinfo = cifspsx_setfileinfo;
- ops.qfileinfo = cifspsx_qfileinfo;
- ops.fsinfo = cifspsx_fsinfo;
- ops.lpq = cifspsx_lpq;
- ops.search_first = cifspsx_search_first;
- ops.search_next = cifspsx_search_next;
- ops.search_close = cifspsx_search_close;
- ops.trans = cifspsx_trans;
- ops.logoff = cifspsx_logoff;
- ops.async_setup = cifspsx_async_setup;
- ops.cancel = cifspsx_cancel;
+ ops.connect_fn = cifspsx_connect;
+ ops.disconnect_fn = cifspsx_disconnect;
+ ops.unlink_fn = cifspsx_unlink;
+ ops.chkpath_fn = cifspsx_chkpath;
+ ops.qpathinfo_fn = cifspsx_qpathinfo;
+ ops.setpathinfo_fn = cifspsx_setpathinfo;
+ ops.open_fn = cifspsx_open;
+ ops.mkdir_fn = cifspsx_mkdir;
+ ops.rmdir_fn = cifspsx_rmdir;
+ ops.rename_fn = cifspsx_rename;
+ ops.copy_fn = cifspsx_copy;
+ ops.ioctl_fn = cifspsx_ioctl;
+ ops.read_fn = cifspsx_read;
+ ops.write_fn = cifspsx_write;
+ ops.seek_fn = cifspsx_seek;
+ ops.flush_fn = cifspsx_flush;
+ ops.close_fn = cifspsx_close;
+ ops.exit_fn = cifspsx_exit;
+ ops.lock_fn = cifspsx_lock;
+ ops.setfileinfo_fn = cifspsx_setfileinfo;
+ ops.qfileinfo_fn = cifspsx_qfileinfo;
+ ops.fsinfo_fn = cifspsx_fsinfo;
+ ops.lpq_fn = cifspsx_lpq;
+ ops.search_first_fn = cifspsx_search_first;
+ ops.search_next_fn = cifspsx_search_next;
+ ops.search_close_fn = cifspsx_search_close;
+ ops.trans_fn = cifspsx_trans;
+ ops.logoff_fn = cifspsx_logoff;
+ ops.async_setup_fn = cifspsx_async_setup;
+ ops.cancel_fn = cifspsx_cancel;
/* register ourselves with the NTVFS subsystem. We register
under names 'cifsposix'
ops.type = NTVFS_IPC;
/* fill in all the operations */
- ops.connect = ipc_connect;
- ops.disconnect = ipc_disconnect;
- ops.unlink = ipc_unlink;
- ops.chkpath = ipc_chkpath;
- ops.qpathinfo = ipc_qpathinfo;
- ops.setpathinfo = ipc_setpathinfo;
- ops.open = ipc_open;
- ops.mkdir = ipc_mkdir;
- ops.rmdir = ipc_rmdir;
- ops.rename = ipc_rename;
- ops.copy = ipc_copy;
- ops.ioctl = ipc_ioctl;
- ops.read = ipc_read;
- ops.write = ipc_write;
- ops.seek = ipc_seek;
- ops.flush = ipc_flush;
- ops.close = ipc_close;
- ops.exit = ipc_exit;
- ops.lock = ipc_lock;
- ops.setfileinfo = ipc_setfileinfo;
- ops.qfileinfo = ipc_qfileinfo;
- ops.fsinfo = ipc_fsinfo;
- ops.lpq = ipc_lpq;
- ops.search_first = ipc_search_first;
- ops.search_next = ipc_search_next;
- ops.search_close = ipc_search_close;
- ops.trans = ipc_trans;
- ops.logoff = ipc_logoff;
- ops.async_setup = ipc_async_setup;
- ops.cancel = ipc_cancel;
+ ops.connect_fn = ipc_connect;
+ ops.disconnect_fn = ipc_disconnect;
+ ops.unlink_fn = ipc_unlink;
+ ops.chkpath_fn = ipc_chkpath;
+ ops.qpathinfo_fn = ipc_qpathinfo;
+ ops.setpathinfo_fn = ipc_setpathinfo;
+ ops.open_fn = ipc_open;
+ ops.mkdir_fn = ipc_mkdir;
+ ops.rmdir_fn = ipc_rmdir;
+ ops.rename_fn = ipc_rename;
+ ops.copy_fn = ipc_copy;
+ ops.ioctl_fn = ipc_ioctl;
+ ops.read_fn = ipc_read;
+ ops.write_fn = ipc_write;
+ ops.seek_fn = ipc_seek;
+ ops.flush_fn = ipc_flush;
+ ops.close_fn = ipc_close;
+ ops.exit_fn = ipc_exit;
+ ops.lock_fn = ipc_lock;
+ ops.setfileinfo_fn = ipc_setfileinfo;
+ ops.qfileinfo_fn = ipc_qfileinfo;
+ ops.fsinfo_fn = ipc_fsinfo;
+ ops.lpq_fn = ipc_lpq;
+ ops.search_first_fn = ipc_search_first;
+ ops.search_next_fn = ipc_search_next;
+ ops.search_close_fn = ipc_search_close;
+ ops.trans_fn = ipc_trans;
+ ops.logoff_fn = ipc_logoff;
+ ops.async_setup_fn = ipc_async_setup;
+ ops.cancel_fn = ipc_cancel;
/* register ourselves with the NTVFS subsystem. */
ret = ntvfs_register(&ops, &vers);
ops.type = NTVFS_DISK;
/* fill in all the operations */
- ops.connect = nbench_connect;
- ops.disconnect = nbench_disconnect;
- ops.unlink = nbench_unlink;
- ops.chkpath = nbench_chkpath;
- ops.qpathinfo = nbench_qpathinfo;
- ops.setpathinfo = nbench_setpathinfo;
- ops.open = nbench_open;
- ops.mkdir = nbench_mkdir;
- ops.rmdir = nbench_rmdir;
- ops.rename = nbench_rename;
- ops.copy = nbench_copy;
- ops.ioctl = nbench_ioctl;
- ops.read = nbench_read;
- ops.write = nbench_write;
- ops.seek = nbench_seek;
- ops.flush = nbench_flush;
- ops.close = nbench_close;
- ops.exit = nbench_exit;
- ops.lock = nbench_lock;
- ops.setfileinfo = nbench_setfileinfo;
- ops.qfileinfo = nbench_qfileinfo;
- ops.fsinfo = nbench_fsinfo;
- ops.lpq = nbench_lpq;
- ops.search_first = nbench_search_first;
- ops.search_next = nbench_search_next;
- ops.search_close = nbench_search_close;
- ops.trans = nbench_trans;
- ops.logoff = nbench_logoff;
- ops.async_setup = nbench_async_setup;
- ops.cancel = nbench_cancel;
+ ops.connect_fn = nbench_connect;
+ ops.disconnect_fn = nbench_disconnect;
+ ops.unlink_fn = nbench_unlink;
+ ops.chkpath_fn = nbench_chkpath;
+ ops.qpathinfo_fn = nbench_qpathinfo;
+ ops.setpathinfo_fn = nbench_setpathinfo;
+ ops.open_fn = nbench_open;
+ ops.mkdir_fn = nbench_mkdir;
+ ops.rmdir_fn = nbench_rmdir;
+ ops.rename_fn = nbench_rename;
+ ops.copy_fn = nbench_copy;
+ ops.ioctl_fn = nbench_ioctl;
+ ops.read_fn = nbench_read;
+ ops.write_fn = nbench_write;
+ ops.seek_fn = nbench_seek;
+ ops.flush_fn = nbench_flush;
+ ops.close_fn = nbench_close;
+ ops.exit_fn = nbench_exit;
+ ops.lock_fn = nbench_lock;
+ ops.setfileinfo_fn = nbench_setfileinfo;
+ ops.qfileinfo_fn = nbench_qfileinfo;
+ ops.fsinfo_fn = nbench_fsinfo;
+ ops.lpq_fn = nbench_lpq;
+ ops.search_first_fn = nbench_search_first;
+ ops.search_next_fn = nbench_search_next;
+ ops.search_close_fn = nbench_search_close;
+ ops.trans_fn = nbench_trans;
+ ops.logoff_fn = nbench_logoff;
+ ops.async_setup_fn = nbench_async_setup;
+ ops.cancel_fn = nbench_cancel;
/* we don't register a trans2 handler as we want to be able to
log individual trans2 requests */
- ops.trans2 = NULL;
+ ops.trans2_fn = NULL;
/* register ourselves with the NTVFS subsystem. */
ret = ntvfs_register(&ops, &vers);
enum ntvfs_type type;
/* initial setup */
- NTSTATUS (*connect)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*connect_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_tcon *tcon);
- NTSTATUS (*disconnect)(struct ntvfs_module_context *ntvfs);
+ NTSTATUS (*disconnect_fn)(struct ntvfs_module_context *ntvfs);
/* async_setup - called when a backend is processing a async request */
- NTSTATUS (*async_setup)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*async_setup_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
void *private_data);
/* filesystem operations */
- NTSTATUS (*fsinfo)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*fsinfo_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_fsinfo *fs);
/* path operations */
- NTSTATUS (*unlink)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*unlink_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_unlink *unl);
- NTSTATUS (*chkpath)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*chkpath_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_chkpath *cp);
- NTSTATUS (*qpathinfo)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*qpathinfo_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_fileinfo *st);
- NTSTATUS (*setpathinfo)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*setpathinfo_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_setfileinfo *st);
- NTSTATUS (*mkdir)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*mkdir_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_mkdir *md);
- NTSTATUS (*rmdir)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*rmdir_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_rmdir *rd);
- NTSTATUS (*rename)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*rename_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_rename *ren);
- NTSTATUS (*copy)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*copy_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_copy *cp);
- NTSTATUS (*open)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*open_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_open *oi);
/* directory search */
- NTSTATUS (*search_first)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*search_first_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_search_first *io, void *private_data,
- bool (*callback)(void *private_data, const union smb_search_data *file));
- NTSTATUS (*search_next)(struct ntvfs_module_context *ntvfs,
+ bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+ NTSTATUS (*search_next_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_search_next *io, void *private_data,
- bool (*callback)(void *private_data, const union smb_search_data *file));
- NTSTATUS (*search_close)(struct ntvfs_module_context *ntvfs,
+ bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+ NTSTATUS (*search_close_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_search_close *io);
/* operations on open files */
- NTSTATUS (*ioctl)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*ioctl_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_ioctl *io);
- NTSTATUS (*read)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*read_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_read *io);
- NTSTATUS (*write)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*write_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_write *io);
- NTSTATUS (*seek)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*seek_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_seek *io);
- NTSTATUS (*flush)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*flush_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_flush *flush);
- NTSTATUS (*lock)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*lock_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_lock *lck);
- NTSTATUS (*qfileinfo)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*qfileinfo_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_fileinfo *info);
- NTSTATUS (*setfileinfo)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*setfileinfo_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_setfileinfo *info);
- NTSTATUS (*close)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*close_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_close *io);
/* trans interface - used by IPC backend for pipes and RAP calls */
- NTSTATUS (*trans)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*trans_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_trans2 *trans);
/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
- NTSTATUS (*trans2)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*trans2_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_trans2 *trans2);
/* change notify request */
- NTSTATUS (*notify)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*notify_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_notify *info);
/* cancel - cancels any pending async request */
- NTSTATUS (*cancel)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*cancel_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req);
/* printing specific operations */
- NTSTATUS (*lpq)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*lpq_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_lpq *lpq);
/* logoff - called when a vuid is closed */
- NTSTATUS (*logoff)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*logoff_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req);
- NTSTATUS (*exit)(struct ntvfs_module_context *ntvfs,
+ NTSTATUS (*exit_fn)(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req);
};
sf->standard.in.create_time = 0;
sf->standard.in.write_time = write_time;
sf->standard.in.access_time = 0;
- status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+ status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
}
if (set_size != 0) {
sf->generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
sf->generic.in.file.ntvfs = io2->generic.out.file.ntvfs;
sf->end_of_file_info.in.size = set_size;
- status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+ status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
if (NT_STATUS_IS_OK(status)) {
io->openx.out.size = io->openx.in.size;
}
io2->generic.in.file_attr = io->openx.in.file_attrs;
io2->generic.in.fname = io->openx.in.fname;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
io2->generic.in.file_attr = io->openold.in.search_attrs;
io2->generic.in.fname = io->openold.in.fname;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
case RAW_OPEN_T2OPEN:
io2->generic.in.ea_list->num_eas = io->t2open.in.num_eas;
io2->generic.in.ea_list->eas = io->t2open.in.eas;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
case RAW_OPEN_MKNEW:
io2->generic.in.share_access =
NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
case RAW_OPEN_CREATE:
io2->generic.in.share_access =
NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
case RAW_OPEN_CTEMP:
io2->generic.in.share_access =
NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
case RAW_OPEN_SMB2:
switch (io->smb2.in.oplock_level) {
io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_SYNC_ALERT;
io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_ASYNC_ALERT;
- status = ntvfs->ops->open(ntvfs, req, io2);
+ status = ntvfs->ops->open_fn(ntvfs, req, io2);
break;
default:
/* ask the backend for the generic info */
fs2->generic.level = RAW_QFS_GENERIC;
- status = ntvfs->ops->fsinfo(ntvfs, req, fs2);
+ status = ntvfs->ops->fsinfo_fn(ntvfs, req, fs2);
return ntvfs_map_async_finish(req, status);
}
info2->generic.level = RAW_FILEINFO_GENERIC;
info2->generic.in.file.ntvfs= info->generic.in.file.ntvfs;
- status = ntvfs->ops->qfileinfo(ntvfs, req, info2);
+ status = ntvfs->ops->qfileinfo_fn(ntvfs, req, info2);
return ntvfs_map_async_finish(req, status);
}
info2->generic.level = RAW_FILEINFO_GENERIC;
info2->generic.in.file.path = info->generic.in.file.path;
- status = ntvfs->ops->qpathinfo(ntvfs, req, info2);
+ status = ntvfs->ops->qpathinfo_fn(ntvfs, req, info2);
return ntvfs_map_async_finish(req, status);
}
* as lock() doesn't have any output fields
*/
- return ntvfs->ops->lock(ntvfs, req, lck2);
+ return ntvfs->ops->lock_fn(ntvfs, req, lck2);
}
/* do the lock sync for now */
state = req->async_states->state;
req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
- status = ntvfs->ops->lock(ntvfs, req, lck);
+ status = ntvfs->ops->lock_fn(ntvfs, req, lck);
req->async_states->state = state;
}
break;
/* do the close sync for now */
state = req->async_states->state;
req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
- status = ntvfs->ops->close(ntvfs, req, cl);
+ status = ntvfs->ops->close_fn(ntvfs, req, cl);
req->async_states->state = state;
}
break;
wr2->writex.in.remaining = wr->write.in.remaining;
wr2->writex.in.count = wr->write.in.count;
wr2->writex.in.data = wr->write.in.data;
- status = ntvfs->ops->write(ntvfs, req, wr2);
+ status = ntvfs->ops->write_fn(ntvfs, req, wr2);
break;
case RAW_WRITE_WRITEUNLOCK:
wr2->writex.in.remaining = wr->writeunlock.in.remaining;
wr2->writex.in.count = wr->writeunlock.in.count;
wr2->writex.in.data = wr->writeunlock.in.data;
- status = ntvfs->ops->write(ntvfs, req, wr2);
+ status = ntvfs->ops->write_fn(ntvfs, req, wr2);
break;
case RAW_WRITE_WRITECLOSE:
wr2->writex.in.remaining = 0;
wr2->writex.in.count = wr->writeclose.in.count;
wr2->writex.in.data = wr->writeclose.in.data;
- status = ntvfs->ops->write(ntvfs, req, wr2);
+ status = ntvfs->ops->write_fn(ntvfs, req, wr2);
break;
case RAW_WRITE_SPLWRITE:
wr2->writex.in.remaining = 0;
wr2->writex.in.count = wr->splwrite.in.count;
wr2->writex.in.data = wr->splwrite.in.data;
- status = ntvfs->ops->write(ntvfs, req, wr2);
+ status = ntvfs->ops->write_fn(ntvfs, req, wr2);
break;
case RAW_WRITE_SMB2:
wr2->writex.in.remaining = 0;
wr2->writex.in.count = wr->smb2.in.data.length;
wr2->writex.in.data = wr->smb2.in.data.data;
- status = ntvfs->ops->write(ntvfs, req, wr2);
+ status = ntvfs->ops->write_fn(ntvfs, req, wr2);
}
return ntvfs_map_async_finish(req, status);
rd2->readx.in.maxcnt = rd->read.in.count;
rd2->readx.in.remaining = rd->read.in.remaining;
rd2->readx.out.data = rd->read.out.data;
- status = ntvfs->ops->read(ntvfs, req, rd2);
+ status = ntvfs->ops->read_fn(ntvfs, req, rd2);
break;
case RAW_READ_READBRAW:
rd2->readx.in.maxcnt = rd->readbraw.in.maxcnt;
rd2->readx.in.remaining = 0;
rd2->readx.out.data = rd->readbraw.out.data;
- status = ntvfs->ops->read(ntvfs, req, rd2);
+ status = ntvfs->ops->read_fn(ntvfs, req, rd2);
break;
case RAW_READ_LOCKREAD:
lck->lock.in.file.ntvfs = rd->lockread.in.file.ntvfs;
lck->lock.in.count = rd->lockread.in.count;
lck->lock.in.offset = rd->lockread.in.offset;
- status = ntvfs->ops->lock(ntvfs, req, lck);
+ status = ntvfs->ops->lock_fn(ntvfs, req, lck);
req->async_states->state = state;
rd2->readx.in.file.ntvfs= rd->lockread.in.file.ntvfs;
rd2->readx.out.data = rd->lockread.out.data;
if (NT_STATUS_IS_OK(status)) {
- status = ntvfs->ops->read(ntvfs, req, rd2);
+ status = ntvfs->ops->read_fn(ntvfs, req, rd2);
}
break;
rd2->readx.in.maxcnt = rd->smb2.in.length;
rd2->readx.in.remaining = 0;
rd2->readx.out.data = rd->smb2.out.data.data;
- status = ntvfs->ops->read(ntvfs, req, rd2);
+ status = ntvfs->ops->read_fn(ntvfs, req, rd2);
break;
}
(second_stage_t)ntvfs_map_close_finish);
NT_STATUS_NOT_OK_RETURN(status);
- status = ntvfs->ops->close(ntvfs, req, cl2);
+ status = ntvfs->ops->close_fn(ntvfs, req, cl2);
return ntvfs_map_async_finish(req, status);
}
nt2->nttrans.in.buffer_size = nt->smb2.in.buffer_size;
nt2->nttrans.in.completion_filter = nt->smb2.in.completion_filter;
nt2->nttrans.in.recursive = nt->smb2.in.recursive;
- status = ntvfs->ops->notify(ntvfs, req, nt2);
+ status = ntvfs->ops->notify_fn(ntvfs, req, nt2);
break;
}
NTSTATUS ntvfs_connect(struct ntvfs_request *req, union smb_tcon *tcon)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->connect) {
+ if (!ntvfs->ops->connect_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->connect(ntvfs, req, tcon);
+ return ntvfs->ops->connect_fn(ntvfs, req, tcon);
}
NTSTATUS ntvfs_disconnect(struct ntvfs_context *ntvfs_ctx)
return NT_STATUS_INVALID_CONNECTION;
}
ntvfs = ntvfs_ctx->modules;
- if (!ntvfs->ops->disconnect) {
+ if (!ntvfs->ops->disconnect_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->disconnect(ntvfs);
+ return ntvfs->ops->disconnect_fn(ntvfs);
}
/* async setup - called by a backend that wants to setup any state for
NTSTATUS ntvfs_async_setup(struct ntvfs_request *req, void *private_data)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->async_setup) {
+ if (!ntvfs->ops->async_setup_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->async_setup(ntvfs, req, private_data);
+ return ntvfs->ops->async_setup_fn(ntvfs, req, private_data);
}
/* filesystem operations */
NTSTATUS ntvfs_fsinfo(struct ntvfs_request *req, union smb_fsinfo *fs)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->fsinfo) {
+ if (!ntvfs->ops->fsinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->fsinfo(ntvfs, req, fs);
+ return ntvfs->ops->fsinfo_fn(ntvfs, req, fs);
}
/* path operations */
NTSTATUS ntvfs_unlink(struct ntvfs_request *req, union smb_unlink *unl)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->unlink) {
+ if (!ntvfs->ops->unlink_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->unlink(ntvfs, req, unl);
+ return ntvfs->ops->unlink_fn(ntvfs, req, unl);
}
NTSTATUS ntvfs_chkpath(struct ntvfs_request *req, union smb_chkpath *cp)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->chkpath) {
+ if (!ntvfs->ops->chkpath_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->chkpath(ntvfs, req, cp);
+ return ntvfs->ops->chkpath_fn(ntvfs, req, cp);
}
NTSTATUS ntvfs_qpathinfo(struct ntvfs_request *req, union smb_fileinfo *st)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->qpathinfo) {
+ if (!ntvfs->ops->qpathinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->qpathinfo(ntvfs, req, st);
+ return ntvfs->ops->qpathinfo_fn(ntvfs, req, st);
}
NTSTATUS ntvfs_setpathinfo(struct ntvfs_request *req, union smb_setfileinfo *st)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->setpathinfo) {
+ if (!ntvfs->ops->setpathinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->setpathinfo(ntvfs, req, st);
+ return ntvfs->ops->setpathinfo_fn(ntvfs, req, st);
}
NTSTATUS ntvfs_open(struct ntvfs_request *req, union smb_open *oi)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->open) {
+ if (!ntvfs->ops->open_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->open(ntvfs, req, oi);
+ return ntvfs->ops->open_fn(ntvfs, req, oi);
}
NTSTATUS ntvfs_mkdir(struct ntvfs_request *req, union smb_mkdir *md)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->mkdir) {
+ if (!ntvfs->ops->mkdir_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->mkdir(ntvfs, req, md);
+ return ntvfs->ops->mkdir_fn(ntvfs, req, md);
}
NTSTATUS ntvfs_rmdir(struct ntvfs_request *req, struct smb_rmdir *rd)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->rmdir) {
+ if (!ntvfs->ops->rmdir_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->rmdir(ntvfs, req, rd);
+ return ntvfs->ops->rmdir_fn(ntvfs, req, rd);
}
NTSTATUS ntvfs_rename(struct ntvfs_request *req, union smb_rename *ren)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->rename) {
+ if (!ntvfs->ops->rename_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->rename(ntvfs, req, ren);
+ return ntvfs->ops->rename_fn(ntvfs, req, ren);
}
NTSTATUS ntvfs_copy(struct ntvfs_request *req, struct smb_copy *cp)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->copy) {
+ if (!ntvfs->ops->copy_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->copy(ntvfs, req, cp);
+ return ntvfs->ops->copy_fn(ntvfs, req, cp);
}
/* directory search */
bool ntvfs_callback(void *private_data, const union smb_search_data *file))
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->search_first) {
+ if (!ntvfs->ops->search_first_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->search_first(ntvfs, req, io, private_data, ntvfs_callback);
+ return ntvfs->ops->search_first_fn(ntvfs, req, io, private_data, ntvfs_callback);
}
NTSTATUS ntvfs_search_next(struct ntvfs_request *req, union smb_search_next *io, void *private_data,
bool ntvfs_callback(void *private_data, const union smb_search_data *file))
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->search_next) {
+ if (!ntvfs->ops->search_next_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->search_next(ntvfs, req, io, private_data, ntvfs_callback);
+ return ntvfs->ops->search_next_fn(ntvfs, req, io, private_data, ntvfs_callback);
}
NTSTATUS ntvfs_search_close(struct ntvfs_request *req, union smb_search_close *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->search_close) {
+ if (!ntvfs->ops->search_close_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->search_close(ntvfs, req, io);
+ return ntvfs->ops->search_close_fn(ntvfs, req, io);
}
/* operations on open files */
NTSTATUS ntvfs_ioctl(struct ntvfs_request *req, union smb_ioctl *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->ioctl) {
+ if (!ntvfs->ops->ioctl_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->ioctl(ntvfs, req, io);
+ return ntvfs->ops->ioctl_fn(ntvfs, req, io);
}
NTSTATUS ntvfs_read(struct ntvfs_request *req, union smb_read *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->read) {
+ if (!ntvfs->ops->read_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->read(ntvfs, req, io);
+ return ntvfs->ops->read_fn(ntvfs, req, io);
}
NTSTATUS ntvfs_write(struct ntvfs_request *req, union smb_write *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->write) {
+ if (!ntvfs->ops->write_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->write(ntvfs, req, io);
+ return ntvfs->ops->write_fn(ntvfs, req, io);
}
NTSTATUS ntvfs_seek(struct ntvfs_request *req, union smb_seek *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->seek) {
+ if (!ntvfs->ops->seek_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->seek(ntvfs, req, io);
+ return ntvfs->ops->seek_fn(ntvfs, req, io);
}
NTSTATUS ntvfs_flush(struct ntvfs_request *req,
union smb_flush *flush)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->flush) {
+ if (!ntvfs->ops->flush_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->flush(ntvfs, req, flush);
+ return ntvfs->ops->flush_fn(ntvfs, req, flush);
}
NTSTATUS ntvfs_lock(struct ntvfs_request *req, union smb_lock *lck)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->lock) {
+ if (!ntvfs->ops->lock_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->lock(ntvfs, req, lck);
+ return ntvfs->ops->lock_fn(ntvfs, req, lck);
}
NTSTATUS ntvfs_qfileinfo(struct ntvfs_request *req, union smb_fileinfo *info)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->qfileinfo) {
+ if (!ntvfs->ops->qfileinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->qfileinfo(ntvfs, req, info);
+ return ntvfs->ops->qfileinfo_fn(ntvfs, req, info);
}
NTSTATUS ntvfs_setfileinfo(struct ntvfs_request *req, union smb_setfileinfo *info)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->setfileinfo) {
+ if (!ntvfs->ops->setfileinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->setfileinfo(ntvfs, req, info);
+ return ntvfs->ops->setfileinfo_fn(ntvfs, req, info);
}
NTSTATUS ntvfs_close(struct ntvfs_request *req, union smb_close *io)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->close) {
+ if (!ntvfs->ops->close_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->close(ntvfs, req, io);
+ return ntvfs->ops->close_fn(ntvfs, req, io);
}
/* trans interface - used by IPC backend for pipes and RAP calls */
NTSTATUS ntvfs_trans(struct ntvfs_request *req, struct smb_trans2 *trans)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->trans) {
+ if (!ntvfs->ops->trans_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->trans(ntvfs, req, trans);
+ return ntvfs->ops->trans_fn(ntvfs, req, trans);
}
/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
NTSTATUS ntvfs_trans2(struct ntvfs_request *req, struct smb_trans2 *trans2)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->trans2) {
+ if (!ntvfs->ops->trans2_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->trans2(ntvfs, req, trans2);
+ return ntvfs->ops->trans2_fn(ntvfs, req, trans2);
}
/* printing specific operations */
NTSTATUS ntvfs_lpq(struct ntvfs_request *req, union smb_lpq *lpq)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->lpq) {
+ if (!ntvfs->ops->lpq_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->lpq(ntvfs, req, lpq);
+ return ntvfs->ops->lpq_fn(ntvfs, req, lpq);
}
/* logoff - called when a vuid is closed */
NTSTATUS ntvfs_logoff(struct ntvfs_request *req)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->logoff) {
+ if (!ntvfs->ops->logoff_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->logoff(ntvfs, req);
+ return ntvfs->ops->logoff_fn(ntvfs, req);
}
NTSTATUS ntvfs_exit(struct ntvfs_request *req)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->exit) {
+ if (!ntvfs->ops->exit_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->exit(ntvfs, req);
+ return ntvfs->ops->exit_fn(ntvfs, req);
}
/*
NTSTATUS ntvfs_notify(struct ntvfs_request *req, union smb_notify *info)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->notify) {
+ if (!ntvfs->ops->notify_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->notify(ntvfs, req, info);
+ return ntvfs->ops->notify_fn(ntvfs, req, info);
}
/*
NTSTATUS ntvfs_cancel(struct ntvfs_request *req)
{
struct ntvfs_module_context *ntvfs = req->ctx->modules;
- if (!ntvfs->ops->cancel) {
+ if (!ntvfs->ops->cancel_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->ops->cancel(ntvfs, req);
+ return ntvfs->ops->cancel_fn(ntvfs, req);
}
/* initial setup */
struct ntvfs_request *req,
union smb_tcon *tcon)
{
- if (!ntvfs->next || !ntvfs->next->ops->connect) {
+ if (!ntvfs->next || !ntvfs->next->ops->connect_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->connect(ntvfs->next, req, tcon);
+ return ntvfs->next->ops->connect_fn(ntvfs->next, req, tcon);
}
NTSTATUS ntvfs_next_disconnect(struct ntvfs_module_context *ntvfs)
{
- if (!ntvfs->next || !ntvfs->next->ops->disconnect) {
+ if (!ntvfs->next || !ntvfs->next->ops->disconnect_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->disconnect(ntvfs->next);
+ return ntvfs->next->ops->disconnect_fn(ntvfs->next);
}
/* async_setup - called when setting up for a async request */
struct ntvfs_request *req,
void *private_data)
{
- if (!ntvfs->next || !ntvfs->next->ops->async_setup) {
+ if (!ntvfs->next || !ntvfs->next->ops->async_setup_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->async_setup(ntvfs->next, req, private_data);
+ return ntvfs->next->ops->async_setup_fn(ntvfs->next, req, private_data);
}
/* filesystem operations */
struct ntvfs_request *req,
union smb_fsinfo *fs)
{
- if (!ntvfs->next || !ntvfs->next->ops->fsinfo) {
+ if (!ntvfs->next || !ntvfs->next->ops->fsinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->fsinfo(ntvfs->next, req, fs);
+ return ntvfs->next->ops->fsinfo_fn(ntvfs->next, req, fs);
}
/* path operations */
struct ntvfs_request *req,
union smb_unlink *unl)
{
- if (!ntvfs->next || !ntvfs->next->ops->unlink) {
+ if (!ntvfs->next || !ntvfs->next->ops->unlink_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->unlink(ntvfs->next, req, unl);
+ return ntvfs->next->ops->unlink_fn(ntvfs->next, req, unl);
}
NTSTATUS ntvfs_next_chkpath(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_chkpath *cp)
{
- if (!ntvfs->next || !ntvfs->next->ops->chkpath) {
+ if (!ntvfs->next || !ntvfs->next->ops->chkpath_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->chkpath(ntvfs->next, req, cp);
+ return ntvfs->next->ops->chkpath_fn(ntvfs->next, req, cp);
}
NTSTATUS ntvfs_next_qpathinfo(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_fileinfo *st)
{
- if (!ntvfs->next || !ntvfs->next->ops->qpathinfo) {
+ if (!ntvfs->next || !ntvfs->next->ops->qpathinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->qpathinfo(ntvfs->next, req, st);
+ return ntvfs->next->ops->qpathinfo_fn(ntvfs->next, req, st);
}
NTSTATUS ntvfs_next_setpathinfo(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_setfileinfo *st)
{
- if (!ntvfs->next || !ntvfs->next->ops->setpathinfo) {
+ if (!ntvfs->next || !ntvfs->next->ops->setpathinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->setpathinfo(ntvfs->next, req, st);
+ return ntvfs->next->ops->setpathinfo_fn(ntvfs->next, req, st);
}
NTSTATUS ntvfs_next_mkdir(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_mkdir *md)
{
- if (!ntvfs->next || !ntvfs->next->ops->mkdir) {
+ if (!ntvfs->next || !ntvfs->next->ops->mkdir_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->mkdir(ntvfs->next, req, md);
+ return ntvfs->next->ops->mkdir_fn(ntvfs->next, req, md);
}
NTSTATUS ntvfs_next_rmdir(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_rmdir *rd)
{
- if (!ntvfs->next || !ntvfs->next->ops->rmdir) {
+ if (!ntvfs->next || !ntvfs->next->ops->rmdir_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->rmdir(ntvfs->next, req, rd);
+ return ntvfs->next->ops->rmdir_fn(ntvfs->next, req, rd);
}
NTSTATUS ntvfs_next_rename(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_rename *ren)
{
- if (!ntvfs->next || !ntvfs->next->ops->rename) {
+ if (!ntvfs->next || !ntvfs->next->ops->rename_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->rename(ntvfs->next, req, ren);
+ return ntvfs->next->ops->rename_fn(ntvfs->next, req, ren);
}
NTSTATUS ntvfs_next_copy(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
struct smb_copy *cp)
{
- if (!ntvfs->next || !ntvfs->next->ops->copy) {
+ if (!ntvfs->next || !ntvfs->next->ops->copy_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->copy(ntvfs->next, req, cp);
+ return ntvfs->next->ops->copy_fn(ntvfs->next, req, cp);
}
NTSTATUS ntvfs_next_open(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_open *oi)
{
- if (!ntvfs->next || !ntvfs->next->ops->open) {
+ if (!ntvfs->next || !ntvfs->next->ops->open_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->open(ntvfs->next, req, oi);
+ return ntvfs->next->ops->open_fn(ntvfs->next, req, oi);
}
union smb_search_first *io, void *private_data,
bool (*callback)(void *private_data, const union smb_search_data *file))
{
- if (!ntvfs->next || !ntvfs->next->ops->search_first) {
+ if (!ntvfs->next || !ntvfs->next->ops->search_first_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->search_first(ntvfs->next, req, io, private_data, callback);
+ return ntvfs->next->ops->search_first_fn(ntvfs->next, req, io, private_data, callback);
}
NTSTATUS ntvfs_next_search_next(struct ntvfs_module_context *ntvfs,
union smb_search_next *io, void *private_data,
bool (*callback)(void *private_data, const union smb_search_data *file))
{
- if (!ntvfs->next || !ntvfs->next->ops->search_next) {
+ if (!ntvfs->next || !ntvfs->next->ops->search_next_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->search_next(ntvfs->next, req, io, private_data, callback);
+ return ntvfs->next->ops->search_next_fn(ntvfs->next, req, io, private_data, callback);
}
NTSTATUS ntvfs_next_search_close(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_search_close *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->search_close) {
+ if (!ntvfs->next || !ntvfs->next->ops->search_close_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->search_close(ntvfs->next, req, io);
+ return ntvfs->next->ops->search_close_fn(ntvfs->next, req, io);
}
/* operations on open files */
struct ntvfs_request *req,
union smb_ioctl *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->ioctl) {
+ if (!ntvfs->next || !ntvfs->next->ops->ioctl_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->ioctl(ntvfs->next, req, io);
+ return ntvfs->next->ops->ioctl_fn(ntvfs->next, req, io);
}
NTSTATUS ntvfs_next_read(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_read *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->read) {
+ if (!ntvfs->next || !ntvfs->next->ops->read_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->read(ntvfs->next, req, io);
+ return ntvfs->next->ops->read_fn(ntvfs->next, req, io);
}
NTSTATUS ntvfs_next_write(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_write *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->write) {
+ if (!ntvfs->next || !ntvfs->next->ops->write_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->write(ntvfs->next, req, io);
+ return ntvfs->next->ops->write_fn(ntvfs->next, req, io);
}
NTSTATUS ntvfs_next_seek(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_seek *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->seek) {
+ if (!ntvfs->next || !ntvfs->next->ops->seek_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->seek(ntvfs->next, req, io);
+ return ntvfs->next->ops->seek_fn(ntvfs->next, req, io);
}
NTSTATUS ntvfs_next_flush(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_flush *flush)
{
- if (!ntvfs->next || !ntvfs->next->ops->flush) {
+ if (!ntvfs->next || !ntvfs->next->ops->flush_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->flush(ntvfs->next, req, flush);
+ return ntvfs->next->ops->flush_fn(ntvfs->next, req, flush);
}
NTSTATUS ntvfs_next_lock(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_lock *lck)
{
- if (!ntvfs->next || !ntvfs->next->ops->lock) {
+ if (!ntvfs->next || !ntvfs->next->ops->lock_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->lock(ntvfs->next, req, lck);
+ return ntvfs->next->ops->lock_fn(ntvfs->next, req, lck);
}
NTSTATUS ntvfs_next_qfileinfo(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_fileinfo *info)
{
- if (!ntvfs->next || !ntvfs->next->ops->qfileinfo) {
+ if (!ntvfs->next || !ntvfs->next->ops->qfileinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->qfileinfo(ntvfs->next, req, info);
+ return ntvfs->next->ops->qfileinfo_fn(ntvfs->next, req, info);
}
NTSTATUS ntvfs_next_setfileinfo(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_setfileinfo *info)
{
- if (!ntvfs->next || !ntvfs->next->ops->setfileinfo) {
+ if (!ntvfs->next || !ntvfs->next->ops->setfileinfo_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->setfileinfo(ntvfs->next, req, info);
+ return ntvfs->next->ops->setfileinfo_fn(ntvfs->next, req, info);
}
NTSTATUS ntvfs_next_close(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_close *io)
{
- if (!ntvfs->next || !ntvfs->next->ops->close) {
+ if (!ntvfs->next || !ntvfs->next->ops->close_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->close(ntvfs->next, req, io);
+ return ntvfs->next->ops->close_fn(ntvfs->next, req, io);
}
/* trans interface - used by IPC backend for pipes and RAP calls */
struct ntvfs_request *req,
struct smb_trans2 *trans)
{
- if (!ntvfs->next || !ntvfs->next->ops->trans) {
+ if (!ntvfs->next || !ntvfs->next->ops->trans_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->trans(ntvfs->next, req, trans);
+ return ntvfs->next->ops->trans_fn(ntvfs->next, req, trans);
}
/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
struct ntvfs_request *req,
struct smb_trans2 *trans2)
{
- if (!ntvfs->next || !ntvfs->next->ops->trans2) {
+ if (!ntvfs->next || !ntvfs->next->ops->trans2_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->trans2(ntvfs->next, req, trans2);
+ return ntvfs->next->ops->trans2_fn(ntvfs->next, req, trans2);
}
/*
struct ntvfs_request *req,
union smb_notify *info)
{
- if (!ntvfs->next || !ntvfs->next->ops->notify) {
+ if (!ntvfs->next || !ntvfs->next->ops->notify_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->notify(ntvfs->next, req, info);
+ return ntvfs->next->ops->notify_fn(ntvfs->next, req, info);
}
/* cancel - called to cancel an outstanding async request */
NTSTATUS ntvfs_next_cancel(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req)
{
- if (!ntvfs->next || !ntvfs->next->ops->cancel) {
+ if (!ntvfs->next || !ntvfs->next->ops->cancel_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->cancel(ntvfs->next, req);
+ return ntvfs->next->ops->cancel_fn(ntvfs->next, req);
}
/* printing specific operations */
struct ntvfs_request *req,
union smb_lpq *lpq)
{
- if (!ntvfs->next || !ntvfs->next->ops->lpq) {
+ if (!ntvfs->next || !ntvfs->next->ops->lpq_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->lpq(ntvfs->next, req, lpq);
+ return ntvfs->next->ops->lpq_fn(ntvfs->next, req, lpq);
}
NTSTATUS ntvfs_next_logoff(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req)
{
- if (!ntvfs->next || !ntvfs->next->ops->logoff) {
+ if (!ntvfs->next || !ntvfs->next->ops->logoff_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->logoff(ntvfs->next, req);
+ return ntvfs->next->ops->logoff_fn(ntvfs->next, req);
}
NTSTATUS ntvfs_next_exit(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req)
{
- if (!ntvfs->next || !ntvfs->next->ops->exit) {
+ if (!ntvfs->next || !ntvfs->next->ops->exit_fn) {
return NT_STATUS_NOT_IMPLEMENTED;
}
- return ntvfs->next->ops->exit(ntvfs->next, req);
+ return ntvfs->next->ops->exit_fn(ntvfs->next, req);
}
/* client connection callback */
ops.type = NTVFS_DISK;
/* fill in all the operations */
- ops.connect = pvfs_connect;
- ops.disconnect = pvfs_disconnect;
- ops.unlink = pvfs_unlink;
- ops.chkpath = pvfs_chkpath;
- ops.qpathinfo = pvfs_qpathinfo;
- ops.setpathinfo = pvfs_setpathinfo;
- ops.open = pvfs_open;
- ops.mkdir = pvfs_mkdir;
- ops.rmdir = pvfs_rmdir;
- ops.rename = pvfs_rename;
- ops.copy = pvfs_copy;
- ops.ioctl = pvfs_ioctl;
- ops.read = pvfs_read;
- ops.write = pvfs_write;
- ops.seek = pvfs_seek;
- ops.flush = pvfs_flush;
- ops.close = pvfs_close;
- ops.exit = pvfs_exit;
- ops.lock = pvfs_lock;
- ops.setfileinfo = pvfs_setfileinfo;
- ops.qfileinfo = pvfs_qfileinfo;
- ops.fsinfo = pvfs_fsinfo;
- ops.lpq = pvfs_lpq;
- ops.search_first = pvfs_search_first;
- ops.search_next = pvfs_search_next;
- ops.search_close = pvfs_search_close;
- ops.trans = pvfs_trans;
- ops.logoff = pvfs_logoff;
- ops.async_setup = pvfs_async_setup;
- ops.cancel = pvfs_cancel;
- ops.notify = pvfs_notify;
+ ops.connect_fn = pvfs_connect;
+ ops.disconnect_fn = pvfs_disconnect;
+ ops.unlink_fn = pvfs_unlink;
+ ops.chkpath_fn = pvfs_chkpath;
+ ops.qpathinfo_fn = pvfs_qpathinfo;
+ ops.setpathinfo_fn = pvfs_setpathinfo;
+ ops.open_fn = pvfs_open;
+ ops.mkdir_fn = pvfs_mkdir;
+ ops.rmdir_fn = pvfs_rmdir;
+ ops.rename_fn = pvfs_rename;
+ ops.copy_fn = pvfs_copy;
+ ops.ioctl_fn = pvfs_ioctl;
+ ops.read_fn = pvfs_read;
+ ops.write_fn = pvfs_write;
+ ops.seek_fn = pvfs_seek;
+ ops.flush_fn = pvfs_flush;
+ ops.close_fn = pvfs_close;
+ ops.exit_fn = pvfs_exit;
+ ops.lock_fn = pvfs_lock;
+ ops.setfileinfo_fn = pvfs_setfileinfo;
+ ops.qfileinfo_fn = pvfs_qfileinfo;
+ ops.fsinfo_fn = pvfs_fsinfo;
+ ops.lpq_fn = pvfs_lpq;
+ ops.search_first_fn = pvfs_search_first;
+ ops.search_next_fn = pvfs_search_next;
+ ops.search_close_fn = pvfs_search_close;
+ ops.trans_fn = pvfs_trans;
+ ops.logoff_fn = pvfs_logoff;
+ ops.async_setup_fn = pvfs_async_setup;
+ ops.cancel_fn = pvfs_cancel;
+ ops.notify_fn = pvfs_notify;
/* register ourselves with the NTVFS subsystem. We register
under the name 'default' as we wish to be the default
ops.type = NTVFS_PRINT;
/* fill in all the operations */
- ops.connect = print_connect;
- ops.disconnect = print_disconnect;
- ops.unlink = print_unlink;
- ops.ioctl = print_ioctl;
+ ops.connect_fn = print_connect;
+ ops.disconnect_fn = print_disconnect;
+ ops.unlink_fn = print_unlink;
+ ops.ioctl_fn = print_ioctl;
/* register ourselves with the NTVFS subsystem. We register under the name 'default'
as we wish to be the default backend */
ZERO_STRUCT(ops);
/* fill in all the operations */
- ops.connect = svfs_connect;
- ops.disconnect = svfs_disconnect;
- ops.unlink = svfs_unlink;
- ops.chkpath = svfs_chkpath;
- ops.qpathinfo = svfs_qpathinfo;
- ops.setpathinfo = svfs_setpathinfo;
- ops.open = svfs_open;
- ops.mkdir = svfs_mkdir;
- ops.rmdir = svfs_rmdir;
- ops.rename = svfs_rename;
- ops.copy = svfs_copy;
- ops.ioctl = svfs_ioctl;
- ops.read = svfs_read;
- ops.write = svfs_write;
- ops.seek = svfs_seek;
- ops.flush = svfs_flush;
- ops.close = svfs_close;
- ops.exit = svfs_exit;
- ops.lock = svfs_lock;
- ops.setfileinfo = svfs_setfileinfo;
- ops.qfileinfo = svfs_qfileinfo;
- ops.fsinfo = svfs_fsinfo;
- ops.lpq = svfs_lpq;
- ops.search_first = svfs_search_first;
- ops.search_next = svfs_search_next;
- ops.search_close = svfs_search_close;
- ops.trans = svfs_trans;
- ops.logoff = svfs_logoff;
- ops.async_setup = svfs_async_setup;
- ops.cancel = svfs_cancel;
+ ops.connect_fn = svfs_connect;
+ ops.disconnect_fn = svfs_disconnect;
+ ops.unlink_fn = svfs_unlink;
+ ops.chkpath_fn = svfs_chkpath;
+ ops.qpathinfo_fn = svfs_qpathinfo;
+ ops.setpathinfo_fn = svfs_setpathinfo;
+ ops.open_fn = svfs_open;
+ ops.mkdir_fn = svfs_mkdir;
+ ops.rmdir_fn = svfs_rmdir;
+ ops.rename_fn = svfs_rename;
+ ops.copy_fn = svfs_copy;
+ ops.ioctl_fn = svfs_ioctl;
+ ops.read_fn = svfs_read;
+ ops.write_fn = svfs_write;
+ ops.seek_fn = svfs_seek;
+ ops.flush_fn = svfs_flush;
+ ops.close_fn = svfs_close;
+ ops.exit_fn = svfs_exit;
+ ops.lock_fn = svfs_lock;
+ ops.setfileinfo_fn = svfs_setfileinfo;
+ ops.qfileinfo_fn = svfs_qfileinfo;
+ ops.fsinfo_fn = svfs_fsinfo;
+ ops.lpq_fn = svfs_lpq;
+ ops.search_first_fn = svfs_search_first;
+ ops.search_next_fn = svfs_search_next;
+ ops.search_close_fn = svfs_search_close;
+ ops.trans_fn = svfs_trans;
+ ops.logoff_fn = svfs_logoff;
+ ops.async_setup_fn = svfs_async_setup;
+ ops.cancel_fn = svfs_cancel;
/* register ourselves with the NTVFS subsystem. We register
under names 'simple'
ops.type = NTVFS_DISK;
/* fill in all the operations */
- ops.connect = cvfs_connect;
- ops.disconnect = cvfs_disconnect;
- ops.unlink = cvfs_unlink;
- ops.chkpath = cvfs_chkpath;
- ops.qpathinfo = cvfs_qpathinfo;
- ops.setpathinfo = cvfs_setpathinfo;
- ops.open = cvfs_open;
- ops.mkdir = cvfs_mkdir;
- ops.rmdir = cvfs_rmdir;
- ops.rename = cvfs_rename;
- ops.copy = cvfs_copy;
- ops.ioctl = cvfs_ioctl;
- ops.read = cvfs_read;
- ops.write = cvfs_write;
- ops.seek = cvfs_seek;
- ops.flush = cvfs_flush;
- ops.close = cvfs_close;
- ops.exit = cvfs_exit;
- ops.lock = cvfs_lock;
- ops.setfileinfo = cvfs_setfileinfo;
- ops.qfileinfo = cvfs_qfileinfo;
- ops.fsinfo = cvfs_fsinfo;
- ops.lpq = cvfs_lpq;
- ops.search_first = cvfs_search_first;
- 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;
- ops.notify = cvfs_notify;
+ ops.connect_fn = cvfs_connect;
+ ops.disconnect_fn = cvfs_disconnect;
+ ops.unlink_fn = cvfs_unlink;
+ ops.chkpath_fn = cvfs_chkpath;
+ ops.qpathinfo_fn = cvfs_qpathinfo;
+ ops.setpathinfo_fn = cvfs_setpathinfo;
+ ops.open_fn = cvfs_open;
+ ops.mkdir_fn = cvfs_mkdir;
+ ops.rmdir_fn = cvfs_rmdir;
+ ops.rename_fn = cvfs_rename;
+ ops.copy_fn = cvfs_copy;
+ ops.ioctl_fn = cvfs_ioctl;
+ ops.read_fn = cvfs_read;
+ ops.write_fn = cvfs_write;
+ ops.seek_fn = cvfs_seek;
+ ops.flush_fn = cvfs_flush;
+ ops.close_fn = cvfs_close;
+ ops.exit_fn = cvfs_exit;
+ ops.lock_fn = cvfs_lock;
+ ops.setfileinfo_fn = cvfs_setfileinfo;
+ ops.qfileinfo_fn = cvfs_qfileinfo;
+ ops.fsinfo_fn = cvfs_fsinfo;
+ ops.lpq_fn = cvfs_lpq;
+ ops.search_first_fn = cvfs_search_first;
+ ops.search_next_fn = cvfs_search_next;
+ ops.search_close_fn = cvfs_search_close;
+ ops.trans_fn = cvfs_trans;
+ ops.logoff_fn = cvfs_logoff;
+ ops.async_setup_fn = cvfs_async_setup;
+ ops.cancel_fn = cvfs_cancel;
+ ops.notify_fn = cvfs_notify;
/* register ourselves with the NTVFS subsystem. We register
under the name 'smb2'. */
ZERO_STRUCT(ops);
/* fill in all the operations */
- ops.connect = unixuid_connect;
- ops.disconnect = unixuid_disconnect;
- ops.unlink = unixuid_unlink;
- ops.chkpath = unixuid_chkpath;
- ops.qpathinfo = unixuid_qpathinfo;
- ops.setpathinfo = unixuid_setpathinfo;
- ops.open = unixuid_open;
- ops.mkdir = unixuid_mkdir;
- ops.rmdir = unixuid_rmdir;
- ops.rename = unixuid_rename;
- ops.copy = unixuid_copy;
- ops.ioctl = unixuid_ioctl;
- ops.read = unixuid_read;
- ops.write = unixuid_write;
- ops.seek = unixuid_seek;
- ops.flush = unixuid_flush;
- ops.close = unixuid_close;
- ops.exit = unixuid_exit;
- ops.lock = unixuid_lock;
- ops.setfileinfo = unixuid_setfileinfo;
- ops.qfileinfo = unixuid_qfileinfo;
- ops.fsinfo = unixuid_fsinfo;
- ops.lpq = unixuid_lpq;
- ops.search_first = unixuid_search_first;
- ops.search_next = unixuid_search_next;
- ops.search_close = unixuid_search_close;
- ops.trans = unixuid_trans;
- ops.logoff = unixuid_logoff;
- ops.async_setup = unixuid_async_setup;
- ops.cancel = unixuid_cancel;
- ops.notify = unixuid_notify;
+ ops.connect_fn = unixuid_connect;
+ ops.disconnect_fn = unixuid_disconnect;
+ ops.unlink_fn = unixuid_unlink;
+ ops.chkpath_fn = unixuid_chkpath;
+ ops.qpathinfo_fn = unixuid_qpathinfo;
+ ops.setpathinfo_fn = unixuid_setpathinfo;
+ ops.open_fn = unixuid_open;
+ ops.mkdir_fn = unixuid_mkdir;
+ ops.rmdir_fn = unixuid_rmdir;
+ ops.rename_fn = unixuid_rename;
+ ops.copy_fn = unixuid_copy;
+ ops.ioctl_fn = unixuid_ioctl;
+ ops.read_fn = unixuid_read;
+ ops.write_fn = unixuid_write;
+ ops.seek_fn = unixuid_seek;
+ ops.flush_fn = unixuid_flush;
+ ops.close_fn = unixuid_close;
+ ops.exit_fn = unixuid_exit;
+ ops.lock_fn = unixuid_lock;
+ ops.setfileinfo_fn = unixuid_setfileinfo;
+ ops.qfileinfo_fn = unixuid_qfileinfo;
+ ops.fsinfo_fn = unixuid_fsinfo;
+ ops.lpq_fn = unixuid_lpq;
+ ops.search_first_fn = unixuid_search_first;
+ ops.search_next_fn = unixuid_search_next;
+ ops.search_close_fn = unixuid_search_close;
+ ops.trans_fn = unixuid_trans;
+ ops.logoff_fn = unixuid_logoff;
+ ops.async_setup_fn = unixuid_async_setup;
+ ops.cancel_fn = unixuid_cancel;
+ ops.notify_fn = unixuid_notify;
ops.name = "unixuid";
git.samba.org / obnox / samba / samba-obnox.git / commitdiff