From 422494a8e630e2ca89386344eaa5346388698a32 Mon Sep 17 00:00:00 2001 From: Richard Sharpe Date: Sat, 3 Dec 2011 20:45:04 -0800 Subject: [PATCH] vfs: Make function pointer names consistent. They all end in _fn Autobuild-User: Richard Sharpe Autobuild-Date: Mon Dec 12 04:58:40 CET 2011 on sn-devel-104 --- examples/VFS/shadow_copy_test.c | 2 +- examples/VFS/skel_opaque.c | 228 +++++------ examples/VFS/skel_transparent.c | 228 +++++------ source3/include/vfs.h | 429 +++++++++++---------- source3/include/vfs_macros.h | 20 +- source3/locking/brlock.c | 9 +- source3/locking/posix.c | 5 +- source3/modules/vfs_acl_tdb.c | 24 +- source3/modules/vfs_acl_xattr.c | 22 +- source3/modules/vfs_afsacl.c | 6 +- source3/modules/vfs_aio_fork.c | 8 +- source3/modules/vfs_aixacl.c | 10 +- source3/modules/vfs_aixacl2.c | 16 +- source3/modules/vfs_audit.c | 20 +- source3/modules/vfs_cacheprime.c | 8 +- source3/modules/vfs_cap.c | 68 ++-- source3/modules/vfs_catia.c | 58 +-- source3/modules/vfs_crossrename.c | 2 +- source3/modules/vfs_default.c | 226 +++++------ source3/modules/vfs_default_quota.c | 4 +- source3/modules/vfs_dfs_samba4.c | 4 +- source3/modules/vfs_dirsort.c | 12 +- source3/modules/vfs_expand_msdfs.c | 2 +- source3/modules/vfs_extd_audit.c | 20 +- source3/modules/vfs_fake_perms.c | 4 +- source3/modules/vfs_fileid.c | 4 +- source3/modules/vfs_full_audit.c | 220 +++++------ source3/modules/vfs_gpfs_hsm_notify.c | 4 +- source3/modules/vfs_hpuxacl.c | 10 +- source3/modules/vfs_irixacl.c | 10 +- source3/modules/vfs_linux_xfs_sgid.c | 4 +- source3/modules/vfs_netatalk.c | 16 +- source3/modules/vfs_notify_fam.c | 2 +- source3/modules/vfs_onefs.c | 64 +-- source3/modules/vfs_onefs_shadow_copy.c | 80 ++-- source3/modules/vfs_posixacl.c | 10 +- source3/modules/vfs_prealloc.c | 2 +- source3/modules/vfs_readahead.c | 4 +- source3/modules/vfs_recycle.c | 2 +- source3/modules/vfs_scannedonly.c | 24 +- source3/modules/vfs_shadow_copy.c | 16 +- source3/modules/vfs_shadow_copy2.c | 60 +-- source3/modules/vfs_smb_traffic_analyzer.c | 22 +- source3/modules/vfs_solarisacl.c | 10 +- source3/modules/vfs_streams_depot.c | 12 +- source3/modules/vfs_streams_xattr.c | 22 +- source3/modules/vfs_syncops.c | 16 +- source3/modules/vfs_time_audit.c | 216 +++++------ source3/modules/vfs_tru64acl.c | 10 +- source3/modules/vfs_tsmsm.c | 14 +- source3/modules/vfs_xattr_tdb.c | 20 +- source3/modules/vfs_zfsacl.c | 16 +- source3/smbd/vfs.c | 277 ++++++------- 53 files changed, 1305 insertions(+), 1297 deletions(-) diff --git a/examples/VFS/shadow_copy_test.c b/examples/VFS/shadow_copy_test.c index a47d2ee19b4..0efceb42340 100644 --- a/examples/VFS/shadow_copy_test.c +++ b/examples/VFS/shadow_copy_test.c @@ -81,7 +81,7 @@ static int test_get_shadow_copy_data(vfs_handle_struct *handle, /* VFS operations structure */ static struct vfs_fn_pointers vfs_test_shadow_copy_fns = { - .get_shadow_copy_data = test_get_shadow_copy_data + .get_shadow_copy_data_fn = test_get_shadow_copy_data }; NTSTATUS vfs_shadow_copy_test_init(void) diff --git a/examples/VFS/skel_opaque.c b/examples/VFS/skel_opaque.c index 7c63dd2eb56..ae42d1c2089 100644 --- a/examples/VFS/skel_opaque.c +++ b/examples/VFS/skel_opaque.c @@ -799,142 +799,142 @@ struct vfs_fn_pointers skel_opaque_fns = { /* Disk operations */ .connect_fn = skel_connect, - .disconnect = skel_disconnect, - .disk_free = skel_disk_free, - .get_quota = skel_get_quota, - .set_quota = skel_set_quota, - .get_shadow_copy_data = skel_get_shadow_copy_data, - .statvfs = skel_statvfs, - .fs_capabilities = skel_fs_capabilities, - .get_dfs_referrals = skel_get_dfs_referrals, + .disconnect_fn = skel_disconnect, + .disk_free_fn = skel_disk_free, + .get_quota_fn = skel_get_quota, + .set_quota_fn = skel_set_quota, + .get_shadow_copy_data_fn = skel_get_shadow_copy_data, + .statvfs_fn = skel_statvfs, + .fs_capabilities_fn = skel_fs_capabilities, + .get_dfs_referrals_fn = skel_get_dfs_referrals, /* Directory operations */ - .opendir = skel_opendir, - .fdopendir = skel_fdopendir, - .readdir = skel_readdir, - .seekdir = skel_seekdir, - .telldir = skel_telldir, - .rewind_dir = skel_rewind_dir, - .mkdir = skel_mkdir, - .rmdir = skel_rmdir, - .closedir = skel_closedir, - .init_search_op = skel_init_search_op, + .opendir_fn = skel_opendir, + .fdopendir_fn = skel_fdopendir, + .readdir_fn = skel_readdir, + .seekdir_fn = skel_seekdir, + .telldir_fn = skel_telldir, + .rewind_dir_fn = skel_rewind_dir, + .mkdir_fn = skel_mkdir, + .rmdir_fn = skel_rmdir, + .closedir_fn = skel_closedir, + .init_search_op_fn = skel_init_search_op, /* File operations */ .open_fn = skel_open, - .create_file = skel_create_file, + .create_file_fn = skel_create_file, .close_fn = skel_close_fn, - .vfs_read = skel_vfs_read, - .pread = skel_pread, - .write = skel_write, - .pwrite = skel_pwrite, - .lseek = skel_lseek, - .sendfile = skel_sendfile, - .recvfile = skel_recvfile, - .rename = skel_rename, - .fsync = skel_fsync, - .stat = skel_stat, - .fstat = skel_fstat, - .lstat = skel_lstat, - .get_alloc_size = skel_get_alloc_size, - .unlink = skel_unlink, - .chmod = skel_chmod, - .fchmod = skel_fchmod, - .chown = skel_chown, - .fchown = skel_fchown, - .lchown = skel_lchown, - .chdir = skel_chdir, - .getwd = skel_getwd, - .ntimes = skel_ntimes, - .ftruncate = skel_ftruncate, - .fallocate = skel_fallocate, - .lock = skel_lock, - .kernel_flock = skel_kernel_flock, - .linux_setlease = skel_linux_setlease, - .getlock = skel_getlock, - .symlink = skel_symlink, - .vfs_readlink = skel_vfs_readlink, - .link = skel_link, - .mknod = skel_mknod, - .realpath = skel_realpath, - .notify_watch = skel_notify_watch, - .chflags = skel_chflags, - .file_id_create = skel_file_id_create, - - .streaminfo = skel_streaminfo, - .get_real_filename = skel_get_real_filename, - .connectpath = skel_connectpath, - .brl_lock_windows = skel_brl_lock_windows, - .brl_unlock_windows = skel_brl_unlock_windows, - .brl_cancel_windows = skel_brl_cancel_windows, - .strict_lock = skel_strict_lock, - .strict_unlock = skel_strict_unlock, - .translate_name = skel_translate_name, - .fsctl = skel_fsctl, + .read_fn = skel_vfs_read, + .pread_fn = skel_pread, + .write_fn = skel_write, + .pwrite_fn = skel_pwrite, + .lseek_fn = skel_lseek, + .sendfile_fn = skel_sendfile, + .recvfile_fn = skel_recvfile, + .rename_fn = skel_rename, + .fsync_fn = skel_fsync, + .stat_fn = skel_stat, + .fstat_fn = skel_fstat, + .lstat_fn = skel_lstat, + .get_alloc_size_fn = skel_get_alloc_size, + .unlink_fn = skel_unlink, + .chmod_fn = skel_chmod, + .fchmod_fn = skel_fchmod, + .chown_fn = skel_chown, + .fchown_fn = skel_fchown, + .lchown_fn = skel_lchown, + .chdir_fn = skel_chdir, + .getwd_fn = skel_getwd, + .ntimes_fn = skel_ntimes, + .ftruncate_fn = skel_ftruncate, + .fallocate_fn = skel_fallocate, + .lock_fn = skel_lock, + .kernel_flock_fn = skel_kernel_flock, + .linux_setlease_fn = skel_linux_setlease, + .getlock_fn = skel_getlock, + .symlink_fn = skel_symlink, + .readlink_fn = skel_vfs_readlink, + .link_fn = skel_link, + .mknod_fn = skel_mknod, + .realpath_fn = skel_realpath, + .notify_watch_fn = skel_notify_watch, + .chflags_fn = skel_chflags, + .file_id_create_fn = skel_file_id_create, + + .streaminfo_fn = skel_streaminfo, + .get_real_filename_fn = skel_get_real_filename, + .connectpath_fn = skel_connectpath, + .brl_lock_windows_fn = skel_brl_lock_windows, + .brl_unlock_windows_fn = skel_brl_unlock_windows, + .brl_cancel_windows_fn = skel_brl_cancel_windows, + .strict_lock_fn = skel_strict_lock, + .strict_unlock_fn = skel_strict_unlock, + .translate_name_fn = skel_translate_name, + .fsctl_fn = skel_fsctl, /* NT ACL operations. */ - .fget_nt_acl = skel_fget_nt_acl, - .get_nt_acl = skel_get_nt_acl, - .fset_nt_acl = skel_fset_nt_acl, + .fget_nt_acl_fn = skel_fget_nt_acl, + .get_nt_acl_fn = skel_get_nt_acl, + .fset_nt_acl_fn = skel_fset_nt_acl, /* POSIX ACL operations. */ - .chmod_acl = skel_chmod_acl, - .fchmod_acl = skel_fchmod_acl, - - .sys_acl_get_entry = skel_sys_acl_get_entry, - .sys_acl_get_tag_type = skel_sys_acl_get_tag_type, - .sys_acl_get_permset = skel_sys_acl_get_permset, - .sys_acl_get_qualifier = skel_sys_acl_get_qualifier, - .sys_acl_get_file = skel_sys_acl_get_file, - .sys_acl_get_fd = skel_sys_acl_get_fd, - .sys_acl_clear_perms = skel_sys_acl_clear_perms, - .sys_acl_add_perm = skel_sys_acl_add_perm, - .sys_acl_to_text = skel_sys_acl_to_text, - .sys_acl_init = skel_sys_acl_init, - .sys_acl_create_entry = skel_sys_acl_create_entry, - .sys_acl_set_tag_type = skel_sys_acl_set_tag_type, - .sys_acl_set_qualifier = skel_sys_acl_set_qualifier, - .sys_acl_set_permset = skel_sys_acl_set_permset, - .sys_acl_valid = skel_sys_acl_valid, - .sys_acl_set_file = skel_sys_acl_set_file, - .sys_acl_set_fd = skel_sys_acl_set_fd, - .sys_acl_delete_def_file = skel_sys_acl_delete_def_file, - .sys_acl_get_perm = skel_sys_acl_get_perm, - .sys_acl_free_text = skel_sys_acl_free_text, - .sys_acl_free_acl = skel_sys_acl_free_acl, - .sys_acl_free_qualifier = skel_sys_acl_free_qualifier, + .chmod_acl_fn = skel_chmod_acl, + .fchmod_acl_fn = skel_fchmod_acl, + + .sys_acl_get_entry_fn = skel_sys_acl_get_entry, + .sys_acl_get_tag_type_fn = skel_sys_acl_get_tag_type, + .sys_acl_get_permset_fn = skel_sys_acl_get_permset, + .sys_acl_get_qualifier_fn = skel_sys_acl_get_qualifier, + .sys_acl_get_file_fn = skel_sys_acl_get_file, + .sys_acl_get_fd_fn = skel_sys_acl_get_fd, + .sys_acl_clear_perms_fn = skel_sys_acl_clear_perms, + .sys_acl_add_perm_fn = skel_sys_acl_add_perm, + .sys_acl_to_text_fn = skel_sys_acl_to_text, + .sys_acl_init_fn = skel_sys_acl_init, + .sys_acl_create_entry_fn = skel_sys_acl_create_entry, + .sys_acl_set_tag_type_fn = skel_sys_acl_set_tag_type, + .sys_acl_set_qualifier_fn = skel_sys_acl_set_qualifier, + .sys_acl_set_permset_fn = skel_sys_acl_set_permset, + .sys_acl_valid_fn = skel_sys_acl_valid, + .sys_acl_set_file_fn = skel_sys_acl_set_file, + .sys_acl_set_fd_fn = skel_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file, + .sys_acl_get_perm_fn = skel_sys_acl_get_perm, + .sys_acl_free_text_fn = skel_sys_acl_free_text, + .sys_acl_free_acl_fn = skel_sys_acl_free_acl, + .sys_acl_free_qualifier_fn = skel_sys_acl_free_qualifier, /* EA operations. */ - .getxattr = skel_getxattr, - .lgetxattr = skel_lgetxattr, - .fgetxattr = skel_fgetxattr, - .listxattr = skel_listxattr, - .llistxattr = skel_llistxattr, - .flistxattr = skel_flistxattr, - .removexattr = skel_removexattr, - .lremovexattr = skel_lremovexattr, - .fremovexattr = skel_fremovexattr, - .setxattr = skel_setxattr, - .lsetxattr = skel_lsetxattr, - .fsetxattr = skel_fsetxattr, + .getxattr_fn = skel_getxattr, + .lgetxattr_fn = skel_lgetxattr, + .fgetxattr_fn = skel_fgetxattr, + .listxattr_fn = skel_listxattr, + .llistxattr_fn = skel_llistxattr, + .flistxattr_fn = skel_flistxattr, + .removexattr_fn = skel_removexattr, + .lremovexattr_fn = skel_lremovexattr, + .fremovexattr_fn = skel_fremovexattr, + .setxattr_fn = skel_setxattr, + .lsetxattr_fn = skel_lsetxattr, + .fsetxattr_fn = skel_fsetxattr, /* aio operations */ - .aio_read = skel_aio_read, - .aio_write = skel_aio_write, + .aio_read_fn = skel_aio_read, + .aio_write_fn = skel_aio_write, .aio_return_fn = skel_aio_return_fn, - .aio_cancel = skel_aio_cancel, + .aio_cancel_fn = skel_aio_cancel, .aio_error_fn = skel_aio_error_fn, - .aio_fsync = skel_aio_fsync, - .aio_suspend = skel_aio_suspend, - .aio_force = skel_aio_force, + .aio_fsync_fn = skel_aio_fsync, + .aio_suspend_fn = skel_aio_suspend, + .aio_force_fn = skel_aio_force, /* offline operations */ - .is_offline = skel_is_offline, - .set_offline = skel_set_offline + .is_offline_fn = skel_is_offline, + .set_offline_fn = skel_set_offline }; NTSTATUS vfs_skel_opaque_init(void) diff --git a/examples/VFS/skel_transparent.c b/examples/VFS/skel_transparent.c index 4804d93322a..85079b40c93 100644 --- a/examples/VFS/skel_transparent.c +++ b/examples/VFS/skel_transparent.c @@ -752,142 +752,142 @@ struct vfs_fn_pointers skel_transparent_fns = { /* Disk operations */ .connect_fn = skel_connect, - .disconnect = skel_disconnect, - .disk_free = skel_disk_free, - .get_quota = skel_get_quota, - .set_quota = skel_set_quota, - .get_shadow_copy_data = skel_get_shadow_copy_data, - .statvfs = skel_statvfs, - .fs_capabilities = skel_fs_capabilities, - .get_dfs_referrals = skel_get_dfs_referrals, + .disconnect_fn = skel_disconnect, + .disk_free_fn = skel_disk_free, + .get_quota_fn = skel_get_quota, + .set_quota_fn = skel_set_quota, + .get_shadow_copy_data_fn = skel_get_shadow_copy_data, + .statvfs_fn = skel_statvfs, + .fs_capabilities_fn = skel_fs_capabilities, + .get_dfs_referrals_fn = skel_get_dfs_referrals, /* Directory operations */ - .opendir = skel_opendir, - .fdopendir = skel_fdopendir, - .readdir = skel_readdir, - .seekdir = skel_seekdir, - .telldir = skel_telldir, - .rewind_dir = skel_rewind_dir, - .mkdir = skel_mkdir, - .rmdir = skel_rmdir, - .closedir = skel_closedir, - .init_search_op = skel_init_search_op, + .opendir_fn = skel_opendir, + .fdopendir_fn = skel_fdopendir, + .readdir_fn = skel_readdir, + .seekdir_fn = skel_seekdir, + .telldir_fn = skel_telldir, + .rewind_dir_fn = skel_rewind_dir, + .mkdir_fn = skel_mkdir, + .rmdir_fn = skel_rmdir, + .closedir_fn = skel_closedir, + .init_search_op_fn = skel_init_search_op, /* File operations */ .open_fn = skel_open, - .create_file = skel_create_file, + .create_file_fn = skel_create_file, .close_fn = skel_close_fn, - .vfs_read = skel_vfs_read, - .pread = skel_pread, - .write = skel_write, - .pwrite = skel_pwrite, - .lseek = skel_lseek, - .sendfile = skel_sendfile, - .recvfile = skel_recvfile, - .rename = skel_rename, - .fsync = skel_fsync, - .stat = skel_stat, - .fstat = skel_fstat, - .lstat = skel_lstat, - .get_alloc_size = skel_get_alloc_size, - .unlink = skel_unlink, - .chmod = skel_chmod, - .fchmod = skel_fchmod, - .chown = skel_chown, - .fchown = skel_fchown, - .lchown = skel_lchown, - .chdir = skel_chdir, - .getwd = skel_getwd, - .ntimes = skel_ntimes, - .ftruncate = skel_ftruncate, - .fallocate = skel_fallocate, - .lock = skel_lock, - .kernel_flock = skel_kernel_flock, - .linux_setlease = skel_linux_setlease, - .getlock = skel_getlock, - .symlink = skel_symlink, - .vfs_readlink = skel_vfs_readlink, - .link = skel_link, - .mknod = skel_mknod, - .realpath = skel_realpath, - .notify_watch = skel_notify_watch, - .chflags = skel_chflags, - .file_id_create = skel_file_id_create, - - .streaminfo = skel_streaminfo, - .get_real_filename = skel_get_real_filename, - .connectpath = skel_connectpath, - .brl_lock_windows = skel_brl_lock_windows, - .brl_unlock_windows = skel_brl_unlock_windows, - .brl_cancel_windows = skel_brl_cancel_windows, - .strict_lock = skel_strict_lock, - .strict_unlock = skel_strict_unlock, - .translate_name = skel_translate_name, - .fsctl = skel_fsctl, + .read_fn = skel_vfs_read, + .pread_fn = skel_pread, + .write_fn = skel_write, + .pwrite_fn = skel_pwrite, + .lseek_fn = skel_lseek, + .sendfile_fn = skel_sendfile, + .recvfile_fn = skel_recvfile, + .rename_fn = skel_rename, + .fsync_fn = skel_fsync, + .stat_fn = skel_stat, + .fstat_fn = skel_fstat, + .lstat_fn = skel_lstat, + .get_alloc_size_fn = skel_get_alloc_size, + .unlink_fn = skel_unlink, + .chmod_fn = skel_chmod, + .fchmod_fn = skel_fchmod, + .chown_fn = skel_chown, + .fchown_fn = skel_fchown, + .lchown_fn = skel_lchown, + .chdir_fn = skel_chdir, + .getwd_fn = skel_getwd, + .ntimes_fn = skel_ntimes, + .ftruncate_fn = skel_ftruncate, + .fallocate_fn = skel_fallocate, + .lock_fn = skel_lock, + .kernel_flock_fn = skel_kernel_flock, + .linux_setlease_fn = skel_linux_setlease, + .getlock_fn = skel_getlock, + .symlink_fn = skel_symlink, + .readlink_fn = skel_vfs_readlink, + .link_fn = skel_link, + .mknod_fn = skel_mknod, + .realpath_fn = skel_realpath, + .notify_watch_fn = skel_notify_watch, + .chflags_fn = skel_chflags, + .file_id_create_fn = skel_file_id_create, + + .streaminfo_fn = skel_streaminfo, + .get_real_filename_fn = skel_get_real_filename, + .connectpath_fn = skel_connectpath, + .brl_lock_windows_fn = skel_brl_lock_windows, + .brl_unlock_windows_fn = skel_brl_unlock_windows, + .brl_cancel_windows_fn = skel_brl_cancel_windows, + .strict_lock_fn = skel_strict_lock, + .strict_unlock_fn = skel_strict_unlock, + .translate_name_fn = skel_translate_name, + .fsctl_fn = skel_fsctl, /* NT ACL operations. */ - .fget_nt_acl = skel_fget_nt_acl, - .get_nt_acl = skel_get_nt_acl, - .fset_nt_acl = skel_fset_nt_acl, + .fget_nt_acl_fn = skel_fget_nt_acl, + .get_nt_acl_fn = skel_get_nt_acl, + .fset_nt_acl_fn = skel_fset_nt_acl, /* POSIX ACL operations. */ - .chmod_acl = skel_chmod_acl, - .fchmod_acl = skel_fchmod_acl, - - .sys_acl_get_entry = skel_sys_acl_get_entry, - .sys_acl_get_tag_type = skel_sys_acl_get_tag_type, - .sys_acl_get_permset = skel_sys_acl_get_permset, - .sys_acl_get_qualifier = skel_sys_acl_get_qualifier, - .sys_acl_get_file = skel_sys_acl_get_file, - .sys_acl_get_fd = skel_sys_acl_get_fd, - .sys_acl_clear_perms = skel_sys_acl_clear_perms, - .sys_acl_add_perm = skel_sys_acl_add_perm, - .sys_acl_to_text = skel_sys_acl_to_text, - .sys_acl_init = skel_sys_acl_init, - .sys_acl_create_entry = skel_sys_acl_create_entry, - .sys_acl_set_tag_type = skel_sys_acl_set_tag_type, - .sys_acl_set_qualifier = skel_sys_acl_set_qualifier, - .sys_acl_set_permset = skel_sys_acl_set_permset, - .sys_acl_valid = skel_sys_acl_valid, - .sys_acl_set_file = skel_sys_acl_set_file, - .sys_acl_set_fd = skel_sys_acl_set_fd, - .sys_acl_delete_def_file = skel_sys_acl_delete_def_file, - .sys_acl_get_perm = skel_sys_acl_get_perm, - .sys_acl_free_text = skel_sys_acl_free_text, - .sys_acl_free_acl = skel_sys_acl_free_acl, - .sys_acl_free_qualifier = skel_sys_acl_free_qualifier, + .chmod_acl_fn = skel_chmod_acl, + .fchmod_acl_fn = skel_fchmod_acl, + + .sys_acl_get_entry_fn = skel_sys_acl_get_entry, + .sys_acl_get_tag_type_fn = skel_sys_acl_get_tag_type, + .sys_acl_get_permset_fn = skel_sys_acl_get_permset, + .sys_acl_get_qualifier_fn = skel_sys_acl_get_qualifier, + .sys_acl_get_file_fn = skel_sys_acl_get_file, + .sys_acl_get_fd_fn = skel_sys_acl_get_fd, + .sys_acl_clear_perms_fn = skel_sys_acl_clear_perms, + .sys_acl_add_perm_fn = skel_sys_acl_add_perm, + .sys_acl_to_text_fn = skel_sys_acl_to_text, + .sys_acl_init_fn = skel_sys_acl_init, + .sys_acl_create_entry_fn = skel_sys_acl_create_entry, + .sys_acl_set_tag_type_fn = skel_sys_acl_set_tag_type, + .sys_acl_set_qualifier_fn = skel_sys_acl_set_qualifier, + .sys_acl_set_permset_fn = skel_sys_acl_set_permset, + .sys_acl_valid_fn = skel_sys_acl_valid, + .sys_acl_set_file_fn = skel_sys_acl_set_file, + .sys_acl_set_fd_fn = skel_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file, + .sys_acl_get_perm_fn = skel_sys_acl_get_perm, + .sys_acl_free_text_fn = skel_sys_acl_free_text, + .sys_acl_free_acl_fn = skel_sys_acl_free_acl, + .sys_acl_free_qualifier_fn = skel_sys_acl_free_qualifier, /* EA operations. */ - .getxattr = skel_getxattr, - .lgetxattr = skel_lgetxattr, - .fgetxattr = skel_fgetxattr, - .listxattr = skel_listxattr, - .llistxattr = skel_llistxattr, - .flistxattr = skel_flistxattr, - .removexattr = skel_removexattr, - .lremovexattr = skel_lremovexattr, - .fremovexattr = skel_fremovexattr, - .setxattr = skel_setxattr, - .lsetxattr = skel_lsetxattr, - .fsetxattr = skel_fsetxattr, + .getxattr_fn = skel_getxattr, + .lgetxattr_fn = skel_lgetxattr, + .fgetxattr_fn = skel_fgetxattr, + .listxattr_fn = skel_listxattr, + .llistxattr_fn = skel_llistxattr, + .flistxattr_fn = skel_flistxattr, + .removexattr_fn = skel_removexattr, + .lremovexattr_fn = skel_lremovexattr, + .fremovexattr_fn = skel_fremovexattr, + .setxattr_fn = skel_setxattr, + .lsetxattr_fn = skel_lsetxattr, + .fsetxattr_fn = skel_fsetxattr, /* aio operations */ - .aio_read = skel_aio_read, - .aio_write = skel_aio_write, + .aio_read_fn = skel_aio_read, + .aio_write_fn = skel_aio_write, .aio_return_fn = skel_aio_return_fn, - .aio_cancel = skel_aio_cancel, + .aio_cancel_fn = skel_aio_cancel, .aio_error_fn = skel_aio_error_fn, - .aio_fsync = skel_aio_fsync, - .aio_suspend = skel_aio_suspend, - .aio_force = skel_aio_force, + .aio_fsync_fn = skel_aio_fsync, + .aio_suspend_fn = skel_aio_suspend, + .aio_force_fn = skel_aio_force, /* offline operations */ - .is_offline = skel_is_offline, - .set_offline = skel_set_offline + .is_offline_fn = skel_is_offline, + .set_offline_fn = skel_set_offline }; NTSTATUS vfs_skel_transparent_init(void) diff --git a/source3/include/vfs.h b/source3/include/vfs.h index 4559b351bc6..62f9d101297 100644 --- a/source3/include/vfs.h +++ b/source3/include/vfs.h @@ -160,7 +160,7 @@ struct blocking_lock_record; struct smb_filename; struct dfs_GetDFSReferral; -#define VFS_FIND(__fn__) while (handle->fns->__fn__==NULL) { \ +#define VFS_FIND(__fn__) while (handle->fns->__fn__##_fn==NULL) { \ handle = handle->next; \ } @@ -186,242 +186,243 @@ struct vfs_fn_pointers { /* Disk operations */ int (*connect_fn)(struct vfs_handle_struct *handle, const char *service, const char *user); - void (*disconnect)(struct vfs_handle_struct *handle); - uint64_t (*disk_free)(struct vfs_handle_struct *handle, const char *path, bool small_query, uint64_t *bsize, + void (*disconnect_fn)(struct vfs_handle_struct *handle); + uint64_t (*disk_free_fn)(struct vfs_handle_struct *handle, const char *path, bool small_query, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize); - int (*get_quota)(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt); - int (*set_quota)(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt); - int (*get_shadow_copy_data)(struct vfs_handle_struct *handle, struct files_struct *fsp, struct shadow_copy_data *shadow_copy_data, bool labels); - int (*statvfs)(struct vfs_handle_struct *handle, const char *path, struct vfs_statvfs_struct *statbuf); - uint32_t (*fs_capabilities)(struct vfs_handle_struct *handle, enum timestamp_set_resolution *p_ts_res); + int (*get_quota_fn)(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt); + int (*set_quota_fn)(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt); + int (*get_shadow_copy_data_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, struct shadow_copy_data *shadow_copy_data, bool labels); + int (*statvfs_fn)(struct vfs_handle_struct *handle, const char *path, struct vfs_statvfs_struct *statbuf); + uint32_t (*fs_capabilities_fn)(struct vfs_handle_struct *handle, enum timestamp_set_resolution *p_ts_res); /* * Note: that "struct dfs_GetDFSReferral *r" * needs to be a valid TALLOC_CTX */ - NTSTATUS (*get_dfs_referrals)(struct vfs_handle_struct *handle, - struct dfs_GetDFSReferral *r); + NTSTATUS (*get_dfs_referrals_fn)(struct vfs_handle_struct *handle, + struct dfs_GetDFSReferral *r); /* Directory operations */ - SMB_STRUCT_DIR *(*opendir)(struct vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attributes); - SMB_STRUCT_DIR *(*fdopendir)(struct vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attributes); - SMB_STRUCT_DIRENT *(*readdir)(struct vfs_handle_struct *handle, - SMB_STRUCT_DIR *dirp, - SMB_STRUCT_STAT *sbuf); - void (*seekdir)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset); - long (*telldir)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); - void (*rewind_dir)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); - int (*mkdir)(struct vfs_handle_struct *handle, const char *path, mode_t mode); - int (*rmdir)(struct vfs_handle_struct *handle, const char *path); - int (*closedir)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dir); - void (*init_search_op)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); + SMB_STRUCT_DIR *(*opendir_fn)(struct vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attributes); + SMB_STRUCT_DIR *(*fdopendir_fn)(struct vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attributes); + SMB_STRUCT_DIRENT *(*readdir_fn)(struct vfs_handle_struct *handle, + SMB_STRUCT_DIR *dirp, + SMB_STRUCT_STAT *sbuf); + void (*seekdir_fn)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset); + long (*telldir_fn)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); + void (*rewind_dir_fn)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); + int (*mkdir_fn)(struct vfs_handle_struct *handle, const char *path, mode_t mode); + int (*rmdir_fn)(struct vfs_handle_struct *handle, const char *path); + int (*closedir_fn)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dir); + void (*init_search_op_fn)(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp); /* File operations */ int (*open_fn)(struct vfs_handle_struct *handle, struct smb_filename *smb_fname, files_struct *fsp, int flags, mode_t mode); - NTSTATUS (*create_file)(struct vfs_handle_struct *handle, - struct smb_request *req, - uint16_t root_dir_fid, - struct smb_filename *smb_fname, - uint32_t access_mask, - uint32_t share_access, - uint32_t create_disposition, - uint32_t create_options, - uint32_t file_attributes, - uint32_t oplock_request, - uint64_t allocation_size, - uint32_t private_flags, - struct security_descriptor *sd, - struct ea_list *ea_list, - files_struct **result, - int *pinfo); + NTSTATUS (*create_file_fn)(struct vfs_handle_struct *handle, + struct smb_request *req, + uint16_t root_dir_fid, + struct smb_filename *smb_fname, + uint32_t access_mask, + uint32_t share_access, + uint32_t create_disposition, + uint32_t create_options, + uint32_t file_attributes, + uint32_t oplock_request, + uint64_t allocation_size, + uint32_t private_flags, + struct security_descriptor *sd, + struct ea_list *ea_list, + files_struct **result, + int *pinfo); int (*close_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp); - ssize_t (*vfs_read)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n); - ssize_t (*pread)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n, SMB_OFF_T offset); - ssize_t (*write)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n); - ssize_t (*pwrite)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset); - SMB_OFF_T (*lseek)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset, int whence); - ssize_t (*sendfile)(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *header, SMB_OFF_T offset, size_t count); - ssize_t (*recvfile)(struct vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t count); - int (*rename)(struct vfs_handle_struct *handle, - const struct smb_filename *smb_fname_src, - const struct smb_filename *smb_fname_dst); - int (*fsync)(struct vfs_handle_struct *handle, struct files_struct *fsp); - int (*stat)(struct vfs_handle_struct *handle, struct smb_filename *smb_fname); - int (*fstat)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_STAT *sbuf); - int (*lstat)(struct vfs_handle_struct *handle, struct smb_filename *smb_filename); - uint64_t (*get_alloc_size)(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf); - int (*unlink)(struct vfs_handle_struct *handle, - const struct smb_filename *smb_fname); - int (*chmod)(struct vfs_handle_struct *handle, const char *path, mode_t mode); - int (*fchmod)(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode); - int (*chown)(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid); - int (*fchown)(struct vfs_handle_struct *handle, struct files_struct *fsp, uid_t uid, gid_t gid); - int (*lchown)(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid); - int (*chdir)(struct vfs_handle_struct *handle, const char *path); - char *(*getwd)(struct vfs_handle_struct *handle); - int (*ntimes)(struct vfs_handle_struct *handle, - const struct smb_filename *smb_fname, - struct smb_file_time *ft); - int (*ftruncate)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset); - int (*fallocate)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - enum vfs_fallocate_mode mode, - SMB_OFF_T offset, - SMB_OFF_T len); - bool (*lock)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type); - int (*kernel_flock)(struct vfs_handle_struct *handle, struct files_struct *fsp, - uint32 share_mode, uint32_t access_mask); - int (*linux_setlease)(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype); - bool (*getlock)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid); - int (*symlink)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); - int (*vfs_readlink)(struct vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz); - int (*link)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); - int (*mknod)(struct vfs_handle_struct *handle, const char *path, mode_t mode, SMB_DEV_T dev); - char *(*realpath)(struct vfs_handle_struct *handle, const char *path); - NTSTATUS (*notify_watch)(struct vfs_handle_struct *handle, - struct sys_notify_context *ctx, - struct notify_entry *e, - void (*callback)(struct sys_notify_context *ctx, - void *private_data, - struct notify_event *ev), - void *private_data, void *handle_p); - int (*chflags)(struct vfs_handle_struct *handle, const char *path, unsigned int flags); - struct file_id (*file_id_create)(struct vfs_handle_struct *handle, - const SMB_STRUCT_STAT *sbuf); - - NTSTATUS (*streaminfo)(struct vfs_handle_struct *handle, + ssize_t (*read_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n); + ssize_t (*pread_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n, SMB_OFF_T offset); + ssize_t (*write_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n); + ssize_t (*pwrite_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset); + SMB_OFF_T (*lseek_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset, int whence); + ssize_t (*sendfile_fn)(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *header, SMB_OFF_T offset, size_t count); + ssize_t (*recvfile_fn)(struct vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t count); + int (*rename_fn)(struct vfs_handle_struct *handle, + const struct smb_filename *smb_fname_src, + const struct smb_filename *smb_fname_dst); + int (*fsync_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp); + int (*stat_fn)(struct vfs_handle_struct *handle, struct smb_filename *smb_fname); + int (*fstat_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_STAT *sbuf); + int (*lstat_fn)(struct vfs_handle_struct *handle, struct smb_filename *smb_filename); + uint64_t (*get_alloc_size_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf); + int (*unlink_fn)(struct vfs_handle_struct *handle, + const struct smb_filename *smb_fname); + int (*chmod_fn)(struct vfs_handle_struct *handle, const char *path, mode_t mode); + int (*fchmod_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode); + int (*chown_fn)(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid); + int (*fchown_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, uid_t uid, gid_t gid); + int (*lchown_fn)(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid); + int (*chdir_fn)(struct vfs_handle_struct *handle, const char *path); + char *(*getwd_fn)(struct vfs_handle_struct *handle); + int (*ntimes_fn)(struct vfs_handle_struct *handle, + const struct smb_filename *smb_fname, + struct smb_file_time *ft); + int (*ftruncate_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset); + int (*fallocate_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + enum vfs_fallocate_mode mode, + SMB_OFF_T offset, + SMB_OFF_T len); + bool (*lock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type); + int (*kernel_flock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, + uint32 share_mode, uint32_t access_mask); + int (*linux_setlease_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype); + bool (*getlock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid); + int (*symlink_fn)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); + int (*readlink_fn)(struct vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz); + int (*link_fn)(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); + int (*mknod_fn)(struct vfs_handle_struct *handle, const char *path, mode_t mode, SMB_DEV_T dev); + char *(*realpath_fn)(struct vfs_handle_struct *handle, const char *path); + NTSTATUS (*notify_watch_fn)(struct vfs_handle_struct *handle, + struct sys_notify_context *ctx, + struct notify_entry *e, + void (*callback)(struct sys_notify_context *ctx, + void *private_data, + struct notify_event *ev), + void *private_data, + void *handle_p); + int (*chflags_fn)(struct vfs_handle_struct *handle, const char *path, unsigned int flags); + struct file_id (*file_id_create_fn)(struct vfs_handle_struct *handle, + const SMB_STRUCT_STAT *sbuf); + + NTSTATUS (*streaminfo_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + const char *fname, + TALLOC_CTX *mem_ctx, + unsigned int *num_streams, + struct stream_struct **streams); + + int (*get_real_filename_fn)(struct vfs_handle_struct *handle, + const char *path, + const char *name, + TALLOC_CTX *mem_ctx, + char **found_name); + + const char *(*connectpath_fn)(struct vfs_handle_struct *handle, + const char *filename); + + NTSTATUS (*brl_lock_windows_fn)(struct vfs_handle_struct *handle, + struct byte_range_lock *br_lck, + struct lock_struct *plock, + bool blocking_lock, + struct blocking_lock_record *blr); + + bool (*brl_unlock_windows_fn)(struct vfs_handle_struct *handle, + struct messaging_context *msg_ctx, + struct byte_range_lock *br_lck, + const struct lock_struct *plock); + + bool (*brl_cancel_windows_fn)(struct vfs_handle_struct *handle, + struct byte_range_lock *br_lck, + struct lock_struct *plock, + struct blocking_lock_record *blr); + + bool (*strict_lock_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, - const char *fname, - TALLOC_CTX *mem_ctx, - unsigned int *num_streams, - struct stream_struct **streams); - - int (*get_real_filename)(struct vfs_handle_struct *handle, - const char *path, - const char *name, - TALLOC_CTX *mem_ctx, - char **found_name); + struct lock_struct *plock); - const char *(*connectpath)(struct vfs_handle_struct *handle, - const char *filename); - - NTSTATUS (*brl_lock_windows)(struct vfs_handle_struct *handle, - struct byte_range_lock *br_lck, - struct lock_struct *plock, - bool blocking_lock, - struct blocking_lock_record *blr); - - bool (*brl_unlock_windows)(struct vfs_handle_struct *handle, - struct messaging_context *msg_ctx, - struct byte_range_lock *br_lck, - const struct lock_struct *plock); - - bool (*brl_cancel_windows)(struct vfs_handle_struct *handle, - struct byte_range_lock *br_lck, - struct lock_struct *plock, - struct blocking_lock_record *blr); + void (*strict_unlock_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + struct lock_struct *plock); - bool (*strict_lock)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - struct lock_struct *plock); + NTSTATUS (*translate_name_fn)(struct vfs_handle_struct *handle, + const char *name, + enum vfs_translate_direction direction, + TALLOC_CTX *mem_ctx, + char **mapped_name); - void (*strict_unlock)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - struct lock_struct *plock); - - NTSTATUS (*translate_name)(struct vfs_handle_struct *handle, - const char *name, - enum vfs_translate_direction direction, - TALLOC_CTX *mem_ctx, - char **mapped_name); - - NTSTATUS (*fsctl)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - TALLOC_CTX *ctx, - uint32_t function, - uint16_t req_flags, - const uint8_t *_in_data, - uint32_t in_len, - uint8_t **_out_data, - uint32_t max_out_len, - uint32_t *out_len); + NTSTATUS (*fsctl_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + TALLOC_CTX *ctx, + uint32_t function, + uint16_t req_flags, + const uint8_t *_in_data, + uint32_t in_len, + uint8_t **_out_data, + uint32_t max_out_len, + uint32_t *out_len); /* NT ACL operations. */ - NTSTATUS (*fget_nt_acl)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - uint32 security_info, - struct security_descriptor **ppdesc); - NTSTATUS (*get_nt_acl)(struct vfs_handle_struct *handle, - const char *name, - uint32 security_info, - struct security_descriptor **ppdesc); - NTSTATUS (*fset_nt_acl)(struct vfs_handle_struct *handle, - struct files_struct *fsp, - uint32 security_info_sent, - const struct security_descriptor *psd); + NTSTATUS (*fget_nt_acl_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + uint32 security_info, + struct security_descriptor **ppdesc); + NTSTATUS (*get_nt_acl_fn)(struct vfs_handle_struct *handle, + const char *name, + uint32 security_info, + struct security_descriptor **ppdesc); + NTSTATUS (*fset_nt_acl_fn)(struct vfs_handle_struct *handle, + struct files_struct *fsp, + uint32 security_info_sent, + const struct security_descriptor *psd); /* POSIX ACL operations. */ - int (*chmod_acl)(struct vfs_handle_struct *handle, const char *name, mode_t mode); - int (*fchmod_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode); - - int (*sys_acl_get_entry)(struct vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p); - int (*sys_acl_get_tag_type)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p); - int (*sys_acl_get_permset)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p); - void * (*sys_acl_get_qualifier)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d); - SMB_ACL_T (*sys_acl_get_file)(struct vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type); - SMB_ACL_T (*sys_acl_get_fd)(struct vfs_handle_struct *handle, struct files_struct *fsp); - int (*sys_acl_clear_perms)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset); - int (*sys_acl_add_perm)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); - char * (*sys_acl_to_text)(struct vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen); - SMB_ACL_T (*sys_acl_init)(struct vfs_handle_struct *handle, int count); - int (*sys_acl_create_entry)(struct vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry); - int (*sys_acl_set_tag_type)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype); - int (*sys_acl_set_qualifier)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual); - int (*sys_acl_set_permset)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset); - int (*sys_acl_valid)(struct vfs_handle_struct *handle, SMB_ACL_T theacl ); - int (*sys_acl_set_file)(struct vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl); - int (*sys_acl_set_fd)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_ACL_T theacl); - int (*sys_acl_delete_def_file)(struct vfs_handle_struct *handle, const char *path); - int (*sys_acl_get_perm)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); - int (*sys_acl_free_text)(struct vfs_handle_struct *handle, char *text); - int (*sys_acl_free_acl)(struct vfs_handle_struct *handle, SMB_ACL_T posix_acl); - int (*sys_acl_free_qualifier)(struct vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype); + int (*chmod_acl_fn)(struct vfs_handle_struct *handle, const char *name, mode_t mode); + int (*fchmod_acl_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode); + + int (*sys_acl_get_entry_fn)(struct vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p); + int (*sys_acl_get_tag_type_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p); + int (*sys_acl_get_permset_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p); + void * (*sys_acl_get_qualifier_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d); + SMB_ACL_T (*sys_acl_get_file_fn)(struct vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type); + SMB_ACL_T (*sys_acl_get_fd_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp); + int (*sys_acl_clear_perms_fn)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset); + int (*sys_acl_add_perm_fn)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); + char * (*sys_acl_to_text_fn)(struct vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen); + SMB_ACL_T (*sys_acl_init_fn)(struct vfs_handle_struct *handle, int count); + int (*sys_acl_create_entry_fn)(struct vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry); + int (*sys_acl_set_tag_type_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype); + int (*sys_acl_set_qualifier_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual); + int (*sys_acl_set_permset_fn)(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset); + int (*sys_acl_valid_fn)(struct vfs_handle_struct *handle, SMB_ACL_T theacl ); + int (*sys_acl_set_file_fn)(struct vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl); + int (*sys_acl_set_fd_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_ACL_T theacl); + int (*sys_acl_delete_def_file_fn)(struct vfs_handle_struct *handle, const char *path); + int (*sys_acl_get_perm_fn)(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); + int (*sys_acl_free_text_fn)(struct vfs_handle_struct *handle, char *text); + int (*sys_acl_free_acl_fn)(struct vfs_handle_struct *handle, SMB_ACL_T posix_acl); + int (*sys_acl_free_qualifier_fn)(struct vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype); /* EA operations. */ - ssize_t (*getxattr)(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size); - ssize_t (*lgetxattr)(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size); - ssize_t (*fgetxattr)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size); - ssize_t (*listxattr)(struct vfs_handle_struct *handle, const char *path, char *list, size_t size); - ssize_t (*llistxattr)(struct vfs_handle_struct *handle, const char *path, char *list, size_t size); - ssize_t (*flistxattr)(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size); - int (*removexattr)(struct vfs_handle_struct *handle, const char *path, const char *name); - int (*lremovexattr)(struct vfs_handle_struct *handle, const char *path, const char *name); - int (*fremovexattr)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name); - int (*setxattr)(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags); - int (*lsetxattr)(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags); - int (*fsetxattr)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags); + ssize_t (*getxattr_fn)(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size); + ssize_t (*lgetxattr_fn)(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size); + ssize_t (*fgetxattr_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size); + ssize_t (*listxattr_fn)(struct vfs_handle_struct *handle, const char *path, char *list, size_t size); + ssize_t (*llistxattr_fn)(struct vfs_handle_struct *handle, const char *path, char *list, size_t size); + ssize_t (*flistxattr_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size); + int (*removexattr_fn)(struct vfs_handle_struct *handle, const char *path, const char *name); + int (*lremovexattr_fn)(struct vfs_handle_struct *handle, const char *path, const char *name); + int (*fremovexattr_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name); + int (*setxattr_fn)(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags); + int (*lsetxattr_fn)(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags); + int (*fsetxattr_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags); /* aio operations */ - int (*aio_read)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); - int (*aio_write)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); + int (*aio_read_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); + int (*aio_write_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); ssize_t (*aio_return_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); - int (*aio_cancel)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); + int (*aio_cancel_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); int (*aio_error_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); - int (*aio_fsync)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb); - int (*aio_suspend)(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_AIOCB * const aiocb[], int n, const struct timespec *timeout); - bool (*aio_force)(struct vfs_handle_struct *handle, struct files_struct *fsp); + int (*aio_fsync_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb); + int (*aio_suspend_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_AIOCB * const aiocb[], int n, const struct timespec *timeout); + bool (*aio_force_fn)(struct vfs_handle_struct *handle, struct files_struct *fsp); /* offline operations */ - bool (*is_offline)(struct vfs_handle_struct *handle, + bool (*is_offline_fn)(struct vfs_handle_struct *handle, const struct smb_filename *fname, SMB_STRUCT_STAT *sbuf); - int (*set_offline)(struct vfs_handle_struct *handle, + int (*set_offline_fn)(struct vfs_handle_struct *handle, const struct smb_filename *fname); }; @@ -544,7 +545,7 @@ int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle, int smb_vfs_call_statvfs(struct vfs_handle_struct *handle, const char *path, struct vfs_statvfs_struct *statbuf); uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle, - enum timestamp_set_resolution *p_ts_res); + enum timestamp_set_resolution *p_ts_res); /* * Note: that "struct dfs_GetDFSReferral *r" needs to be a valid TALLOC_CTX */ @@ -592,10 +593,10 @@ NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle, struct ea_list *ea_list, files_struct **result, int *pinfo); -int smb_vfs_call_close_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp); -ssize_t smb_vfs_call_vfs_read(struct vfs_handle_struct *handle, - struct files_struct *fsp, void *data, size_t n); +int smb_vfs_call_close(struct vfs_handle_struct *handle, + struct files_struct *fsp); +ssize_t smb_vfs_call_read(struct vfs_handle_struct *handle, + struct files_struct *fsp, void *data, size_t n); ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle, struct files_struct *fsp, void *data, size_t n, SMB_OFF_T offset); @@ -665,8 +666,8 @@ bool smb_vfs_call_getlock(struct vfs_handle_struct *handle, SMB_OFF_T *pcount, int *ptype, pid_t *ppid); int smb_vfs_call_symlink(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); -int smb_vfs_call_vfs_readlink(struct vfs_handle_struct *handle, - const char *path, char *buf, size_t bufsiz); +int smb_vfs_call_readlink(struct vfs_handle_struct *handle, + const char *path, char *buf, size_t bufsiz); int smb_vfs_call_link(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath); int smb_vfs_call_mknod(struct vfs_handle_struct *handle, const char *path, @@ -832,14 +833,14 @@ int smb_vfs_call_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); int smb_vfs_call_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); -ssize_t smb_vfs_call_aio_return_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp, - SMB_STRUCT_AIOCB *aiocb); +ssize_t smb_vfs_call_aio_return(struct vfs_handle_struct *handle, + struct files_struct *fsp, + SMB_STRUCT_AIOCB *aiocb); int smb_vfs_call_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); -int smb_vfs_call_aio_error_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp, - SMB_STRUCT_AIOCB *aiocb); +int smb_vfs_call_aio_error(struct vfs_handle_struct *handle, + struct files_struct *fsp, + SMB_STRUCT_AIOCB *aiocb); int smb_vfs_call_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb); diff --git a/source3/include/vfs_macros.h b/source3/include/vfs_macros.h index 6047f59392c..3bfda9fecb8 100644 --- a/source3/include/vfs_macros.h +++ b/source3/include/vfs_macros.h @@ -144,14 +144,14 @@ (create_options), (file_attributes), (oplock_request), (allocation_size), (private_flags), (sd), (ea_list), (result), (pinfo)) #define SMB_VFS_CLOSE(fsp) \ - smb_vfs_call_close_fn((fsp)->conn->vfs_handles, (fsp)) + smb_vfs_call_close((fsp)->conn->vfs_handles, (fsp)) #define SMB_VFS_NEXT_CLOSE(handle, fsp) \ - smb_vfs_call_close_fn((handle)->next, (fsp)) + smb_vfs_call_close((handle)->next, (fsp)) #define SMB_VFS_READ(fsp, data, n) \ - smb_vfs_call_vfs_read((fsp)->conn->vfs_handles, (fsp), (data), (n)) + smb_vfs_call_read((fsp)->conn->vfs_handles, (fsp), (data), (n)) #define SMB_VFS_NEXT_READ(handle, fsp, data, n) \ - smb_vfs_call_vfs_read((handle)->next, (fsp), (data), (n)) + smb_vfs_call_read((handle)->next, (fsp), (data), (n)) #define SMB_VFS_PREAD(fsp, data, n, off) \ smb_vfs_call_pread((fsp)->conn->vfs_handles, (fsp), (data), (n), (off)) @@ -294,9 +294,9 @@ smb_vfs_call_symlink((handle)->next, (oldpath), (newpath)) #define SMB_VFS_READLINK(conn, path, buf, bufsiz) \ - smb_vfs_call_vfs_readlink((conn)->vfs_handles, (path), (buf), (bufsiz)) + smb_vfs_call_readlink((conn)->vfs_handles, (path), (buf), (bufsiz)) #define SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz) \ - smb_vfs_call_vfs_readlink((handle)->next, (path), (buf), (bufsiz)) + smb_vfs_call_readlink((handle)->next, (path), (buf), (bufsiz)) #define SMB_VFS_LINK(conn, oldpath, newpath) \ smb_vfs_call_link((conn)->vfs_handles, (oldpath), (newpath)) @@ -585,9 +585,9 @@ smb_vfs_call_aio_write((handle)->next,(fsp),(aiocb)) #define SMB_VFS_AIO_RETURN(fsp,aiocb) \ - smb_vfs_call_aio_return_fn((fsp)->conn->vfs_handles, (fsp), (aiocb)) + smb_vfs_call_aio_return((fsp)->conn->vfs_handles, (fsp), (aiocb)) #define SMB_VFS_NEXT_AIO_RETURN(handle,fsp,aiocb) \ - smb_vfs_call_aio_return_fn((handle)->next,(fsp),(aiocb)) + smb_vfs_call_aio_return((handle)->next,(fsp),(aiocb)) #define SMB_VFS_AIO_CANCEL(fsp,aiocb) \ smb_vfs_call_aio_cancel((fsp)->conn->vfs_handles, (fsp), (aiocb)) @@ -595,9 +595,9 @@ smb_vfs_call_aio_cancel((handle)->next,(fsp),(aiocb)) #define SMB_VFS_AIO_ERROR(fsp,aiocb) \ - smb_vfs_call_aio_error_fn((fsp)->conn->vfs_handles, (fsp),(aiocb)) + smb_vfs_call_aio_error((fsp)->conn->vfs_handles, (fsp),(aiocb)) #define SMB_VFS_NEXT_AIO_ERROR(handle,fsp,aiocb) \ - smb_vfs_call_aio_error_fn((handle)->next,(fsp),(aiocb)) + smb_vfs_call_aio_error((handle)->next,(fsp),(aiocb)) #define SMB_VFS_AIO_FSYNC(fsp,op,aiocb) \ smb_vfs_call_aio_fsync((fsp)->conn->vfs_handles, (fsp), (op),(aiocb)) diff --git a/source3/locking/brlock.c b/source3/locking/brlock.c index 2cb2652791a..efc58c38913 100644 --- a/source3/locking/brlock.c +++ b/source3/locking/brlock.c @@ -898,8 +898,8 @@ NTSTATUS smb_vfs_call_brl_lock_windows(struct vfs_handle_struct *handle, struct blocking_lock_record *blr) { VFS_FIND(brl_lock_windows); - return handle->fns->brl_lock_windows(handle, br_lck, plock, - blocking_lock, blr); + return handle->fns->brl_lock_windows_fn(handle, br_lck, plock, + blocking_lock, blr); } /**************************************************************************** @@ -1232,7 +1232,8 @@ bool smb_vfs_call_brl_unlock_windows(struct vfs_handle_struct *handle, const struct lock_struct *plock) { VFS_FIND(brl_unlock_windows); - return handle->fns->brl_unlock_windows(handle, msg_ctx, br_lck, plock); + return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck, + plock); } /**************************************************************************** @@ -1400,7 +1401,7 @@ bool smb_vfs_call_brl_cancel_windows(struct vfs_handle_struct *handle, struct blocking_lock_record *blr) { VFS_FIND(brl_cancel_windows); - return handle->fns->brl_cancel_windows(handle, br_lck, plock, blr); + return handle->fns->brl_cancel_windows_fn(handle, br_lck, plock, blr); } /**************************************************************************** diff --git a/source3/locking/posix.c b/source3/locking/posix.c index 0ff2395d60c..abedd5600db 100644 --- a/source3/locking/posix.c +++ b/source3/locking/posix.c @@ -187,7 +187,7 @@ bool smb_vfs_call_lock(struct vfs_handle_struct *handle, SMB_OFF_T count, int type) { VFS_FIND(lock); - return handle->fns->lock(handle, fsp, op, offset, count, type); + return handle->fns->lock_fn(handle, fsp, op, offset, count, type); } /**************************************************************************** @@ -238,7 +238,8 @@ bool smb_vfs_call_getlock(struct vfs_handle_struct *handle, SMB_OFF_T *pcount, int *ptype, pid_t *ppid) { VFS_FIND(getlock); - return handle->fns->getlock(handle, fsp, poffset, pcount, ptype, ppid); + return handle->fns->getlock_fn(handle, fsp, poffset, pcount, ptype, + ppid); } /**************************************************************************** diff --git a/source3/modules/vfs_acl_tdb.c b/source3/modules/vfs_acl_tdb.c index 35b8ab70c73..67d0540fef0 100644 --- a/source3/modules/vfs_acl_tdb.c +++ b/source3/modules/vfs_acl_tdb.c @@ -399,18 +399,18 @@ static int sys_acl_set_fd_tdb(vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_acl_tdb_fns = { .connect_fn = connect_acl_tdb, - .disconnect = disconnect_acl_tdb, - .rmdir = rmdir_acl_tdb, - .unlink = unlink_acl_tdb, - .chmod = chmod_acl_module_common, - .fchmod = fchmod_acl_module_common, - .fget_nt_acl = fget_nt_acl_common, - .get_nt_acl = get_nt_acl_common, - .fset_nt_acl = fset_nt_acl_common, - .chmod_acl = chmod_acl_acl_module_common, - .fchmod_acl = fchmod_acl_acl_module_common, - .sys_acl_set_file = sys_acl_set_file_tdb, - .sys_acl_set_fd = sys_acl_set_fd_tdb + .disconnect_fn = disconnect_acl_tdb, + .rmdir_fn = rmdir_acl_tdb, + .unlink_fn = unlink_acl_tdb, + .chmod_fn = chmod_acl_module_common, + .fchmod_fn = fchmod_acl_module_common, + .fget_nt_acl_fn = fget_nt_acl_common, + .get_nt_acl_fn = get_nt_acl_common, + .fset_nt_acl_fn = fset_nt_acl_common, + .chmod_acl_fn = chmod_acl_acl_module_common, + .fchmod_acl_fn = fchmod_acl_acl_module_common, + .sys_acl_set_file_fn = sys_acl_set_file_tdb, + .sys_acl_set_fd_fn = sys_acl_set_fd_tdb }; NTSTATUS vfs_acl_tdb_init(void) diff --git a/source3/modules/vfs_acl_xattr.c b/source3/modules/vfs_acl_xattr.c index 25a3c54ef25..5653657066d 100644 --- a/source3/modules/vfs_acl_xattr.c +++ b/source3/modules/vfs_acl_xattr.c @@ -201,17 +201,17 @@ static int connect_acl_xattr(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_acl_xattr_fns = { .connect_fn = connect_acl_xattr, - .rmdir = rmdir_acl_common, - .unlink = unlink_acl_common, - .chmod = chmod_acl_module_common, - .fchmod = fchmod_acl_module_common, - .fget_nt_acl = fget_nt_acl_common, - .get_nt_acl = get_nt_acl_common, - .fset_nt_acl = fset_nt_acl_common, - .chmod_acl = chmod_acl_acl_module_common, - .fchmod_acl = fchmod_acl_acl_module_common, - .sys_acl_set_file = sys_acl_set_file_xattr, - .sys_acl_set_fd = sys_acl_set_fd_xattr + .rmdir_fn = rmdir_acl_common, + .unlink_fn = unlink_acl_common, + .chmod_fn = chmod_acl_module_common, + .fchmod_fn = fchmod_acl_module_common, + .fget_nt_acl_fn = fget_nt_acl_common, + .get_nt_acl_fn = get_nt_acl_common, + .fset_nt_acl_fn = fset_nt_acl_common, + .chmod_acl_fn = chmod_acl_acl_module_common, + .fchmod_acl_fn = fchmod_acl_acl_module_common, + .sys_acl_set_file_fn = sys_acl_set_file_xattr, + .sys_acl_set_fd_fn = sys_acl_set_fd_xattr }; NTSTATUS vfs_acl_xattr_init(void) diff --git a/source3/modules/vfs_afsacl.c b/source3/modules/vfs_afsacl.c index 6301469db06..e965e4c8b13 100644 --- a/source3/modules/vfs_afsacl.c +++ b/source3/modules/vfs_afsacl.c @@ -1087,9 +1087,9 @@ static int afsacl_connect(vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_afsacl_fns = { .connect_fn = afsacl_connect, - .fget_nt_acl = afsacl_fget_nt_acl, - .get_nt_acl = afsacl_get_nt_acl, - .fset_nt_acl = afsacl_fset_nt_acl + .fget_nt_acl_fn = afsacl_fget_nt_acl, + .get_nt_acl_fn = afsacl_get_nt_acl, + .fset_nt_acl_fn = afsacl_fset_nt_acl }; NTSTATUS vfs_afsacl_init(void); diff --git a/source3/modules/vfs_aio_fork.c b/source3/modules/vfs_aio_fork.c index 961efd85de2..01eb97de867 100644 --- a/source3/modules/vfs_aio_fork.c +++ b/source3/modules/vfs_aio_fork.c @@ -879,12 +879,12 @@ static int aio_fork_suspend(struct vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_aio_fork_fns = { - .aio_read = aio_fork_read, - .aio_write = aio_fork_write, + .aio_read_fn = aio_fork_read, + .aio_write_fn = aio_fork_write, .aio_return_fn = aio_fork_return_fn, - .aio_cancel = aio_fork_cancel, + .aio_cancel_fn = aio_fork_cancel, .aio_error_fn = aio_fork_error_fn, - .aio_suspend = aio_fork_suspend, + .aio_suspend_fn = aio_fork_suspend, }; NTSTATUS vfs_aio_fork_init(void); diff --git a/source3/modules/vfs_aixacl.c b/source3/modules/vfs_aixacl.c index c09bdb5bb81..c4bb02eebf5 100644 --- a/source3/modules/vfs_aixacl.c +++ b/source3/modules/vfs_aixacl.c @@ -180,11 +180,11 @@ int aixacl_sys_acl_delete_def_file(vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_aixacl_fns = { - .sys_acl_get_file = aixacl_sys_acl_get_file, - .sys_acl_get_fd = aixacl_sys_acl_get_fd, - .sys_acl_set_file = aixacl_sys_acl_set_file, - .sys_acl_set_fd = aixacl_sys_acl_set_fd, - .sys_acl_delete_def_file = aixacl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = aixacl_sys_acl_get_file, + .sys_acl_get_fd_fn = aixacl_sys_acl_get_fd, + .sys_acl_set_file_fn = aixacl_sys_acl_set_file, + .sys_acl_set_fd_fn = aixacl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = aixacl_sys_acl_delete_def_file, }; NTSTATUS vfs_aixacl_init(void); diff --git a/source3/modules/vfs_aixacl2.c b/source3/modules/vfs_aixacl2.c index 5ded2a8f2e5..3f13a6fa87f 100644 --- a/source3/modules/vfs_aixacl2.c +++ b/source3/modules/vfs_aixacl2.c @@ -487,14 +487,14 @@ int aixjfs2_sys_acl_delete_def_file(vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_aixacl2_fns = { - .fget_nt_acl = aixjfs2_fget_nt_acl, - .get_nt_acl = aixjfs2_get_nt_acl, - .fset_nt_acl = aixjfs2_fset_nt_acl, - .sys_acl_get_file = aixjfs2_sys_acl_get_file, - .sys_acl_get_fd = aixjfs2_sys_acl_get_fd, - .sys_acl_set_file = aixjfs2_sys_acl_set_file, - .sys_acl_set_fd = aixjfs2_sys_acl_set_fd, - .sys_acl_delete_def_file = aixjfs2_sys_acl_delete_def_file + .fget_nt_acl_fn = aixjfs2_fget_nt_acl, + .get_nt_acl_fn = aixjfs2_get_nt_acl, + .fset_nt_acl_fn = aixjfs2_fset_nt_acl, + .sys_acl_get_file_fn = aixjfs2_sys_acl_get_file, + .sys_acl_get_fd_fn = aixjfs2_sys_acl_get_fd, + .sys_acl_set_file_fn = aixjfs2_sys_acl_set_file, + .sys_acl_set_fd_fn = aixjfs2_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = aixjfs2_sys_acl_delete_def_file }; NTSTATUS vfs_aixacl2_init(void); diff --git a/source3/modules/vfs_audit.c b/source3/modules/vfs_audit.c index eeeea8aafa3..1da8755410d 100644 --- a/source3/modules/vfs_audit.c +++ b/source3/modules/vfs_audit.c @@ -269,18 +269,18 @@ static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t static struct vfs_fn_pointers vfs_audit_fns = { .connect_fn = audit_connect, - .disconnect = audit_disconnect, - .opendir = audit_opendir, - .mkdir = audit_mkdir, - .rmdir = audit_rmdir, + .disconnect_fn = audit_disconnect, + .opendir_fn = audit_opendir, + .mkdir_fn = audit_mkdir, + .rmdir_fn = audit_rmdir, .open_fn = audit_open, .close_fn = audit_close, - .rename = audit_rename, - .unlink = audit_unlink, - .chmod = audit_chmod, - .fchmod = audit_fchmod, - .chmod_acl = audit_chmod_acl, - .fchmod_acl = audit_fchmod_acl + .rename_fn = audit_rename, + .unlink_fn = audit_unlink, + .chmod_fn = audit_chmod, + .fchmod_fn = audit_fchmod, + .chmod_acl_fn = audit_chmod_acl, + .fchmod_acl_fn = audit_fchmod_acl }; NTSTATUS vfs_audit_init(void) diff --git a/source3/modules/vfs_cacheprime.c b/source3/modules/vfs_cacheprime.c index 167b93580f9..bd11797f6b1 100644 --- a/source3/modules/vfs_cacheprime.c +++ b/source3/modules/vfs_cacheprime.c @@ -177,10 +177,10 @@ static ssize_t cprime_pread( } static struct vfs_fn_pointers vfs_cacheprime_fns = { - .sendfile = cprime_sendfile, - .pread = cprime_pread, - .vfs_read = cprime_read, - .connect_fn = cprime_connect, + .sendfile_fn = cprime_sendfile, + .pread_fn = cprime_pread, + .read_fn = cprime_read, + .connect_fn = cprime_connect, }; /* ------------------------------------------------------------------------- diff --git a/source3/modules/vfs_cap.c b/source3/modules/vfs_cap.c index 15bebf6fea0..06ff89d89bb 100644 --- a/source3/modules/vfs_cap.c +++ b/source3/modules/vfs_cap.c @@ -571,41 +571,41 @@ static int cap_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp, co } static struct vfs_fn_pointers vfs_cap_fns = { - .disk_free = cap_disk_free, - .opendir = cap_opendir, - .readdir = cap_readdir, - .mkdir = cap_mkdir, - .rmdir = cap_rmdir, + .disk_free_fn = cap_disk_free, + .opendir_fn = cap_opendir, + .readdir_fn = cap_readdir, + .mkdir_fn = cap_mkdir, + .rmdir_fn = cap_rmdir, .open_fn = cap_open, - .rename = cap_rename, - .stat = cap_stat, - .lstat = cap_lstat, - .unlink = cap_unlink, - .chmod = cap_chmod, - .chown = cap_chown, - .lchown = cap_lchown, - .chdir = cap_chdir, - .ntimes = cap_ntimes, - .symlink = cap_symlink, - .vfs_readlink = cap_readlink, - .link = cap_link, - .mknod = cap_mknod, - .realpath = cap_realpath, - .chmod_acl = cap_chmod_acl, - .sys_acl_get_file = cap_sys_acl_get_file, - .sys_acl_set_file = cap_sys_acl_set_file, - .sys_acl_delete_def_file = cap_sys_acl_delete_def_file, - .getxattr = cap_getxattr, - .lgetxattr = cap_lgetxattr, - .fgetxattr = cap_fgetxattr, - .listxattr = cap_listxattr, - .llistxattr = cap_llistxattr, - .removexattr = cap_removexattr, - .lremovexattr = cap_lremovexattr, - .fremovexattr = cap_fremovexattr, - .setxattr = cap_setxattr, - .lsetxattr = cap_lsetxattr, - .fsetxattr = cap_fsetxattr + .rename_fn = cap_rename, + .stat_fn = cap_stat, + .lstat_fn = cap_lstat, + .unlink_fn = cap_unlink, + .chmod_fn = cap_chmod, + .chown_fn = cap_chown, + .lchown_fn = cap_lchown, + .chdir_fn = cap_chdir, + .ntimes_fn = cap_ntimes, + .symlink_fn = cap_symlink, + .readlink_fn = cap_readlink, + .link_fn = cap_link, + .mknod_fn = cap_mknod, + .realpath_fn = cap_realpath, + .chmod_acl_fn = cap_chmod_acl, + .sys_acl_get_file_fn = cap_sys_acl_get_file, + .sys_acl_set_file_fn = cap_sys_acl_set_file, + .sys_acl_delete_def_file_fn = cap_sys_acl_delete_def_file, + .getxattr_fn = cap_getxattr, + .lgetxattr_fn = cap_lgetxattr, + .fgetxattr_fn = cap_fgetxattr, + .listxattr_fn = cap_listxattr, + .llistxattr_fn = cap_llistxattr, + .removexattr_fn = cap_removexattr, + .lremovexattr_fn = cap_lremovexattr, + .fremovexattr_fn = cap_fremovexattr, + .setxattr_fn = cap_setxattr, + .lsetxattr_fn = cap_lsetxattr, + .fsetxattr_fn = cap_fsetxattr }; NTSTATUS vfs_cap_init(void); diff --git a/source3/modules/vfs_catia.c b/source3/modules/vfs_catia.c index 31b9f188d36..d18977d6fe7 100644 --- a/source3/modules/vfs_catia.c +++ b/source3/modules/vfs_catia.c @@ -987,35 +987,35 @@ catia_lsetxattr(vfs_handle_struct *handle, const char *path, } static struct vfs_fn_pointers vfs_catia_fns = { - .mkdir = catia_mkdir, - .rmdir = catia_rmdir, - .opendir = catia_opendir, - .open_fn = catia_open, - .rename = catia_rename, - .stat = catia_stat, - .lstat = catia_lstat, - .unlink = catia_unlink, - .chown = catia_chown, - .lchown = catia_lchown, - .chdir = catia_chdir, - .ntimes = catia_ntimes, - .realpath = catia_realpath, - .chflags = catia_chflags, - .streaminfo = catia_streaminfo, - .translate_name = catia_translate_name, - .get_nt_acl = catia_get_nt_acl, - .chmod_acl = catia_chmod_acl, - .sys_acl_get_file = catia_sys_acl_get_file, - .sys_acl_set_file = catia_sys_acl_set_file, - .sys_acl_delete_def_file = catia_sys_acl_delete_def_file, - .getxattr = catia_getxattr, - .lgetxattr = catia_lgetxattr, - .listxattr = catia_listxattr, - .llistxattr = catia_llistxattr, - .removexattr = catia_removexattr, - .lremovexattr = catia_lremovexattr, - .setxattr = catia_setxattr, - .lsetxattr = catia_lsetxattr, + .mkdir_fn = catia_mkdir, + .rmdir_fn = catia_rmdir, + .opendir_fn = catia_opendir, + .open_fn = catia_open, + .rename_fn = catia_rename, + .stat_fn = catia_stat, + .lstat_fn = catia_lstat, + .unlink_fn = catia_unlink, + .chown_fn = catia_chown, + .lchown_fn = catia_lchown, + .chdir_fn = catia_chdir, + .ntimes_fn = catia_ntimes, + .realpath_fn = catia_realpath, + .chflags_fn = catia_chflags, + .streaminfo_fn = catia_streaminfo, + .translate_name_fn = catia_translate_name, + .get_nt_acl_fn = catia_get_nt_acl, + .chmod_acl_fn = catia_chmod_acl, + .sys_acl_get_file_fn = catia_sys_acl_get_file, + .sys_acl_set_file_fn = catia_sys_acl_set_file, + .sys_acl_delete_def_file_fn = catia_sys_acl_delete_def_file, + .getxattr_fn = catia_getxattr, + .lgetxattr_fn = catia_lgetxattr, + .listxattr_fn = catia_listxattr, + .llistxattr_fn = catia_llistxattr, + .removexattr_fn = catia_removexattr, + .lremovexattr_fn = catia_lremovexattr, + .setxattr_fn = catia_setxattr, + .lsetxattr_fn = catia_lsetxattr, }; NTSTATUS vfs_catia_init(void) diff --git a/source3/modules/vfs_crossrename.c b/source3/modules/vfs_crossrename.c index 8f7c5f042bb..a54125c3269 100644 --- a/source3/modules/vfs_crossrename.c +++ b/source3/modules/vfs_crossrename.c @@ -191,7 +191,7 @@ static int crossrename_rename(vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_crossrename_fns = { .connect_fn = crossrename_connect, - .rename = crossrename_rename + .rename_fn = crossrename_rename }; NTSTATUS vfs_crossrename_init(void); diff --git a/source3/modules/vfs_default.c b/source3/modules/vfs_default.c index 4fd844a104e..f556f1c4967 100644 --- a/source3/modules/vfs_default.c +++ b/source3/modules/vfs_default.c @@ -2166,141 +2166,141 @@ static struct vfs_fn_pointers vfs_default_fns = { /* Disk operations */ .connect_fn = vfswrap_connect, - .disconnect = vfswrap_disconnect, - .disk_free = vfswrap_disk_free, - .get_quota = vfswrap_get_quota, - .set_quota = vfswrap_set_quota, - .get_shadow_copy_data = vfswrap_get_shadow_copy_data, - .statvfs = vfswrap_statvfs, - .fs_capabilities = vfswrap_fs_capabilities, - .get_dfs_referrals = vfswrap_get_dfs_referrals, + .disconnect_fn = vfswrap_disconnect, + .disk_free_fn = vfswrap_disk_free, + .get_quota_fn = vfswrap_get_quota, + .set_quota_fn = vfswrap_set_quota, + .get_shadow_copy_data_fn = vfswrap_get_shadow_copy_data, + .statvfs_fn = vfswrap_statvfs, + .fs_capabilities_fn = vfswrap_fs_capabilities, + .get_dfs_referrals_fn = vfswrap_get_dfs_referrals, /* Directory operations */ - .opendir = vfswrap_opendir, - .fdopendir = vfswrap_fdopendir, - .readdir = vfswrap_readdir, - .seekdir = vfswrap_seekdir, - .telldir = vfswrap_telldir, - .rewind_dir = vfswrap_rewinddir, - .mkdir = vfswrap_mkdir, - .rmdir = vfswrap_rmdir, - .closedir = vfswrap_closedir, - .init_search_op = vfswrap_init_search_op, + .opendir_fn = vfswrap_opendir, + .fdopendir_fn = vfswrap_fdopendir, + .readdir_fn = vfswrap_readdir, + .seekdir_fn = vfswrap_seekdir, + .telldir_fn = vfswrap_telldir, + .rewind_dir_fn = vfswrap_rewinddir, + .mkdir_fn = vfswrap_mkdir, + .rmdir_fn = vfswrap_rmdir, + .closedir_fn = vfswrap_closedir, + .init_search_op_fn = vfswrap_init_search_op, /* File operations */ .open_fn = vfswrap_open, - .create_file = vfswrap_create_file, + .create_file_fn = vfswrap_create_file, .close_fn = vfswrap_close, - .vfs_read = vfswrap_read, - .pread = vfswrap_pread, - .write = vfswrap_write, - .pwrite = vfswrap_pwrite, - .lseek = vfswrap_lseek, - .sendfile = vfswrap_sendfile, - .recvfile = vfswrap_recvfile, - .rename = vfswrap_rename, - .fsync = vfswrap_fsync, - .stat = vfswrap_stat, - .fstat = vfswrap_fstat, - .lstat = vfswrap_lstat, - .get_alloc_size = vfswrap_get_alloc_size, - .unlink = vfswrap_unlink, - .chmod = vfswrap_chmod, - .fchmod = vfswrap_fchmod, - .chown = vfswrap_chown, - .fchown = vfswrap_fchown, - .lchown = vfswrap_lchown, - .chdir = vfswrap_chdir, - .getwd = vfswrap_getwd, - .ntimes = vfswrap_ntimes, - .ftruncate = vfswrap_ftruncate, - .fallocate = vfswrap_fallocate, - .lock = vfswrap_lock, - .kernel_flock = vfswrap_kernel_flock, - .linux_setlease = vfswrap_linux_setlease, - .getlock = vfswrap_getlock, - .symlink = vfswrap_symlink, - .vfs_readlink = vfswrap_readlink, - .link = vfswrap_link, - .mknod = vfswrap_mknod, - .realpath = vfswrap_realpath, - .notify_watch = vfswrap_notify_watch, - .chflags = vfswrap_chflags, - .file_id_create = vfswrap_file_id_create, - .streaminfo = vfswrap_streaminfo, - .get_real_filename = vfswrap_get_real_filename, - .connectpath = vfswrap_connectpath, - .brl_lock_windows = vfswrap_brl_lock_windows, - .brl_unlock_windows = vfswrap_brl_unlock_windows, - .brl_cancel_windows = vfswrap_brl_cancel_windows, - .strict_lock = vfswrap_strict_lock, - .strict_unlock = vfswrap_strict_unlock, - .translate_name = vfswrap_translate_name, - .fsctl = vfswrap_fsctl, + .read_fn = vfswrap_read, + .pread_fn = vfswrap_pread, + .write_fn = vfswrap_write, + .pwrite_fn = vfswrap_pwrite, + .lseek_fn = vfswrap_lseek, + .sendfile_fn = vfswrap_sendfile, + .recvfile_fn = vfswrap_recvfile, + .rename_fn = vfswrap_rename, + .fsync_fn = vfswrap_fsync, + .stat_fn = vfswrap_stat, + .fstat_fn = vfswrap_fstat, + .lstat_fn = vfswrap_lstat, + .get_alloc_size_fn = vfswrap_get_alloc_size, + .unlink_fn = vfswrap_unlink, + .chmod_fn = vfswrap_chmod, + .fchmod_fn = vfswrap_fchmod, + .chown_fn = vfswrap_chown, + .fchown_fn = vfswrap_fchown, + .lchown_fn = vfswrap_lchown, + .chdir_fn = vfswrap_chdir, + .getwd_fn = vfswrap_getwd, + .ntimes_fn = vfswrap_ntimes, + .ftruncate_fn = vfswrap_ftruncate, + .fallocate_fn = vfswrap_fallocate, + .lock_fn = vfswrap_lock, + .kernel_flock_fn = vfswrap_kernel_flock, + .linux_setlease_fn = vfswrap_linux_setlease, + .getlock_fn = vfswrap_getlock, + .symlink_fn = vfswrap_symlink, + .readlink_fn = vfswrap_readlink, + .link_fn = vfswrap_link, + .mknod_fn = vfswrap_mknod, + .realpath_fn = vfswrap_realpath, + .notify_watch_fn = vfswrap_notify_watch, + .chflags_fn = vfswrap_chflags, + .file_id_create_fn = vfswrap_file_id_create, + .streaminfo_fn = vfswrap_streaminfo, + .get_real_filename_fn = vfswrap_get_real_filename, + .connectpath_fn = vfswrap_connectpath, + .brl_lock_windows_fn = vfswrap_brl_lock_windows, + .brl_unlock_windows_fn = vfswrap_brl_unlock_windows, + .brl_cancel_windows_fn = vfswrap_brl_cancel_windows, + .strict_lock_fn = vfswrap_strict_lock, + .strict_unlock_fn = vfswrap_strict_unlock, + .translate_name_fn = vfswrap_translate_name, + .fsctl_fn = vfswrap_fsctl, /* NT ACL operations. */ - .fget_nt_acl = vfswrap_fget_nt_acl, - .get_nt_acl = vfswrap_get_nt_acl, - .fset_nt_acl = vfswrap_fset_nt_acl, + .fget_nt_acl_fn = vfswrap_fget_nt_acl, + .get_nt_acl_fn = vfswrap_get_nt_acl, + .fset_nt_acl_fn = vfswrap_fset_nt_acl, /* POSIX ACL operations. */ - .chmod_acl = vfswrap_chmod_acl, - .fchmod_acl = vfswrap_fchmod_acl, - - .sys_acl_get_entry = vfswrap_sys_acl_get_entry, - .sys_acl_get_tag_type = vfswrap_sys_acl_get_tag_type, - .sys_acl_get_permset = vfswrap_sys_acl_get_permset, - .sys_acl_get_qualifier = vfswrap_sys_acl_get_qualifier, - .sys_acl_get_file = vfswrap_sys_acl_get_file, - .sys_acl_get_fd = vfswrap_sys_acl_get_fd, - .sys_acl_clear_perms = vfswrap_sys_acl_clear_perms, - .sys_acl_add_perm = vfswrap_sys_acl_add_perm, - .sys_acl_to_text = vfswrap_sys_acl_to_text, - .sys_acl_init = vfswrap_sys_acl_init, - .sys_acl_create_entry = vfswrap_sys_acl_create_entry, - .sys_acl_set_tag_type = vfswrap_sys_acl_set_tag_type, - .sys_acl_set_qualifier = vfswrap_sys_acl_set_qualifier, - .sys_acl_set_permset = vfswrap_sys_acl_set_permset, - .sys_acl_valid = vfswrap_sys_acl_valid, - .sys_acl_set_file = vfswrap_sys_acl_set_file, - .sys_acl_set_fd = vfswrap_sys_acl_set_fd, - .sys_acl_delete_def_file = vfswrap_sys_acl_delete_def_file, - .sys_acl_get_perm = vfswrap_sys_acl_get_perm, - .sys_acl_free_text = vfswrap_sys_acl_free_text, - .sys_acl_free_acl = vfswrap_sys_acl_free_acl, - .sys_acl_free_qualifier = vfswrap_sys_acl_free_qualifier, + .chmod_acl_fn = vfswrap_chmod_acl, + .fchmod_acl_fn = vfswrap_fchmod_acl, + + .sys_acl_get_entry_fn = vfswrap_sys_acl_get_entry, + .sys_acl_get_tag_type_fn = vfswrap_sys_acl_get_tag_type, + .sys_acl_get_permset_fn = vfswrap_sys_acl_get_permset, + .sys_acl_get_qualifier_fn = vfswrap_sys_acl_get_qualifier, + .sys_acl_get_file_fn = vfswrap_sys_acl_get_file, + .sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd, + .sys_acl_clear_perms_fn = vfswrap_sys_acl_clear_perms, + .sys_acl_add_perm_fn = vfswrap_sys_acl_add_perm, + .sys_acl_to_text_fn = vfswrap_sys_acl_to_text, + .sys_acl_init_fn = vfswrap_sys_acl_init, + .sys_acl_create_entry_fn = vfswrap_sys_acl_create_entry, + .sys_acl_set_tag_type_fn = vfswrap_sys_acl_set_tag_type, + .sys_acl_set_qualifier_fn = vfswrap_sys_acl_set_qualifier, + .sys_acl_set_permset_fn = vfswrap_sys_acl_set_permset, + .sys_acl_valid_fn = vfswrap_sys_acl_valid, + .sys_acl_set_file_fn = vfswrap_sys_acl_set_file, + .sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = vfswrap_sys_acl_delete_def_file, + .sys_acl_get_perm_fn = vfswrap_sys_acl_get_perm, + .sys_acl_free_text_fn = vfswrap_sys_acl_free_text, + .sys_acl_free_acl_fn = vfswrap_sys_acl_free_acl, + .sys_acl_free_qualifier_fn = vfswrap_sys_acl_free_qualifier, /* EA operations. */ - .getxattr = vfswrap_getxattr, - .lgetxattr = vfswrap_lgetxattr, - .fgetxattr = vfswrap_fgetxattr, - .listxattr = vfswrap_listxattr, - .llistxattr = vfswrap_llistxattr, - .flistxattr = vfswrap_flistxattr, - .removexattr = vfswrap_removexattr, - .lremovexattr = vfswrap_lremovexattr, - .fremovexattr = vfswrap_fremovexattr, - .setxattr = vfswrap_setxattr, - .lsetxattr = vfswrap_lsetxattr, - .fsetxattr = vfswrap_fsetxattr, + .getxattr_fn = vfswrap_getxattr, + .lgetxattr_fn = vfswrap_lgetxattr, + .fgetxattr_fn = vfswrap_fgetxattr, + .listxattr_fn = vfswrap_listxattr, + .llistxattr_fn = vfswrap_llistxattr, + .flistxattr_fn = vfswrap_flistxattr, + .removexattr_fn = vfswrap_removexattr, + .lremovexattr_fn = vfswrap_lremovexattr, + .fremovexattr_fn = vfswrap_fremovexattr, + .setxattr_fn = vfswrap_setxattr, + .lsetxattr_fn = vfswrap_lsetxattr, + .fsetxattr_fn = vfswrap_fsetxattr, /* aio operations */ - .aio_read = vfswrap_aio_read, - .aio_write = vfswrap_aio_write, + .aio_read_fn = vfswrap_aio_read, + .aio_write_fn = vfswrap_aio_write, .aio_return_fn = vfswrap_aio_return, - .aio_cancel = vfswrap_aio_cancel, + .aio_cancel_fn = vfswrap_aio_cancel, .aio_error_fn = vfswrap_aio_error, - .aio_fsync = vfswrap_aio_fsync, - .aio_suspend = vfswrap_aio_suspend, - .aio_force = vfswrap_aio_force, + .aio_fsync_fn = vfswrap_aio_fsync, + .aio_suspend_fn = vfswrap_aio_suspend, + .aio_force_fn = vfswrap_aio_force, /* offline operations */ - .is_offline = vfswrap_is_offline, - .set_offline = vfswrap_set_offline + .is_offline_fn = vfswrap_is_offline, + .set_offline_fn = vfswrap_set_offline }; NTSTATUS vfs_default_init(void); diff --git a/source3/modules/vfs_default_quota.c b/source3/modules/vfs_default_quota.c index fc95ef2e3b8..7b9b0c84705 100644 --- a/source3/modules/vfs_default_quota.c +++ b/source3/modules/vfs_default_quota.c @@ -216,8 +216,8 @@ static int default_quota_set_quota(vfs_handle_struct *handle, enum SMB_QUOTA_TYP } static struct vfs_fn_pointers vfs_default_quota_fns = { - .get_quota = default_quota_get_quota, - .set_quota = default_quota_set_quota + .get_quota_fn = default_quota_get_quota, + .set_quota_fn = default_quota_set_quota }; NTSTATUS vfs_default_quota_init(void); diff --git a/source3/modules/vfs_dfs_samba4.c b/source3/modules/vfs_dfs_samba4.c index a611de8415a..ad6f0411a15 100644 --- a/source3/modules/vfs_dfs_samba4.c +++ b/source3/modules/vfs_dfs_samba4.c @@ -131,8 +131,8 @@ static NTSTATUS dfs_samba4_get_referrals(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_dfs_samba4_fns = { .connect_fn = dfs_samba4_connect, - .disconnect = dfs_samba4_disconnect, - .get_dfs_referrals = dfs_samba4_get_referrals, + .disconnect_fn = dfs_samba4_disconnect, + .get_dfs_referrals_fn = dfs_samba4_get_referrals, }; NTSTATUS vfs_dfs_samba4_init(void); diff --git a/source3/modules/vfs_dirsort.c b/source3/modules/vfs_dirsort.c index ba8441c2dff..1c7aaba640a 100644 --- a/source3/modules/vfs_dirsort.c +++ b/source3/modules/vfs_dirsort.c @@ -222,12 +222,12 @@ static void dirsort_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp) } static struct vfs_fn_pointers vfs_dirsort_fns = { - .opendir = dirsort_opendir, - .fdopendir = dirsort_fdopendir, - .readdir = dirsort_readdir, - .seekdir = dirsort_seekdir, - .telldir = dirsort_telldir, - .rewind_dir = dirsort_rewinddir, + .opendir_fn = dirsort_opendir, + .fdopendir_fn = dirsort_fdopendir, + .readdir_fn = dirsort_readdir, + .seekdir_fn = dirsort_seekdir, + .telldir_fn = dirsort_telldir, + .rewind_dir_fn = dirsort_rewinddir, }; NTSTATUS vfs_dirsort_init(void) diff --git a/source3/modules/vfs_expand_msdfs.c b/source3/modules/vfs_expand_msdfs.c index a0d0d3d12af..d6e25776f19 100644 --- a/source3/modules/vfs_expand_msdfs.c +++ b/source3/modules/vfs_expand_msdfs.c @@ -224,7 +224,7 @@ static int expand_msdfs_readlink(struct vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_expand_msdfs_fns = { - .vfs_readlink = expand_msdfs_readlink + .readlink_fn = expand_msdfs_readlink }; NTSTATUS vfs_expand_msdfs_init(void); diff --git a/source3/modules/vfs_extd_audit.c b/source3/modules/vfs_extd_audit.c index fa8e9b14f96..6aab9cecbe0 100644 --- a/source3/modules/vfs_extd_audit.c +++ b/source3/modules/vfs_extd_audit.c @@ -346,18 +346,18 @@ static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t static struct vfs_fn_pointers vfs_extd_audit_fns = { .connect_fn = audit_connect, - .disconnect = audit_disconnect, - .opendir = audit_opendir, - .mkdir = audit_mkdir, - .rmdir = audit_rmdir, + .disconnect_fn = audit_disconnect, + .opendir_fn = audit_opendir, + .mkdir_fn = audit_mkdir, + .rmdir_fn = audit_rmdir, .open_fn = audit_open, .close_fn = audit_close, - .rename = audit_rename, - .unlink = audit_unlink, - .chmod = audit_chmod, - .fchmod = audit_fchmod, - .chmod_acl = audit_chmod_acl, - .fchmod_acl = audit_fchmod_acl, + .rename_fn = audit_rename, + .unlink_fn = audit_unlink, + .chmod_fn = audit_chmod, + .fchmod_fn = audit_fchmod, + .chmod_acl_fn = audit_chmod_acl, + .fchmod_acl_fn = audit_fchmod_acl, }; NTSTATUS vfs_extd_audit_init(void) diff --git a/source3/modules/vfs_fake_perms.c b/source3/modules/vfs_fake_perms.c index a7de8af6b15..4cda7ea1601 100644 --- a/source3/modules/vfs_fake_perms.c +++ b/source3/modules/vfs_fake_perms.c @@ -66,8 +66,8 @@ static int fake_perms_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_ST } static struct vfs_fn_pointers vfs_fake_perms_fns = { - .stat = fake_perms_stat, - .fstat = fake_perms_fstat + .stat_fn = fake_perms_stat, + .fstat_fn = fake_perms_fstat }; NTSTATUS vfs_fake_perms_init(void); diff --git a/source3/modules/vfs_fileid.c b/source3/modules/vfs_fileid.c index 1168d50cb2e..6237513f233 100644 --- a/source3/modules/vfs_fileid.c +++ b/source3/modules/vfs_fileid.c @@ -254,8 +254,8 @@ static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_fileid_fns = { .connect_fn = fileid_connect, - .disconnect = fileid_disconnect, - .file_id_create = fileid_file_id_create + .disconnect_fn = fileid_disconnect, + .file_id_create_fn = fileid_file_id_create }; NTSTATUS vfs_fileid_init(void); diff --git a/source3/modules/vfs_full_audit.c b/source3/modules/vfs_full_audit.c index 9471e6d8c2b..3efa848d22d 100644 --- a/source3/modules/vfs_full_audit.c +++ b/source3/modules/vfs_full_audit.c @@ -2241,120 +2241,120 @@ static struct vfs_fn_pointers vfs_full_audit_fns = { /* Disk operations */ .connect_fn = smb_full_audit_connect, - .disconnect = smb_full_audit_disconnect, - .disk_free = smb_full_audit_disk_free, - .get_quota = smb_full_audit_get_quota, - .set_quota = smb_full_audit_set_quota, - .get_shadow_copy_data = smb_full_audit_get_shadow_copy_data, - .statvfs = smb_full_audit_statvfs, - .fs_capabilities = smb_full_audit_fs_capabilities, - .opendir = smb_full_audit_opendir, - .fdopendir = smb_full_audit_fdopendir, - .readdir = smb_full_audit_readdir, - .seekdir = smb_full_audit_seekdir, - .telldir = smb_full_audit_telldir, - .rewind_dir = smb_full_audit_rewinddir, - .mkdir = smb_full_audit_mkdir, - .rmdir = smb_full_audit_rmdir, - .closedir = smb_full_audit_closedir, - .init_search_op = smb_full_audit_init_search_op, + .disconnect_fn = smb_full_audit_disconnect, + .disk_free_fn = smb_full_audit_disk_free, + .get_quota_fn = smb_full_audit_get_quota, + .set_quota_fn = smb_full_audit_set_quota, + .get_shadow_copy_data_fn = smb_full_audit_get_shadow_copy_data, + .statvfs_fn = smb_full_audit_statvfs, + .fs_capabilities_fn = smb_full_audit_fs_capabilities, + .opendir_fn = smb_full_audit_opendir, + .fdopendir_fn = smb_full_audit_fdopendir, + .readdir_fn = smb_full_audit_readdir, + .seekdir_fn = smb_full_audit_seekdir, + .telldir_fn = smb_full_audit_telldir, + .rewind_dir_fn = smb_full_audit_rewinddir, + .mkdir_fn = smb_full_audit_mkdir, + .rmdir_fn = smb_full_audit_rmdir, + .closedir_fn = smb_full_audit_closedir, + .init_search_op_fn = smb_full_audit_init_search_op, .open_fn = smb_full_audit_open, - .create_file = smb_full_audit_create_file, + .create_file_fn = smb_full_audit_create_file, .close_fn = smb_full_audit_close, - .vfs_read = smb_full_audit_read, - .pread = smb_full_audit_pread, - .write = smb_full_audit_write, - .pwrite = smb_full_audit_pwrite, - .lseek = smb_full_audit_lseek, - .sendfile = smb_full_audit_sendfile, - .recvfile = smb_full_audit_recvfile, - .rename = smb_full_audit_rename, - .fsync = smb_full_audit_fsync, - .stat = smb_full_audit_stat, - .fstat = smb_full_audit_fstat, - .lstat = smb_full_audit_lstat, - .get_alloc_size = smb_full_audit_get_alloc_size, - .unlink = smb_full_audit_unlink, - .chmod = smb_full_audit_chmod, - .fchmod = smb_full_audit_fchmod, - .chown = smb_full_audit_chown, - .fchown = smb_full_audit_fchown, - .lchown = smb_full_audit_lchown, - .chdir = smb_full_audit_chdir, - .getwd = smb_full_audit_getwd, - .ntimes = smb_full_audit_ntimes, - .ftruncate = smb_full_audit_ftruncate, - .fallocate = smb_full_audit_fallocate, - .lock = smb_full_audit_lock, - .kernel_flock = smb_full_audit_kernel_flock, - .linux_setlease = smb_full_audit_linux_setlease, - .getlock = smb_full_audit_getlock, - .symlink = smb_full_audit_symlink, - .vfs_readlink = smb_full_audit_readlink, - .link = smb_full_audit_link, - .mknod = smb_full_audit_mknod, - .realpath = smb_full_audit_realpath, - .notify_watch = smb_full_audit_notify_watch, - .chflags = smb_full_audit_chflags, - .file_id_create = smb_full_audit_file_id_create, - .streaminfo = smb_full_audit_streaminfo, - .get_real_filename = smb_full_audit_get_real_filename, - .connectpath = smb_full_audit_connectpath, - .brl_lock_windows = smb_full_audit_brl_lock_windows, - .brl_unlock_windows = smb_full_audit_brl_unlock_windows, - .brl_cancel_windows = smb_full_audit_brl_cancel_windows, - .strict_lock = smb_full_audit_strict_lock, - .strict_unlock = smb_full_audit_strict_unlock, - .translate_name = smb_full_audit_translate_name, - .fget_nt_acl = smb_full_audit_fget_nt_acl, - .get_nt_acl = smb_full_audit_get_nt_acl, - .fset_nt_acl = smb_full_audit_fset_nt_acl, - .chmod_acl = smb_full_audit_chmod_acl, - .fchmod_acl = smb_full_audit_fchmod_acl, - .sys_acl_get_entry = smb_full_audit_sys_acl_get_entry, - .sys_acl_get_tag_type = smb_full_audit_sys_acl_get_tag_type, - .sys_acl_get_permset = smb_full_audit_sys_acl_get_permset, - .sys_acl_get_qualifier = smb_full_audit_sys_acl_get_qualifier, - .sys_acl_get_file = smb_full_audit_sys_acl_get_file, - .sys_acl_get_fd = smb_full_audit_sys_acl_get_fd, - .sys_acl_clear_perms = smb_full_audit_sys_acl_clear_perms, - .sys_acl_add_perm = smb_full_audit_sys_acl_add_perm, - .sys_acl_to_text = smb_full_audit_sys_acl_to_text, - .sys_acl_init = smb_full_audit_sys_acl_init, - .sys_acl_create_entry = smb_full_audit_sys_acl_create_entry, - .sys_acl_set_tag_type = smb_full_audit_sys_acl_set_tag_type, - .sys_acl_set_qualifier = smb_full_audit_sys_acl_set_qualifier, - .sys_acl_set_permset = smb_full_audit_sys_acl_set_permset, - .sys_acl_valid = smb_full_audit_sys_acl_valid, - .sys_acl_set_file = smb_full_audit_sys_acl_set_file, - .sys_acl_set_fd = smb_full_audit_sys_acl_set_fd, - .sys_acl_delete_def_file = smb_full_audit_sys_acl_delete_def_file, - .sys_acl_get_perm = smb_full_audit_sys_acl_get_perm, - .sys_acl_free_text = smb_full_audit_sys_acl_free_text, - .sys_acl_free_acl = smb_full_audit_sys_acl_free_acl, - .sys_acl_free_qualifier = smb_full_audit_sys_acl_free_qualifier, - .getxattr = smb_full_audit_getxattr, - .lgetxattr = smb_full_audit_lgetxattr, - .fgetxattr = smb_full_audit_fgetxattr, - .listxattr = smb_full_audit_listxattr, - .llistxattr = smb_full_audit_llistxattr, - .flistxattr = smb_full_audit_flistxattr, - .removexattr = smb_full_audit_removexattr, - .lremovexattr = smb_full_audit_lremovexattr, - .fremovexattr = smb_full_audit_fremovexattr, - .setxattr = smb_full_audit_setxattr, - .lsetxattr = smb_full_audit_lsetxattr, - .fsetxattr = smb_full_audit_fsetxattr, - .aio_read = smb_full_audit_aio_read, - .aio_write = smb_full_audit_aio_write, + .read_fn = smb_full_audit_read, + .pread_fn = smb_full_audit_pread, + .write_fn = smb_full_audit_write, + .pwrite_fn = smb_full_audit_pwrite, + .lseek_fn = smb_full_audit_lseek, + .sendfile_fn = smb_full_audit_sendfile, + .recvfile_fn = smb_full_audit_recvfile, + .rename_fn = smb_full_audit_rename, + .fsync_fn = smb_full_audit_fsync, + .stat_fn = smb_full_audit_stat, + .fstat_fn = smb_full_audit_fstat, + .lstat_fn = smb_full_audit_lstat, + .get_alloc_size_fn = smb_full_audit_get_alloc_size, + .unlink_fn = smb_full_audit_unlink, + .chmod_fn = smb_full_audit_chmod, + .fchmod_fn = smb_full_audit_fchmod, + .chown_fn = smb_full_audit_chown, + .fchown_fn = smb_full_audit_fchown, + .lchown_fn = smb_full_audit_lchown, + .chdir_fn = smb_full_audit_chdir, + .getwd_fn = smb_full_audit_getwd, + .ntimes_fn = smb_full_audit_ntimes, + .ftruncate_fn = smb_full_audit_ftruncate, + .fallocate_fn = smb_full_audit_fallocate, + .lock_fn = smb_full_audit_lock, + .kernel_flock_fn = smb_full_audit_kernel_flock, + .linux_setlease_fn = smb_full_audit_linux_setlease, + .getlock_fn = smb_full_audit_getlock, + .symlink_fn = smb_full_audit_symlink, + .readlink_fn = smb_full_audit_readlink, + .link_fn = smb_full_audit_link, + .mknod_fn = smb_full_audit_mknod, + .realpath_fn = smb_full_audit_realpath, + .notify_watch_fn = smb_full_audit_notify_watch, + .chflags_fn = smb_full_audit_chflags, + .file_id_create_fn = smb_full_audit_file_id_create, + .streaminfo_fn = smb_full_audit_streaminfo, + .get_real_filename_fn = smb_full_audit_get_real_filename, + .connectpath_fn = smb_full_audit_connectpath, + .brl_lock_windows_fn = smb_full_audit_brl_lock_windows, + .brl_unlock_windows_fn = smb_full_audit_brl_unlock_windows, + .brl_cancel_windows_fn = smb_full_audit_brl_cancel_windows, + .strict_lock_fn = smb_full_audit_strict_lock, + .strict_unlock_fn = smb_full_audit_strict_unlock, + .translate_name_fn = smb_full_audit_translate_name, + .fget_nt_acl_fn = smb_full_audit_fget_nt_acl, + .get_nt_acl_fn = smb_full_audit_get_nt_acl, + .fset_nt_acl_fn = smb_full_audit_fset_nt_acl, + .chmod_acl_fn = smb_full_audit_chmod_acl, + .fchmod_acl_fn = smb_full_audit_fchmod_acl, + .sys_acl_get_entry_fn = smb_full_audit_sys_acl_get_entry, + .sys_acl_get_tag_type_fn = smb_full_audit_sys_acl_get_tag_type, + .sys_acl_get_permset_fn = smb_full_audit_sys_acl_get_permset, + .sys_acl_get_qualifier_fn = smb_full_audit_sys_acl_get_qualifier, + .sys_acl_get_file_fn = smb_full_audit_sys_acl_get_file, + .sys_acl_get_fd_fn = smb_full_audit_sys_acl_get_fd, + .sys_acl_clear_perms_fn = smb_full_audit_sys_acl_clear_perms, + .sys_acl_add_perm_fn = smb_full_audit_sys_acl_add_perm, + .sys_acl_to_text_fn = smb_full_audit_sys_acl_to_text, + .sys_acl_init_fn = smb_full_audit_sys_acl_init, + .sys_acl_create_entry_fn = smb_full_audit_sys_acl_create_entry, + .sys_acl_set_tag_type_fn = smb_full_audit_sys_acl_set_tag_type, + .sys_acl_set_qualifier_fn = smb_full_audit_sys_acl_set_qualifier, + .sys_acl_set_permset_fn = smb_full_audit_sys_acl_set_permset, + .sys_acl_valid_fn = smb_full_audit_sys_acl_valid, + .sys_acl_set_file_fn = smb_full_audit_sys_acl_set_file, + .sys_acl_set_fd_fn = smb_full_audit_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = smb_full_audit_sys_acl_delete_def_file, + .sys_acl_get_perm_fn = smb_full_audit_sys_acl_get_perm, + .sys_acl_free_text_fn = smb_full_audit_sys_acl_free_text, + .sys_acl_free_acl_fn = smb_full_audit_sys_acl_free_acl, + .sys_acl_free_qualifier_fn = smb_full_audit_sys_acl_free_qualifier, + .getxattr_fn = smb_full_audit_getxattr, + .lgetxattr_fn = smb_full_audit_lgetxattr, + .fgetxattr_fn = smb_full_audit_fgetxattr, + .listxattr_fn = smb_full_audit_listxattr, + .llistxattr_fn = smb_full_audit_llistxattr, + .flistxattr_fn = smb_full_audit_flistxattr, + .removexattr_fn = smb_full_audit_removexattr, + .lremovexattr_fn = smb_full_audit_lremovexattr, + .fremovexattr_fn = smb_full_audit_fremovexattr, + .setxattr_fn = smb_full_audit_setxattr, + .lsetxattr_fn = smb_full_audit_lsetxattr, + .fsetxattr_fn = smb_full_audit_fsetxattr, + .aio_read_fn = smb_full_audit_aio_read, + .aio_write_fn = smb_full_audit_aio_write, .aio_return_fn = smb_full_audit_aio_return, - .aio_cancel = smb_full_audit_aio_cancel, + .aio_cancel_fn = smb_full_audit_aio_cancel, .aio_error_fn = smb_full_audit_aio_error, - .aio_fsync = smb_full_audit_aio_fsync, - .aio_suspend = smb_full_audit_aio_suspend, - .aio_force = smb_full_audit_aio_force, - .is_offline = smb_full_audit_is_offline, - .set_offline = smb_full_audit_set_offline, + .aio_fsync_fn = smb_full_audit_aio_fsync, + .aio_suspend_fn = smb_full_audit_aio_suspend, + .aio_force_fn = smb_full_audit_aio_force, + .is_offline_fn = smb_full_audit_is_offline, + .set_offline_fn = smb_full_audit_set_offline, }; NTSTATUS vfs_full_audit_init(void) diff --git a/source3/modules/vfs_gpfs_hsm_notify.c b/source3/modules/vfs_gpfs_hsm_notify.c index fa24db99833..7ff5355c95f 100644 --- a/source3/modules/vfs_gpfs_hsm_notify.c +++ b/source3/modules/vfs_gpfs_hsm_notify.c @@ -97,8 +97,8 @@ static ssize_t vfs_gpfs_hsm_notify_aio_return(struct vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_gpfs_hsm_notify_fns = { - .pread = vfs_gpfs_hsm_notify_pread, - .pwrite = vfs_gpfs_hsm_notify_pwrite, + .pread_fn = vfs_gpfs_hsm_notify_pread, + .pwrite_fn = vfs_gpfs_hsm_notify_pwrite, .aio_return_fn = vfs_gpfs_hsm_notify_aio_return }; diff --git a/source3/modules/vfs_hpuxacl.c b/source3/modules/vfs_hpuxacl.c index 0f5af9d318d..5acfd1e25b7 100644 --- a/source3/modules/vfs_hpuxacl.c +++ b/source3/modules/vfs_hpuxacl.c @@ -1170,11 +1170,11 @@ static bool hpux_acl_check(HPUX_ACL_T hpux_acl, int count) /* VFS operations structure */ static struct vfs_fn_pointers hpuxacl_fns = { - .sys_acl_get_file = hpuxacl_sys_acl_get_file, - .sys_acl_get_fd = hpuxacl_sys_acl_get_fd, - .sys_acl_set_file = hpuxacl_sys_acl_set_file, - .sys_acl_set_fd = hpuxacl_sys_acl_set_fd, - .sys_acl_delete_def_file = hpuxacl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = hpuxacl_sys_acl_get_file, + .sys_acl_get_fd_fn = hpuxacl_sys_acl_get_fd, + .sys_acl_set_file_fn = hpuxacl_sys_acl_set_file, + .sys_acl_set_fd_fn = hpuxacl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = hpuxacl_sys_acl_delete_def_file, }; NTSTATUS vfs_hpuxacl_init(void) diff --git a/source3/modules/vfs_irixacl.c b/source3/modules/vfs_irixacl.c index b14abcca47c..8a24ee72633 100644 --- a/source3/modules/vfs_irixacl.c +++ b/source3/modules/vfs_irixacl.c @@ -71,11 +71,11 @@ int irixacl_sys_acl_delete_def_file(vfs_handle_struct *handle, /* VFS operations structure */ static struct vfs_fn_pointers irixacl_fns = { - .sys_acl_get_file = irixacl_sys_acl_get_file, - .sys_acl_get_fd = irixacl_sys_acl_get_fd, - .sys_acl_set_file = irixacl_sys_acl_set_file, - .sys_acl_set_fd = irixacl_sys_acl_set_fd, - .sys_acl_delete_def_file = irixacl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = irixacl_sys_acl_get_file, + .sys_acl_get_fd_fn = irixacl_sys_acl_get_fd, + .sys_acl_set_file_fn = irixacl_sys_acl_set_file, + .sys_acl_set_fd_fn = irixacl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = irixacl_sys_acl_delete_def_file, }; NTSTATUS vfs_irixacl_init(void); diff --git a/source3/modules/vfs_linux_xfs_sgid.c b/source3/modules/vfs_linux_xfs_sgid.c index fee12b01103..5a33f63d263 100644 --- a/source3/modules/vfs_linux_xfs_sgid.c +++ b/source3/modules/vfs_linux_xfs_sgid.c @@ -95,8 +95,8 @@ static int linux_xfs_sgid_chmod_acl(vfs_handle_struct *handle, } static struct vfs_fn_pointers linux_xfs_sgid_fns = { - .mkdir = linux_xfs_sgid_mkdir, - .chmod_acl = linux_xfs_sgid_chmod_acl, + .mkdir_fn = linux_xfs_sgid_mkdir, + .chmod_acl_fn = linux_xfs_sgid_chmod_acl, }; NTSTATUS vfs_linux_xfs_sgid_init(void); diff --git a/source3/modules/vfs_netatalk.c b/source3/modules/vfs_netatalk.c index 3e5606b553f..95de44137b4 100644 --- a/source3/modules/vfs_netatalk.c +++ b/source3/modules/vfs_netatalk.c @@ -455,14 +455,14 @@ exit_lchown: } static struct vfs_fn_pointers vfs_netatalk_fns = { - .opendir = atalk_opendir, - .fdopendir = atalk_fdopendir, - .rmdir = atalk_rmdir, - .rename = atalk_rename, - .unlink = atalk_unlink, - .chmod = atalk_chmod, - .chown = atalk_chown, - .lchown = atalk_lchown, + .opendir_fn = atalk_opendir, + .fdopendir_fn = atalk_fdopendir, + .rmdir_fn = atalk_rmdir, + .rename_fn = atalk_rename, + .unlink_fn = atalk_unlink, + .chmod_fn = atalk_chmod, + .chown_fn = atalk_chown, + .lchown_fn = atalk_lchown, }; NTSTATUS vfs_netatalk_init(void); diff --git a/source3/modules/vfs_notify_fam.c b/source3/modules/vfs_notify_fam.c index 1f76a05fc08..343149423e8 100644 --- a/source3/modules/vfs_notify_fam.c +++ b/source3/modules/vfs_notify_fam.c @@ -301,7 +301,7 @@ static NTSTATUS fam_watch(vfs_handle_struct *vfs_handle, /* VFS operations structure */ static struct vfs_fn_pointers notify_fam_fns = { - .notify_watch = fam_watch, + .notify_watch_fn = fam_watch, }; diff --git a/source3/modules/vfs_onefs.c b/source3/modules/vfs_onefs.c index efc8b8aae2d..5866eb49c89 100644 --- a/source3/modules/vfs_onefs.c +++ b/source3/modules/vfs_onefs.c @@ -256,40 +256,40 @@ static uint32_t onefs_fs_capabilities(struct vfs_handle_struct *handle, enum tim static struct vfs_fn_pointers onefs_fns = { .connect_fn = onefs_connect, - .fs_capabilities = onefs_fs_capabilities, - .opendir = onefs_opendir, - .readdir = onefs_readdir, - .seekdir = onefs_seekdir, - .telldir = onefs_telldir, - .rewind_dir = onefs_rewinddir, - .mkdir = onefs_mkdir, - .closedir = onefs_closedir, - .init_search_op = onefs_init_search_op, + .fs_capabilities_fn = onefs_fs_capabilities, + .opendir_fn = onefs_opendir, + .readdir_fn = onefs_readdir, + .seekdir_fn = onefs_seekdir, + .telldir_fn = onefs_telldir, + .rewind_dir_fn = onefs_rewinddir, + .mkdir_fn = onefs_mkdir, + .closedir_fn = onefs_closedir, + .init_search_op_fn = onefs_init_search_op, .open_fn = onefs_open, - .create_file = onefs_create_file, + .create_file_fn = onefs_create_file, .close_fn = onefs_close, - .sendfile = onefs_sendfile, - .recvfile = onefs_recvfile, - .rename = onefs_rename, - .stat = onefs_stat, - .fstat = onefs_fstat, - .lstat = onefs_lstat, - .get_alloc_size = onefs_get_alloc_size, - .unlink = onefs_unlink, - .ntimes = onefs_ntimes, - .file_id_create = onefs_file_id_create, - .streaminfo = onefs_streaminfo, - .brl_lock_windows = onefs_brl_lock_windows, - .brl_unlock_windows = onefs_brl_unlock_windows, - .brl_cancel_windows = onefs_brl_cancel_windows, - .strict_lock = onefs_strict_lock, - .strict_unlock = onefs_strict_unlock, - .notify_watch = onefs_notify_watch, - .fget_nt_acl = onefs_fget_nt_acl, - .get_nt_acl = onefs_get_nt_acl, - .fset_nt_acl = onefs_fset_nt_acl, - .statvfs = onefs_statvfs, - .get_real_filename = onefs_get_real_filename, + .sendfile_fn = onefs_sendfile, + .recvfile_fn = onefs_recvfile, + .rename_fn = onefs_rename, + .stat_fn = onefs_stat, + .fstat_fn = onefs_fstat, + .lstat_fn = onefs_lstat, + .get_alloc_size_fn = onefs_get_alloc_size, + .unlink_fn = onefs_unlink, + .ntimes_fn = onefs_ntimes, + .file_id_create_fn = onefs_file_id_create, + .streaminfo_fn = onefs_streaminfo, + .brl_lock_windows_fn = onefs_brl_lock_windows, + .brl_unlock_windows_fn = onefs_brl_unlock_windows, + .brl_cancel_windows_fn = onefs_brl_cancel_windows, + .strict_lock_fn = onefs_strict_lock, + .strict_unlock_fn = onefs_strict_unlock, + .notify_watch_fn = onefs_notify_watch, + .fget_nt_acl_fn = onefs_fget_nt_acl, + .get_nt_acl_fn = onefs_get_nt_acl, + .fset_nt_acl_fn = onefs_fset_nt_acl, + .statvfs_fn = onefs_statvfs, + .get_real_filename_fn = onefs_get_real_filename, }; NTSTATUS vfs_onefs_init(void) diff --git a/source3/modules/vfs_onefs_shadow_copy.c b/source3/modules/vfs_onefs_shadow_copy.c index a8a41bf8c5c..3b25942e686 100644 --- a/source3/modules/vfs_onefs_shadow_copy.c +++ b/source3/modules/vfs_onefs_shadow_copy.c @@ -657,47 +657,47 @@ onefs_shadow_copy_set_offline(struct vfs_handle_struct *handle, /* VFS operations structure */ static struct vfs_fn_pointers onefs_shadow_copy_fns = { - .disk_free = onefs_shadow_copy_disk_free, - .get_shadow_copy_data = onefs_shadow_copy_get_shadow_copy_data, - .statvfs = onefs_shadow_copy_statvfs, - .opendir = onefs_shadow_copy_opendir, - .mkdir = onefs_shadow_copy_mkdir, - .rmdir = onefs_shadow_copy_rmdir, + .disk_free_fn = onefs_shadow_copy_disk_free, + .get_shadow_copy_data_fn = onefs_shadow_copy_get_shadow_copy_data, + .statvfs_fn = onefs_shadow_copy_statvfs, + .opendir_fn = onefs_shadow_copy_opendir, + .mkdir_fn = onefs_shadow_copy_mkdir, + .rmdir_fn = onefs_shadow_copy_rmdir, .open_fn = onefs_shadow_copy_open, - .create_file = onefs_shadow_copy_create_file, - .rename = onefs_shadow_copy_rename, - .stat = onefs_shadow_copy_stat, - .stat = onefs_shadow_copy_stat, - .lstat = onefs_shadow_copy_lstat, - .unlink = onefs_shadow_copy_unlink, - .chmod = onefs_shadow_copy_chmod, - .chown = onefs_shadow_copy_chown, - .lchown = onefs_shadow_copy_lchown, - .chdir = onefs_shadow_copy_chdir, - .ntimes = onefs_shadow_copy_ntimes, - .symlink = onefs_shadow_copy_symlink, - .vfs_readlink = onefs_shadow_copy_readlink, - .link = onefs_shadow_copy_link, - .mknod = onefs_shadow_copy_mknod, - .realpath = onefs_shadow_copy_realpath, - .chflags = onefs_shadow_copy_chflags, - .streaminfo = onefs_shadow_copy_streaminfo, - .get_real_filename = onefs_shadow_copy_get_real_filename, - .get_nt_acl = onefs_shadow_copy_get_nt_acl, - .chmod_acl = onefs_shadow_copy_chmod_acl, - .sys_acl_get_file = onefs_shadow_copy_sys_acl_get_file, - .sys_acl_set_file = onefs_shadow_copy_sys_acl_set_file, - .sys_acl_delete_def_file = onefs_shadow_copy_sys_acl_delete_def_file, - .getxattr = onefs_shadow_copy_getxattr, - .lgetxattr = onefs_shadow_copy_lgetxattr, - .listxattr = onefs_shadow_copy_listxattr, - .llistxattr = onefs_shadow_copy_llistxattr, - .removexattr = onefs_shadow_copy_removexattr, - .lremovexattr = onefs_shadow_copy_lremovexattr, - .setxattr = onefs_shadow_copy_setxattr, - .lsetxattr = onefs_shadow_copy_lsetxattr, - .is_offline = onefs_shadow_copy_is_offline, - .set_offline = onefs_shadow_copy_set_offline, + .create_file_fn = onefs_shadow_copy_create_file, + .rename_fn = onefs_shadow_copy_rename, + .stat_fn = onefs_shadow_copy_stat, + .stat_fn = onefs_shadow_copy_stat, + .lstat_fn = onefs_shadow_copy_lstat, + .unlink_fn = onefs_shadow_copy_unlink, + .chmod_fn = onefs_shadow_copy_chmod, + .chown_fn = onefs_shadow_copy_chown, + .lchown_fn = onefs_shadow_copy_lchown, + .chdir_fn = onefs_shadow_copy_chdir, + .ntimes_fn = onefs_shadow_copy_ntimes, + .symlink_fn = onefs_shadow_copy_symlink, + .readlink_fn = onefs_shadow_copy_readlink, + .link_fn = onefs_shadow_copy_link, + .mknod_fn = onefs_shadow_copy_mknod, + .realpath_fn = onefs_shadow_copy_realpath, + .chflags_fn = onefs_shadow_copy_chflags, + .streaminfo_fn = onefs_shadow_copy_streaminfo, + .get_real_filename_fn = onefs_shadow_copy_get_real_filename, + .get_nt_acl_fn = onefs_shadow_copy_get_nt_acl, + .chmod_acl_fn = onefs_shadow_copy_chmod_acl, + .sys_acl_get_file_fn = onefs_shadow_copy_sys_acl_get_file, + .sys_acl_set_file_fn = onefs_shadow_copy_sys_acl_set_file, + .sys_acl_delete_def_file_fn = onefs_shadow_copy_sys_acl_delete_def_file, + .getxattr_fn = onefs_shadow_copy_getxattr, + .lgetxattr_fn = onefs_shadow_copy_lgetxattr, + .listxattr_fn = onefs_shadow_copy_listxattr, + .llistxattr_fn = onefs_shadow_copy_llistxattr, + .removexattr_fn = onefs_shadow_copy_removexattr, + .lremovexattr_fn = onefs_shadow_copy_lremovexattr, + .setxattr_fn = onefs_shadow_copy_setxattr, + .lsetxattr_fn = onefs_shadow_copy_lsetxattr, + .is_offline_fn = onefs_shadow_copy_is_offline, + .set_offline_fn = onefs_shadow_copy_set_offline, }; NTSTATUS vfs_shadow_copy_init(void) diff --git a/source3/modules/vfs_posixacl.c b/source3/modules/vfs_posixacl.c index e1c5b630cd1..464099176df 100644 --- a/source3/modules/vfs_posixacl.c +++ b/source3/modules/vfs_posixacl.c @@ -364,11 +364,11 @@ static acl_t smb_acl_to_posix(const struct smb_acl_t *acl) /* VFS operations structure */ static struct vfs_fn_pointers posixacl_fns = { - .sys_acl_get_file = posixacl_sys_acl_get_file, - .sys_acl_get_fd = posixacl_sys_acl_get_fd, - .sys_acl_set_file = posixacl_sys_acl_set_file, - .sys_acl_set_fd = posixacl_sys_acl_set_fd, - .sys_acl_delete_def_file = posixacl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = posixacl_sys_acl_get_file, + .sys_acl_get_fd_fn = posixacl_sys_acl_get_fd, + .sys_acl_set_file_fn = posixacl_sys_acl_set_file, + .sys_acl_set_fd_fn = posixacl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = posixacl_sys_acl_delete_def_file, }; NTSTATUS vfs_posixacl_init(void); diff --git a/source3/modules/vfs_prealloc.c b/source3/modules/vfs_prealloc.c index fb2e46e2274..3293b4ec8e0 100644 --- a/source3/modules/vfs_prealloc.c +++ b/source3/modules/vfs_prealloc.c @@ -216,7 +216,7 @@ static int prealloc_ftruncate(vfs_handle_struct * handle, static struct vfs_fn_pointers prealloc_fns = { .open_fn = prealloc_open, - .ftruncate = prealloc_ftruncate, + .ftruncate_fn = prealloc_ftruncate, .connect_fn = prealloc_connect, }; diff --git a/source3/modules/vfs_readahead.c b/source3/modules/vfs_readahead.c index 22f7f703554..8e6fd43aae8 100644 --- a/source3/modules/vfs_readahead.c +++ b/source3/modules/vfs_readahead.c @@ -169,8 +169,8 @@ static int readahead_connect(struct vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_readahead_fns = { - .sendfile = readahead_sendfile, - .pread = readahead_pread, + .sendfile_fn = readahead_sendfile, + .pread_fn = readahead_pread, .connect_fn = readahead_connect }; diff --git a/source3/modules/vfs_recycle.c b/source3/modules/vfs_recycle.c index 03da571d1a4..c735dccd314 100644 --- a/source3/modules/vfs_recycle.c +++ b/source3/modules/vfs_recycle.c @@ -639,7 +639,7 @@ done: } static struct vfs_fn_pointers vfs_recycle_fns = { - .unlink = recycle_unlink + .unlink_fn = recycle_unlink }; NTSTATUS vfs_recycle_init(void); diff --git a/source3/modules/vfs_scannedonly.c b/source3/modules/vfs_scannedonly.c index df1e140f3ce..1b35388b853 100644 --- a/source3/modules/vfs_scannedonly.c +++ b/source3/modules/vfs_scannedonly.c @@ -1016,20 +1016,20 @@ static int scannedonly_connect(struct vfs_handle_struct *handle, /* VFS operations structure */ static struct vfs_fn_pointers vfs_scannedonly_fns = { - .opendir = scannedonly_opendir, - .fdopendir = scannedonly_fdopendir, - .readdir = scannedonly_readdir, - .seekdir = scannedonly_seekdir, - .telldir = scannedonly_telldir, - .rewind_dir = scannedonly_rewinddir, - .closedir = scannedonly_closedir, - .rmdir = scannedonly_rmdir, - .stat = scannedonly_stat, - .lstat = scannedonly_lstat, + .opendir_fn = scannedonly_opendir, + .fdopendir_fn = scannedonly_fdopendir, + .readdir_fn = scannedonly_readdir, + .seekdir_fn = scannedonly_seekdir, + .telldir_fn = scannedonly_telldir, + .rewind_dir_fn = scannedonly_rewinddir, + .closedir_fn = scannedonly_closedir, + .rmdir_fn = scannedonly_rmdir, + .stat_fn = scannedonly_stat, + .lstat_fn = scannedonly_lstat, .open_fn = scannedonly_open, .close_fn = scannedonly_close, - .rename = scannedonly_rename, - .unlink = scannedonly_unlink, + .rename_fn = scannedonly_rename, + .unlink_fn = scannedonly_unlink, .connect_fn = scannedonly_connect }; diff --git a/source3/modules/vfs_shadow_copy.c b/source3/modules/vfs_shadow_copy.c index 1db47d216be..f3f4292cf08 100644 --- a/source3/modules/vfs_shadow_copy.c +++ b/source3/modules/vfs_shadow_copy.c @@ -272,14 +272,14 @@ static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_shadow_copy_fns = { - .opendir = shadow_copy_opendir, - .fdopendir = shadow_copy_fdopendir, - .readdir = shadow_copy_readdir, - .seekdir = shadow_copy_seekdir, - .telldir = shadow_copy_telldir, - .rewind_dir = shadow_copy_rewinddir, - .closedir = shadow_copy_closedir, - .get_shadow_copy_data = shadow_copy_get_shadow_copy_data, + .opendir_fn = shadow_copy_opendir, + .fdopendir_fn = shadow_copy_fdopendir, + .readdir_fn = shadow_copy_readdir, + .seekdir_fn = shadow_copy_seekdir, + .telldir_fn = shadow_copy_telldir, + .rewind_dir_fn = shadow_copy_rewinddir, + .closedir_fn = shadow_copy_closedir, + .get_shadow_copy_data_fn = shadow_copy_get_shadow_copy_data, }; NTSTATUS vfs_shadow_copy_init(void); diff --git a/source3/modules/vfs_shadow_copy2.c b/source3/modules/vfs_shadow_copy2.c index 4ac9e849c4e..02c5b3d5803 100644 --- a/source3/modules/vfs_shadow_copy2.c +++ b/source3/modules/vfs_shadow_copy2.c @@ -1567,37 +1567,37 @@ static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_shadow_copy2_fns = { - .opendir = shadow_copy2_opendir, - .rename = shadow_copy2_rename, - .link = shadow_copy2_link, - .symlink = shadow_copy2_symlink, - .stat = shadow_copy2_stat, - .lstat = shadow_copy2_lstat, - .fstat = shadow_copy2_fstat, + .opendir_fn = shadow_copy2_opendir, + .rename_fn = shadow_copy2_rename, + .link_fn = shadow_copy2_link, + .symlink_fn = shadow_copy2_symlink, + .stat_fn = shadow_copy2_stat, + .lstat_fn = shadow_copy2_lstat, + .fstat_fn = shadow_copy2_fstat, .open_fn = shadow_copy2_open, - .unlink = shadow_copy2_unlink, - .chmod = shadow_copy2_chmod, - .chown = shadow_copy2_chown, - .chdir = shadow_copy2_chdir, - .ntimes = shadow_copy2_ntimes, - .vfs_readlink = shadow_copy2_readlink, - .mknod = shadow_copy2_mknod, - .realpath = shadow_copy2_realpath, - .get_nt_acl = shadow_copy2_get_nt_acl, - .fget_nt_acl = shadow_copy2_fget_nt_acl, - .get_shadow_copy_data = shadow_copy2_get_shadow_copy_data, - .mkdir = shadow_copy2_mkdir, - .rmdir = shadow_copy2_rmdir, - .getxattr = shadow_copy2_getxattr, - .lgetxattr = shadow_copy2_lgetxattr, - .listxattr = shadow_copy2_listxattr, - .removexattr = shadow_copy2_removexattr, - .lremovexattr = shadow_copy2_lremovexattr, - .setxattr = shadow_copy2_setxattr, - .lsetxattr = shadow_copy2_lsetxattr, - .chmod_acl = shadow_copy2_chmod_acl, - .chflags = shadow_copy2_chflags, - .get_real_filename = shadow_copy2_get_real_filename, + .unlink_fn = shadow_copy2_unlink, + .chmod_fn = shadow_copy2_chmod, + .chown_fn = shadow_copy2_chown, + .chdir_fn = shadow_copy2_chdir, + .ntimes_fn = shadow_copy2_ntimes, + .readlink_fn = shadow_copy2_readlink, + .mknod_fn = shadow_copy2_mknod, + .realpath_fn = shadow_copy2_realpath, + .get_nt_acl_fn = shadow_copy2_get_nt_acl, + .fget_nt_acl_fn = shadow_copy2_fget_nt_acl, + .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data, + .mkdir_fn = shadow_copy2_mkdir, + .rmdir_fn = shadow_copy2_rmdir, + .getxattr_fn = shadow_copy2_getxattr, + .lgetxattr_fn = shadow_copy2_lgetxattr, + .listxattr_fn = shadow_copy2_listxattr, + .removexattr_fn = shadow_copy2_removexattr, + .lremovexattr_fn = shadow_copy2_lremovexattr, + .setxattr_fn = shadow_copy2_setxattr, + .lsetxattr_fn = shadow_copy2_lsetxattr, + .chmod_acl_fn = shadow_copy2_chmod_acl, + .chflags_fn = shadow_copy2_chflags, + .get_real_filename_fn = shadow_copy2_get_real_filename, }; NTSTATUS vfs_shadow_copy2_init(void); diff --git a/source3/modules/vfs_smb_traffic_analyzer.c b/source3/modules/vfs_smb_traffic_analyzer.c index 5f05fa68d1e..4d1ffbd06de 100644 --- a/source3/modules/vfs_smb_traffic_analyzer.c +++ b/source3/modules/vfs_smb_traffic_analyzer.c @@ -903,19 +903,19 @@ static int smb_traffic_analyzer_close(vfs_handle_struct *handle, \ static struct vfs_fn_pointers vfs_smb_traffic_analyzer_fns = { - .connect_fn = smb_traffic_analyzer_connect, - .vfs_read = smb_traffic_analyzer_read, - .pread = smb_traffic_analyzer_pread, - .write = smb_traffic_analyzer_write, - .pwrite = smb_traffic_analyzer_pwrite, - .mkdir = smb_traffic_analyzer_mkdir, - .rename = smb_traffic_analyzer_rename, - .chdir = smb_traffic_analyzer_chdir, + .connect_fn = smb_traffic_analyzer_connect, + .read_fn = smb_traffic_analyzer_read, + .pread_fn = smb_traffic_analyzer_pread, + .write_fn = smb_traffic_analyzer_write, + .pwrite_fn = smb_traffic_analyzer_pwrite, + .mkdir_fn = smb_traffic_analyzer_mkdir, + .rename_fn = smb_traffic_analyzer_rename, + .chdir_fn = smb_traffic_analyzer_chdir, .open_fn = smb_traffic_analyzer_open, - .rmdir = smb_traffic_analyzer_rmdir, + .rmdir_fn = smb_traffic_analyzer_rmdir, .close_fn = smb_traffic_analyzer_close, - .sendfile = smb_traffic_analyzer_sendfile, - .recvfile = smb_traffic_analyzer_recvfile + .sendfile_fn = smb_traffic_analyzer_sendfile, + .recvfile_fn = smb_traffic_analyzer_recvfile }; /* Module initialization */ diff --git a/source3/modules/vfs_solarisacl.c b/source3/modules/vfs_solarisacl.c index dabec5a413e..598f25f7f8f 100644 --- a/source3/modules/vfs_solarisacl.c +++ b/source3/modules/vfs_solarisacl.c @@ -752,11 +752,11 @@ static bool solaris_acl_check(SOLARIS_ACL_T solaris_acl, int count) #endif static struct vfs_fn_pointers solarisacl_fns = { - .sys_acl_get_file = solarisacl_sys_acl_get_file, - .sys_acl_get_fd = solarisacl_sys_acl_get_fd, - .sys_acl_set_file = solarisacl_sys_acl_set_file, - .sys_acl_set_fd = solarisacl_sys_acl_set_fd, - .sys_acl_delete_def_file = solarisacl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = solarisacl_sys_acl_get_file, + .sys_acl_get_fd_fn = solarisacl_sys_acl_get_fd, + .sys_acl_set_file_fn = solarisacl_sys_acl_set_file, + .sys_acl_set_fd_fn = solarisacl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = solarisacl_sys_acl_delete_def_file, }; NTSTATUS vfs_solarisacl_init(void); diff --git a/source3/modules/vfs_streams_depot.c b/source3/modules/vfs_streams_depot.c index e1ba6510059..68a14539bd1 100644 --- a/source3/modules/vfs_streams_depot.c +++ b/source3/modules/vfs_streams_depot.c @@ -863,13 +863,13 @@ static uint32_t streams_depot_fs_capabilities(struct vfs_handle_struct *handle, } static struct vfs_fn_pointers vfs_streams_depot_fns = { - .fs_capabilities = streams_depot_fs_capabilities, + .fs_capabilities_fn = streams_depot_fs_capabilities, .open_fn = streams_depot_open, - .stat = streams_depot_stat, - .lstat = streams_depot_lstat, - .unlink = streams_depot_unlink, - .rename = streams_depot_rename, - .streaminfo = streams_depot_streaminfo, + .stat_fn = streams_depot_stat, + .lstat_fn = streams_depot_lstat, + .unlink_fn = streams_depot_unlink, + .rename_fn = streams_depot_rename, + .streaminfo_fn = streams_depot_streaminfo, }; NTSTATUS vfs_streams_depot_init(void); diff --git a/source3/modules/vfs_streams_xattr.c b/source3/modules/vfs_streams_xattr.c index 85647603535..2ac0491f283 100644 --- a/source3/modules/vfs_streams_xattr.c +++ b/source3/modules/vfs_streams_xattr.c @@ -1042,18 +1042,18 @@ static int streams_xattr_fallocate(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_streams_xattr_fns = { - .fs_capabilities = streams_xattr_fs_capabilities, + .fs_capabilities_fn = streams_xattr_fs_capabilities, .open_fn = streams_xattr_open, - .stat = streams_xattr_stat, - .fstat = streams_xattr_fstat, - .lstat = streams_xattr_lstat, - .pread = streams_xattr_pread, - .pwrite = streams_xattr_pwrite, - .unlink = streams_xattr_unlink, - .rename = streams_xattr_rename, - .ftruncate = streams_xattr_ftruncate, - .fallocate = streams_xattr_fallocate, - .streaminfo = streams_xattr_streaminfo, + .stat_fn = streams_xattr_stat, + .fstat_fn = streams_xattr_fstat, + .lstat_fn = streams_xattr_lstat, + .pread_fn = streams_xattr_pread, + .pwrite_fn = streams_xattr_pwrite, + .unlink_fn = streams_xattr_unlink, + .rename_fn = streams_xattr_rename, + .ftruncate_fn = streams_xattr_ftruncate, + .fallocate_fn = streams_xattr_fallocate, + .streaminfo_fn = streams_xattr_streaminfo, }; NTSTATUS vfs_streams_xattr_init(void); diff --git a/source3/modules/vfs_syncops.c b/source3/modules/vfs_syncops.c index a792fb4b8d0..8ff283d1919 100644 --- a/source3/modules/vfs_syncops.c +++ b/source3/modules/vfs_syncops.c @@ -280,14 +280,14 @@ static int syncops_connect(struct vfs_handle_struct *handle, const char *service static struct vfs_fn_pointers vfs_syncops_fns = { .connect_fn = syncops_connect, - .mkdir = syncops_mkdir, - .rmdir = syncops_rmdir, - .open_fn = syncops_open, - .rename = syncops_rename, - .unlink = syncops_unlink, - .symlink = syncops_symlink, - .link = syncops_link, - .mknod = syncops_mknod, + .mkdir_fn = syncops_mkdir, + .rmdir_fn = syncops_rmdir, + .open_fn = syncops_open, + .rename_fn = syncops_rename, + .unlink_fn = syncops_unlink, + .symlink_fn = syncops_symlink, + .link_fn = syncops_link, + .mknod_fn = syncops_mknod, .close_fn = syncops_close, }; diff --git a/source3/modules/vfs_time_audit.c b/source3/modules/vfs_time_audit.c index 25332e4e038..734625e4e92 100644 --- a/source3/modules/vfs_time_audit.c +++ b/source3/modules/vfs_time_audit.c @@ -2338,118 +2338,118 @@ static bool smb_time_audit_aio_force(struct vfs_handle_struct *handle, static struct vfs_fn_pointers vfs_time_audit_fns = { .connect_fn = smb_time_audit_connect, - .disconnect = smb_time_audit_disconnect, - .disk_free = smb_time_audit_disk_free, - .get_quota = smb_time_audit_get_quota, - .set_quota = smb_time_audit_set_quota, - .get_shadow_copy_data = smb_time_audit_get_shadow_copy_data, - .statvfs = smb_time_audit_statvfs, - .fs_capabilities = smb_time_audit_fs_capabilities, - .opendir = smb_time_audit_opendir, - .fdopendir = smb_time_audit_fdopendir, - .readdir = smb_time_audit_readdir, - .seekdir = smb_time_audit_seekdir, - .telldir = smb_time_audit_telldir, - .rewind_dir = smb_time_audit_rewinddir, - .mkdir = smb_time_audit_mkdir, - .rmdir = smb_time_audit_rmdir, - .closedir = smb_time_audit_closedir, - .init_search_op = smb_time_audit_init_search_op, + .disconnect_fn = smb_time_audit_disconnect, + .disk_free_fn = smb_time_audit_disk_free, + .get_quota_fn = smb_time_audit_get_quota, + .set_quota_fn = smb_time_audit_set_quota, + .get_shadow_copy_data_fn = smb_time_audit_get_shadow_copy_data, + .statvfs_fn = smb_time_audit_statvfs, + .fs_capabilities_fn = smb_time_audit_fs_capabilities, + .opendir_fn = smb_time_audit_opendir, + .fdopendir_fn = smb_time_audit_fdopendir, + .readdir_fn = smb_time_audit_readdir, + .seekdir_fn = smb_time_audit_seekdir, + .telldir_fn = smb_time_audit_telldir, + .rewind_dir_fn = smb_time_audit_rewinddir, + .mkdir_fn = smb_time_audit_mkdir, + .rmdir_fn = smb_time_audit_rmdir, + .closedir_fn = smb_time_audit_closedir, + .init_search_op_fn = smb_time_audit_init_search_op, .open_fn = smb_time_audit_open, - .create_file = smb_time_audit_create_file, + .create_file_fn = smb_time_audit_create_file, .close_fn = smb_time_audit_close, - .vfs_read = smb_time_audit_read, - .pread = smb_time_audit_pread, - .write = smb_time_audit_write, - .pwrite = smb_time_audit_pwrite, - .lseek = smb_time_audit_lseek, - .sendfile = smb_time_audit_sendfile, - .recvfile = smb_time_audit_recvfile, - .rename = smb_time_audit_rename, - .fsync = smb_time_audit_fsync, - .stat = smb_time_audit_stat, - .fstat = smb_time_audit_fstat, - .lstat = smb_time_audit_lstat, - .get_alloc_size = smb_time_audit_get_alloc_size, - .unlink = smb_time_audit_unlink, - .chmod = smb_time_audit_chmod, - .fchmod = smb_time_audit_fchmod, - .chown = smb_time_audit_chown, - .fchown = smb_time_audit_fchown, - .lchown = smb_time_audit_lchown, - .chdir = smb_time_audit_chdir, - .getwd = smb_time_audit_getwd, - .ntimes = smb_time_audit_ntimes, - .ftruncate = smb_time_audit_ftruncate, - .fallocate = smb_time_audit_fallocate, - .lock = smb_time_audit_lock, - .kernel_flock = smb_time_audit_kernel_flock, - .linux_setlease = smb_time_audit_linux_setlease, - .getlock = smb_time_audit_getlock, - .symlink = smb_time_audit_symlink, - .vfs_readlink = smb_time_audit_readlink, - .link = smb_time_audit_link, - .mknod = smb_time_audit_mknod, - .realpath = smb_time_audit_realpath, - .notify_watch = smb_time_audit_notify_watch, - .chflags = smb_time_audit_chflags, - .file_id_create = smb_time_audit_file_id_create, - .streaminfo = smb_time_audit_streaminfo, - .get_real_filename = smb_time_audit_get_real_filename, - .connectpath = smb_time_audit_connectpath, - .brl_lock_windows = smb_time_audit_brl_lock_windows, - .brl_unlock_windows = smb_time_audit_brl_unlock_windows, - .brl_cancel_windows = smb_time_audit_brl_cancel_windows, - .strict_lock = smb_time_audit_strict_lock, - .strict_unlock = smb_time_audit_strict_unlock, - .translate_name = smb_time_audit_translate_name, - .fget_nt_acl = smb_time_audit_fget_nt_acl, - .get_nt_acl = smb_time_audit_get_nt_acl, - .fset_nt_acl = smb_time_audit_fset_nt_acl, - .chmod_acl = smb_time_audit_chmod_acl, - .fchmod_acl = smb_time_audit_fchmod_acl, - .sys_acl_get_entry = smb_time_audit_sys_acl_get_entry, - .sys_acl_get_tag_type = smb_time_audit_sys_acl_get_tag_type, - .sys_acl_get_permset = smb_time_audit_sys_acl_get_permset, - .sys_acl_get_qualifier = smb_time_audit_sys_acl_get_qualifier, - .sys_acl_get_file = smb_time_audit_sys_acl_get_file, - .sys_acl_get_fd = smb_time_audit_sys_acl_get_fd, - .sys_acl_clear_perms = smb_time_audit_sys_acl_clear_perms, - .sys_acl_add_perm = smb_time_audit_sys_acl_add_perm, - .sys_acl_to_text = smb_time_audit_sys_acl_to_text, - .sys_acl_init = smb_time_audit_sys_acl_init, - .sys_acl_create_entry = smb_time_audit_sys_acl_create_entry, - .sys_acl_set_tag_type = smb_time_audit_sys_acl_set_tag_type, - .sys_acl_set_qualifier = smb_time_audit_sys_acl_set_qualifier, - .sys_acl_set_permset = smb_time_audit_sys_acl_set_permset, - .sys_acl_valid = smb_time_audit_sys_acl_valid, - .sys_acl_set_file = smb_time_audit_sys_acl_set_file, - .sys_acl_set_fd = smb_time_audit_sys_acl_set_fd, - .sys_acl_delete_def_file = smb_time_audit_sys_acl_delete_def_file, - .sys_acl_get_perm = smb_time_audit_sys_acl_get_perm, - .sys_acl_free_text = smb_time_audit_sys_acl_free_text, - .sys_acl_free_acl = smb_time_audit_sys_acl_free_acl, - .sys_acl_free_qualifier = smb_time_audit_sys_acl_free_qualifier, - .getxattr = smb_time_audit_getxattr, - .lgetxattr = smb_time_audit_lgetxattr, - .fgetxattr = smb_time_audit_fgetxattr, - .listxattr = smb_time_audit_listxattr, - .llistxattr = smb_time_audit_llistxattr, - .flistxattr = smb_time_audit_flistxattr, - .removexattr = smb_time_audit_removexattr, - .lremovexattr = smb_time_audit_lremovexattr, - .fremovexattr = smb_time_audit_fremovexattr, - .setxattr = smb_time_audit_setxattr, - .lsetxattr = smb_time_audit_lsetxattr, - .fsetxattr = smb_time_audit_fsetxattr, - .aio_read = smb_time_audit_aio_read, - .aio_write = smb_time_audit_aio_write, + .read_fn = smb_time_audit_read, + .pread_fn = smb_time_audit_pread, + .write_fn = smb_time_audit_write, + .pwrite_fn = smb_time_audit_pwrite, + .lseek_fn = smb_time_audit_lseek, + .sendfile_fn = smb_time_audit_sendfile, + .recvfile_fn = smb_time_audit_recvfile, + .rename_fn = smb_time_audit_rename, + .fsync_fn = smb_time_audit_fsync, + .stat_fn = smb_time_audit_stat, + .fstat_fn = smb_time_audit_fstat, + .lstat_fn = smb_time_audit_lstat, + .get_alloc_size_fn = smb_time_audit_get_alloc_size, + .unlink_fn = smb_time_audit_unlink, + .chmod_fn = smb_time_audit_chmod, + .fchmod_fn = smb_time_audit_fchmod, + .chown_fn = smb_time_audit_chown, + .fchown_fn = smb_time_audit_fchown, + .lchown_fn = smb_time_audit_lchown, + .chdir_fn = smb_time_audit_chdir, + .getwd_fn = smb_time_audit_getwd, + .ntimes_fn = smb_time_audit_ntimes, + .ftruncate_fn = smb_time_audit_ftruncate, + .fallocate_fn = smb_time_audit_fallocate, + .lock_fn = smb_time_audit_lock, + .kernel_flock_fn = smb_time_audit_kernel_flock, + .linux_setlease_fn = smb_time_audit_linux_setlease, + .getlock_fn = smb_time_audit_getlock, + .symlink_fn = smb_time_audit_symlink, + .readlink_fn = smb_time_audit_readlink, + .link_fn = smb_time_audit_link, + .mknod_fn = smb_time_audit_mknod, + .realpath_fn = smb_time_audit_realpath, + .notify_watch_fn = smb_time_audit_notify_watch, + .chflags_fn = smb_time_audit_chflags, + .file_id_create_fn = smb_time_audit_file_id_create, + .streaminfo_fn = smb_time_audit_streaminfo, + .get_real_filename_fn = smb_time_audit_get_real_filename, + .connectpath_fn = smb_time_audit_connectpath, + .brl_lock_windows_fn = smb_time_audit_brl_lock_windows, + .brl_unlock_windows_fn = smb_time_audit_brl_unlock_windows, + .brl_cancel_windows_fn = smb_time_audit_brl_cancel_windows, + .strict_lock_fn = smb_time_audit_strict_lock, + .strict_unlock_fn = smb_time_audit_strict_unlock, + .translate_name_fn = smb_time_audit_translate_name, + .fget_nt_acl_fn = smb_time_audit_fget_nt_acl, + .get_nt_acl_fn = smb_time_audit_get_nt_acl, + .fset_nt_acl_fn = smb_time_audit_fset_nt_acl, + .chmod_acl_fn = smb_time_audit_chmod_acl, + .fchmod_acl_fn = smb_time_audit_fchmod_acl, + .sys_acl_get_entry_fn = smb_time_audit_sys_acl_get_entry, + .sys_acl_get_tag_type_fn = smb_time_audit_sys_acl_get_tag_type, + .sys_acl_get_permset_fn = smb_time_audit_sys_acl_get_permset, + .sys_acl_get_qualifier_fn = smb_time_audit_sys_acl_get_qualifier, + .sys_acl_get_file_fn = smb_time_audit_sys_acl_get_file, + .sys_acl_get_fd_fn = smb_time_audit_sys_acl_get_fd, + .sys_acl_clear_perms_fn = smb_time_audit_sys_acl_clear_perms, + .sys_acl_add_perm_fn = smb_time_audit_sys_acl_add_perm, + .sys_acl_to_text_fn = smb_time_audit_sys_acl_to_text, + .sys_acl_init_fn = smb_time_audit_sys_acl_init, + .sys_acl_create_entry_fn = smb_time_audit_sys_acl_create_entry, + .sys_acl_set_tag_type_fn = smb_time_audit_sys_acl_set_tag_type, + .sys_acl_set_qualifier_fn = smb_time_audit_sys_acl_set_qualifier, + .sys_acl_set_permset_fn = smb_time_audit_sys_acl_set_permset, + .sys_acl_valid_fn = smb_time_audit_sys_acl_valid, + .sys_acl_set_file_fn = smb_time_audit_sys_acl_set_file, + .sys_acl_set_fd_fn = smb_time_audit_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = smb_time_audit_sys_acl_delete_def_file, + .sys_acl_get_perm_fn = smb_time_audit_sys_acl_get_perm, + .sys_acl_free_text_fn = smb_time_audit_sys_acl_free_text, + .sys_acl_free_acl_fn = smb_time_audit_sys_acl_free_acl, + .sys_acl_free_qualifier_fn = smb_time_audit_sys_acl_free_qualifier, + .getxattr_fn = smb_time_audit_getxattr, + .lgetxattr_fn = smb_time_audit_lgetxattr, + .fgetxattr_fn = smb_time_audit_fgetxattr, + .listxattr_fn = smb_time_audit_listxattr, + .llistxattr_fn = smb_time_audit_llistxattr, + .flistxattr_fn = smb_time_audit_flistxattr, + .removexattr_fn = smb_time_audit_removexattr, + .lremovexattr_fn = smb_time_audit_lremovexattr, + .fremovexattr_fn = smb_time_audit_fremovexattr, + .setxattr_fn = smb_time_audit_setxattr, + .lsetxattr_fn = smb_time_audit_lsetxattr, + .fsetxattr_fn = smb_time_audit_fsetxattr, + .aio_read_fn = smb_time_audit_aio_read, + .aio_write_fn = smb_time_audit_aio_write, .aio_return_fn = smb_time_audit_aio_return, - .aio_cancel = smb_time_audit_aio_cancel, + .aio_cancel_fn = smb_time_audit_aio_cancel, .aio_error_fn = smb_time_audit_aio_error, - .aio_fsync = smb_time_audit_aio_fsync, - .aio_suspend = smb_time_audit_aio_suspend, - .aio_force = smb_time_audit_aio_force, + .aio_fsync_fn = smb_time_audit_aio_fsync, + .aio_suspend_fn = smb_time_audit_aio_suspend, + .aio_force_fn = smb_time_audit_aio_force, }; diff --git a/source3/modules/vfs_tru64acl.c b/source3/modules/vfs_tru64acl.c index 39fc6e9ac37..3f91a4753a2 100644 --- a/source3/modules/vfs_tru64acl.c +++ b/source3/modules/vfs_tru64acl.c @@ -470,11 +470,11 @@ static SMB_ACL_PERM_T tru64_permset_to_smb(const acl_perm_t tru64_permset) /* VFS operations structure */ static struct vfs_fn_pointers tru64acl_fns = { - .sys_acl_get_file = tru64acl_sys_acl_get_file, - .sys_acl_get_fd = tru64acl_sys_acl_get_fd, - .sys_acl_set_file = tru64acl_sys_acl_set_file, - .sys_acl_set_fd = tru64acl_sys_acl_set_fd, - .sys_acl_delete_def_file = tru64acl_sys_acl_delete_def_file, + .sys_acl_get_file_fn = tru64acl_sys_acl_get_file, + .sys_acl_get_fd_fn = tru64acl_sys_acl_get_fd, + .sys_acl_set_file_fn = tru64acl_sys_acl_set_file, + .sys_acl_set_fd_fn = tru64acl_sys_acl_set_fd, + .sys_acl_delete_def_file_fn = tru64acl_sys_acl_delete_def_file, }; NTSTATUS vfs_tru64acl_init(void); diff --git a/source3/modules/vfs_tsmsm.c b/source3/modules/vfs_tsmsm.c index e9fd83bfea7..468fe679fc4 100644 --- a/source3/modules/vfs_tsmsm.c +++ b/source3/modules/vfs_tsmsm.c @@ -392,14 +392,14 @@ static uint32_t tsmsm_fs_capabilities(struct vfs_handle_struct *handle, static struct vfs_fn_pointers tsmsm_fns = { .connect_fn = tsmsm_connect, - .fs_capabilities = tsmsm_fs_capabilities, - .aio_force = tsmsm_aio_force, + .fs_capabilities_fn = tsmsm_fs_capabilities, + .aio_force_fn = tsmsm_aio_force, .aio_return_fn = tsmsm_aio_return, - .pread = tsmsm_pread, - .pwrite = tsmsm_pwrite, - .sendfile = tsmsm_sendfile, - .is_offline = tsmsm_is_offline, - .set_offline = tsmsm_set_offline, + .pread_fn = tsmsm_pread, + .pwrite_fn = tsmsm_pwrite, + .sendfile_fn = tsmsm_sendfile, + .is_offline_fn = tsmsm_is_offline, + .set_offline_fn = tsmsm_set_offline, }; NTSTATUS vfs_tsmsm_init(void); diff --git a/source3/modules/vfs_xattr_tdb.c b/source3/modules/vfs_xattr_tdb.c index 72624686f74..8f367f359a7 100644 --- a/source3/modules/vfs_xattr_tdb.c +++ b/source3/modules/vfs_xattr_tdb.c @@ -767,16 +767,16 @@ static int xattr_tdb_connect(vfs_handle_struct *handle, const char *service, } static struct vfs_fn_pointers vfs_xattr_tdb_fns = { - .getxattr = xattr_tdb_getxattr, - .fgetxattr = xattr_tdb_fgetxattr, - .setxattr = xattr_tdb_setxattr, - .fsetxattr = xattr_tdb_fsetxattr, - .listxattr = xattr_tdb_listxattr, - .flistxattr = xattr_tdb_flistxattr, - .removexattr = xattr_tdb_removexattr, - .fremovexattr = xattr_tdb_fremovexattr, - .unlink = xattr_tdb_unlink, - .rmdir = xattr_tdb_rmdir, + .getxattr_fn = xattr_tdb_getxattr, + .fgetxattr_fn = xattr_tdb_fgetxattr, + .setxattr_fn = xattr_tdb_setxattr, + .fsetxattr_fn = xattr_tdb_fsetxattr, + .listxattr_fn = xattr_tdb_listxattr, + .flistxattr_fn = xattr_tdb_flistxattr, + .removexattr_fn = xattr_tdb_removexattr, + .fremovexattr_fn = xattr_tdb_fremovexattr, + .unlink_fn = xattr_tdb_unlink, + .rmdir_fn = xattr_tdb_rmdir, .connect_fn = xattr_tdb_connect, }; diff --git a/source3/modules/vfs_zfsacl.c b/source3/modules/vfs_zfsacl.c index fbfe7794e70..7858a6a4753 100644 --- a/source3/modules/vfs_zfsacl.c +++ b/source3/modules/vfs_zfsacl.c @@ -300,14 +300,14 @@ static int zfsacl_fail__sys_acl_delete_def_file(vfs_handle_struct *handle, /* VFS operations structure */ static struct vfs_fn_pointers zfsacl_fns = { - .sys_acl_get_file = zfsacl_fail__sys_acl_get_file, - .sys_acl_get_fd = zfsacl_fail__sys_acl_get_fd, - .sys_acl_set_file = zfsacl_fail__sys_acl_set_file, - .sys_acl_set_fd = zfsacl_fail__sys_acl_set_fd, - .sys_acl_delete_def_file = zfsacl_fail__sys_acl_delete_def_file, - .fget_nt_acl = zfsacl_fget_nt_acl, - .get_nt_acl = zfsacl_get_nt_acl, - .fset_nt_acl = zfsacl_fset_nt_acl, + .sys_acl_get_file_fn = zfsacl_fail__sys_acl_get_file, + .sys_acl_get_fd_fn = zfsacl_fail__sys_acl_get_fd, + .sys_acl_set_file_fn = zfsacl_fail__sys_acl_set_file, + .sys_acl_set_fd_fn = zfsacl_fail__sys_acl_set_fd, + .sys_acl_delete_def_file_fn = zfsacl_fail__sys_acl_delete_def_file, + .fget_nt_acl_fn = zfsacl_fget_nt_acl, + .get_nt_acl_fn = zfsacl_get_nt_acl, + .fset_nt_acl_fn = zfsacl_fset_nt_acl, }; NTSTATUS vfs_zfsacl_init(void); diff --git a/source3/smbd/vfs.c b/source3/smbd/vfs.c index 1424d502d69..6239ad47966 100644 --- a/source3/smbd/vfs.c +++ b/source3/smbd/vfs.c @@ -1152,14 +1152,14 @@ struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_S int smb_vfs_call_connect(struct vfs_handle_struct *handle, const char *service, const char *user) { - VFS_FIND(connect_fn); + VFS_FIND(connect); return handle->fns->connect_fn(handle, service, user); } void smb_vfs_call_disconnect(struct vfs_handle_struct *handle) { VFS_FIND(disconnect); - handle->fns->disconnect(handle); + handle->fns->disconnect_fn(handle); } uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle, @@ -1168,8 +1168,8 @@ uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle, uint64_t *dsize) { VFS_FIND(disk_free); - return handle->fns->disk_free(handle, path, small_query, bsize, dfree, - dsize); + return handle->fns->disk_free_fn(handle, path, small_query, bsize, + dfree, dsize); } int smb_vfs_call_get_quota(struct vfs_handle_struct *handle, @@ -1177,7 +1177,7 @@ int smb_vfs_call_get_quota(struct vfs_handle_struct *handle, SMB_DISK_QUOTA *qt) { VFS_FIND(get_quota); - return handle->fns->get_quota(handle, qtype, id, qt); + return handle->fns->get_quota_fn(handle, qtype, id, qt); } int smb_vfs_call_set_quota(struct vfs_handle_struct *handle, @@ -1185,7 +1185,7 @@ int smb_vfs_call_set_quota(struct vfs_handle_struct *handle, SMB_DISK_QUOTA *qt) { VFS_FIND(set_quota); - return handle->fns->set_quota(handle, qtype, id, qt); + return handle->fns->set_quota_fn(handle, qtype, id, qt); } int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle, @@ -1194,28 +1194,29 @@ int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle, bool labels) { VFS_FIND(get_shadow_copy_data); - return handle->fns->get_shadow_copy_data(handle, fsp, shadow_copy_data, - labels); + return handle->fns->get_shadow_copy_data_fn(handle, fsp, + shadow_copy_data, + labels); } int smb_vfs_call_statvfs(struct vfs_handle_struct *handle, const char *path, struct vfs_statvfs_struct *statbuf) { VFS_FIND(statvfs); - return handle->fns->statvfs(handle, path, statbuf); + return handle->fns->statvfs_fn(handle, path, statbuf); } uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle, enum timestamp_set_resolution *p_ts_res) { VFS_FIND(fs_capabilities); - return handle->fns->fs_capabilities(handle, p_ts_res); + return handle->fns->fs_capabilities_fn(handle, p_ts_res); } NTSTATUS smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct *handle, struct dfs_GetDFSReferral *r) { VFS_FIND(get_dfs_referrals); - return handle->fns->get_dfs_referrals(handle, r); + return handle->fns->get_dfs_referrals_fn(handle, r); } SMB_STRUCT_DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle, @@ -1223,7 +1224,7 @@ SMB_STRUCT_DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle, uint32 attributes) { VFS_FIND(opendir); - return handle->fns->opendir(handle, fname, mask, attributes); + return handle->fns->opendir_fn(handle, fname, mask, attributes); } SMB_STRUCT_DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle, @@ -1232,7 +1233,7 @@ SMB_STRUCT_DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle, uint32 attributes) { VFS_FIND(fdopendir); - return handle->fns->fdopendir(handle, fsp, mask, attributes); + return handle->fns->fdopendir_fn(handle, fsp, mask, attributes); } SMB_STRUCT_DIRENT *smb_vfs_call_readdir(struct vfs_handle_struct *handle, @@ -1240,62 +1241,62 @@ SMB_STRUCT_DIRENT *smb_vfs_call_readdir(struct vfs_handle_struct *handle, SMB_STRUCT_STAT *sbuf) { VFS_FIND(readdir); - return handle->fns->readdir(handle, dirp, sbuf); + return handle->fns->readdir_fn(handle, dirp, sbuf); } void smb_vfs_call_seekdir(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset) { VFS_FIND(seekdir); - handle->fns->seekdir(handle, dirp, offset); + handle->fns->seekdir_fn(handle, dirp, offset); } long smb_vfs_call_telldir(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp) { VFS_FIND(telldir); - return handle->fns->telldir(handle, dirp); + return handle->fns->telldir_fn(handle, dirp); } void smb_vfs_call_rewind_dir(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp) { VFS_FIND(rewind_dir); - handle->fns->rewind_dir(handle, dirp); + handle->fns->rewind_dir_fn(handle, dirp); } int smb_vfs_call_mkdir(struct vfs_handle_struct *handle, const char *path, mode_t mode) { VFS_FIND(mkdir); - return handle->fns->mkdir(handle, path, mode); + return handle->fns->mkdir_fn(handle, path, mode); } int smb_vfs_call_rmdir(struct vfs_handle_struct *handle, const char *path) { VFS_FIND(rmdir); - return handle->fns->rmdir(handle, path); + return handle->fns->rmdir_fn(handle, path); } int smb_vfs_call_closedir(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dir) { VFS_FIND(closedir); - return handle->fns->closedir(handle, dir); + return handle->fns->closedir_fn(handle, dir); } void smb_vfs_call_init_search_op(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp) { VFS_FIND(init_search_op); - handle->fns->init_search_op(handle, dirp); + handle->fns->init_search_op_fn(handle, dirp); } int smb_vfs_call_open(struct vfs_handle_struct *handle, struct smb_filename *smb_fname, struct files_struct *fsp, int flags, mode_t mode) { - VFS_FIND(open_fn); + VFS_FIND(open); return handle->fns->open_fn(handle, smb_fname, fsp, flags, mode); } @@ -1317,7 +1318,7 @@ NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle, int *pinfo) { VFS_FIND(create_file); - return handle->fns->create_file( + return handle->fns->create_file_fn( handle, req, root_dir_fid, smb_fname, access_mask, share_access, create_disposition, create_options, file_attributes, oplock_request, allocation_size, @@ -1325,18 +1326,18 @@ NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle, result, pinfo); } -int smb_vfs_call_close_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp) +int smb_vfs_call_close(struct vfs_handle_struct *handle, + struct files_struct *fsp) { - VFS_FIND(close_fn); + VFS_FIND(close); return handle->fns->close_fn(handle, fsp); } -ssize_t smb_vfs_call_vfs_read(struct vfs_handle_struct *handle, - struct files_struct *fsp, void *data, size_t n) +ssize_t smb_vfs_call_read(struct vfs_handle_struct *handle, + struct files_struct *fsp, void *data, size_t n) { - VFS_FIND(vfs_read); - return handle->fns->vfs_read(handle, fsp, data, n); + VFS_FIND(read); + return handle->fns->read_fn(handle, fsp, data, n); } ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle, @@ -1344,7 +1345,7 @@ ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle, SMB_OFF_T offset) { VFS_FIND(pread); - return handle->fns->pread(handle, fsp, data, n, offset); + return handle->fns->pread_fn(handle, fsp, data, n, offset); } ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle, @@ -1352,7 +1353,7 @@ ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle, size_t n) { VFS_FIND(write); - return handle->fns->write(handle, fsp, data, n); + return handle->fns->write_fn(handle, fsp, data, n); } ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle, @@ -1360,7 +1361,7 @@ ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle, size_t n, SMB_OFF_T offset) { VFS_FIND(pwrite); - return handle->fns->pwrite(handle, fsp, data, n, offset); + return handle->fns->pwrite_fn(handle, fsp, data, n, offset); } SMB_OFF_T smb_vfs_call_lseek(struct vfs_handle_struct *handle, @@ -1368,7 +1369,7 @@ SMB_OFF_T smb_vfs_call_lseek(struct vfs_handle_struct *handle, int whence) { VFS_FIND(lseek); - return handle->fns->lseek(handle, fsp, offset, whence); + return handle->fns->lseek_fn(handle, fsp, offset, whence); } ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd, @@ -1376,8 +1377,8 @@ ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd, SMB_OFF_T offset, size_t count) { VFS_FIND(sendfile); - return handle->fns->sendfile(handle, tofd, fromfsp, header, offset, - count); + return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset, + count); } ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd, @@ -1385,7 +1386,7 @@ ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd, size_t count) { VFS_FIND(recvfile); - return handle->fns->recvfile(handle, fromfd, tofsp, offset, count); + return handle->fns->recvfile_fn(handle, fromfd, tofsp, offset, count); } int smb_vfs_call_rename(struct vfs_handle_struct *handle, @@ -1393,35 +1394,35 @@ int smb_vfs_call_rename(struct vfs_handle_struct *handle, const struct smb_filename *smb_fname_dst) { VFS_FIND(rename); - return handle->fns->rename(handle, smb_fname_src, smb_fname_dst); + return handle->fns->rename_fn(handle, smb_fname_src, smb_fname_dst); } int smb_vfs_call_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp) { VFS_FIND(fsync); - return handle->fns->fsync(handle, fsp); + return handle->fns->fsync_fn(handle, fsp); } int smb_vfs_call_stat(struct vfs_handle_struct *handle, struct smb_filename *smb_fname) { VFS_FIND(stat); - return handle->fns->stat(handle, smb_fname); + return handle->fns->stat_fn(handle, smb_fname); } int smb_vfs_call_fstat(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_STAT *sbuf) { VFS_FIND(fstat); - return handle->fns->fstat(handle, fsp, sbuf); + return handle->fns->fstat_fn(handle, fsp, sbuf); } int smb_vfs_call_lstat(struct vfs_handle_struct *handle, struct smb_filename *smb_filename) { VFS_FIND(lstat); - return handle->fns->lstat(handle, smb_filename); + return handle->fns->lstat_fn(handle, smb_filename); } uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle, @@ -1429,49 +1430,49 @@ uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle, const SMB_STRUCT_STAT *sbuf) { VFS_FIND(get_alloc_size); - return handle->fns->get_alloc_size(handle, fsp, sbuf); + return handle->fns->get_alloc_size_fn(handle, fsp, sbuf); } int smb_vfs_call_unlink(struct vfs_handle_struct *handle, const struct smb_filename *smb_fname) { VFS_FIND(unlink); - return handle->fns->unlink(handle, smb_fname); + return handle->fns->unlink_fn(handle, smb_fname); } int smb_vfs_call_chmod(struct vfs_handle_struct *handle, const char *path, mode_t mode) { VFS_FIND(chmod); - return handle->fns->chmod(handle, path, mode); + return handle->fns->chmod_fn(handle, path, mode); } int smb_vfs_call_fchmod(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode) { VFS_FIND(fchmod); - return handle->fns->fchmod(handle, fsp, mode); + return handle->fns->fchmod_fn(handle, fsp, mode); } int smb_vfs_call_chown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid) { VFS_FIND(chown); - return handle->fns->chown(handle, path, uid, gid); + return handle->fns->chown_fn(handle, path, uid, gid); } int smb_vfs_call_fchown(struct vfs_handle_struct *handle, struct files_struct *fsp, uid_t uid, gid_t gid) { VFS_FIND(fchown); - return handle->fns->fchown(handle, fsp, uid, gid); + return handle->fns->fchown_fn(handle, fsp, uid, gid); } int smb_vfs_call_lchown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid) { VFS_FIND(lchown); - return handle->fns->lchown(handle, path, uid, gid); + return handle->fns->lchown_fn(handle, path, uid, gid); } NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid) @@ -1577,13 +1578,13 @@ NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid) int smb_vfs_call_chdir(struct vfs_handle_struct *handle, const char *path) { VFS_FIND(chdir); - return handle->fns->chdir(handle, path); + return handle->fns->chdir_fn(handle, path); } char *smb_vfs_call_getwd(struct vfs_handle_struct *handle) { VFS_FIND(getwd); - return handle->fns->getwd(handle); + return handle->fns->getwd_fn(handle); } int smb_vfs_call_ntimes(struct vfs_handle_struct *handle, @@ -1591,14 +1592,14 @@ int smb_vfs_call_ntimes(struct vfs_handle_struct *handle, struct smb_file_time *ft) { VFS_FIND(ntimes); - return handle->fns->ntimes(handle, smb_fname, ft); + return handle->fns->ntimes_fn(handle, smb_fname, ft); } int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_OFF_T offset) { VFS_FIND(ftruncate); - return handle->fns->ftruncate(handle, fsp, offset); + return handle->fns->ftruncate_fn(handle, fsp, offset); } int smb_vfs_call_fallocate(struct vfs_handle_struct *handle, @@ -1608,7 +1609,7 @@ int smb_vfs_call_fallocate(struct vfs_handle_struct *handle, SMB_OFF_T len) { VFS_FIND(fallocate); - return handle->fns->fallocate(handle, fsp, mode, offset, len); + return handle->fns->fallocate_fn(handle, fsp, mode, offset, len); } int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle, @@ -1616,7 +1617,7 @@ int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle, uint32_t access_mask) { VFS_FIND(kernel_flock); - return handle->fns->kernel_flock(handle, fsp, share_mode, + return handle->fns->kernel_flock_fn(handle, fsp, share_mode, access_mask); } @@ -1624,41 +1625,41 @@ int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype) { VFS_FIND(linux_setlease); - return handle->fns->linux_setlease(handle, fsp, leasetype); + return handle->fns->linux_setlease_fn(handle, fsp, leasetype); } int smb_vfs_call_symlink(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath) { VFS_FIND(symlink); - return handle->fns->symlink(handle, oldpath, newpath); + return handle->fns->symlink_fn(handle, oldpath, newpath); } -int smb_vfs_call_vfs_readlink(struct vfs_handle_struct *handle, +int smb_vfs_call_readlink(struct vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz) { - VFS_FIND(vfs_readlink); - return handle->fns->vfs_readlink(handle, path, buf, bufsiz); + VFS_FIND(readlink); + return handle->fns->readlink_fn(handle, path, buf, bufsiz); } int smb_vfs_call_link(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath) { VFS_FIND(link); - return handle->fns->link(handle, oldpath, newpath); + return handle->fns->link_fn(handle, oldpath, newpath); } int smb_vfs_call_mknod(struct vfs_handle_struct *handle, const char *path, mode_t mode, SMB_DEV_T dev) { VFS_FIND(mknod); - return handle->fns->mknod(handle, path, mode, dev); + return handle->fns->mknod_fn(handle, path, mode, dev); } char *smb_vfs_call_realpath(struct vfs_handle_struct *handle, const char *path) { VFS_FIND(realpath); - return handle->fns->realpath(handle, path); + return handle->fns->realpath_fn(handle, path); } NTSTATUS smb_vfs_call_notify_watch(struct vfs_handle_struct *handle, @@ -1670,22 +1671,22 @@ NTSTATUS smb_vfs_call_notify_watch(struct vfs_handle_struct *handle, void *private_data, void *handle_p) { VFS_FIND(notify_watch); - return handle->fns->notify_watch(handle, ctx, e, callback, - private_data, handle_p); + return handle->fns->notify_watch_fn(handle, ctx, e, callback, + private_data, handle_p); } int smb_vfs_call_chflags(struct vfs_handle_struct *handle, const char *path, unsigned int flags) { VFS_FIND(chflags); - return handle->fns->chflags(handle, path, flags); + return handle->fns->chflags_fn(handle, path, flags); } struct file_id smb_vfs_call_file_id_create(struct vfs_handle_struct *handle, const SMB_STRUCT_STAT *sbuf) { VFS_FIND(file_id_create); - return handle->fns->file_id_create(handle, sbuf); + return handle->fns->file_id_create_fn(handle, sbuf); } NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle, @@ -1696,8 +1697,8 @@ NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle, struct stream_struct **streams) { VFS_FIND(streaminfo); - return handle->fns->streaminfo(handle, fsp, fname, mem_ctx, - num_streams, streams); + return handle->fns->streaminfo_fn(handle, fsp, fname, mem_ctx, + num_streams, streams); } int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle, @@ -1705,15 +1706,15 @@ int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx, char **found_name) { VFS_FIND(get_real_filename); - return handle->fns->get_real_filename(handle, path, name, mem_ctx, - found_name); + return handle->fns->get_real_filename_fn(handle, path, name, mem_ctx, + found_name); } const char *smb_vfs_call_connectpath(struct vfs_handle_struct *handle, const char *filename) { VFS_FIND(connectpath); - return handle->fns->connectpath(handle, filename); + return handle->fns->connectpath_fn(handle, filename); } bool smb_vfs_call_strict_lock(struct vfs_handle_struct *handle, @@ -1721,7 +1722,7 @@ bool smb_vfs_call_strict_lock(struct vfs_handle_struct *handle, struct lock_struct *plock) { VFS_FIND(strict_lock); - return handle->fns->strict_lock(handle, fsp, plock); + return handle->fns->strict_lock_fn(handle, fsp, plock); } void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle, @@ -1729,7 +1730,7 @@ void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle, struct lock_struct *plock) { VFS_FIND(strict_unlock); - handle->fns->strict_unlock(handle, fsp, plock); + handle->fns->strict_unlock_fn(handle, fsp, plock); } NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle, @@ -1739,8 +1740,8 @@ NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle, char **mapped_name) { VFS_FIND(translate_name); - return handle->fns->translate_name(handle, name, direction, mem_ctx, - mapped_name); + return handle->fns->translate_name_fn(handle, name, direction, mem_ctx, + mapped_name); } NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle, @@ -1755,9 +1756,9 @@ NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle, uint32_t *out_len) { VFS_FIND(fsctl); - return handle->fns->fsctl(handle, fsp, ctx, function, req_flags, - in_data, in_len, out_data, max_out_len, - out_len); + return handle->fns->fsctl_fn(handle, fsp, ctx, function, req_flags, + in_data, in_len, out_data, max_out_len, + out_len); } NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle, @@ -1766,8 +1767,8 @@ NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle, struct security_descriptor **ppdesc) { VFS_FIND(fget_nt_acl); - return handle->fns->fget_nt_acl(handle, fsp, security_info, - ppdesc); + return handle->fns->fget_nt_acl_fn(handle, fsp, security_info, + ppdesc); } NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle, @@ -1776,7 +1777,7 @@ NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle, struct security_descriptor **ppdesc) { VFS_FIND(get_nt_acl); - return handle->fns->get_nt_acl(handle, name, security_info, ppdesc); + return handle->fns->get_nt_acl_fn(handle, name, security_info, ppdesc); } NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle, @@ -1785,21 +1786,22 @@ NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle, const struct security_descriptor *psd) { VFS_FIND(fset_nt_acl); - return handle->fns->fset_nt_acl(handle, fsp, security_info_sent, psd); + return handle->fns->fset_nt_acl_fn(handle, fsp, security_info_sent, + psd); } int smb_vfs_call_chmod_acl(struct vfs_handle_struct *handle, const char *name, mode_t mode) { VFS_FIND(chmod_acl); - return handle->fns->chmod_acl(handle, name, mode); + return handle->fns->chmod_acl_fn(handle, name, mode); } int smb_vfs_call_fchmod_acl(struct vfs_handle_struct *handle, struct files_struct *fsp, mode_t mode) { VFS_FIND(fchmod_acl); - return handle->fns->fchmod_acl(handle, fsp, mode); + return handle->fns->fchmod_acl_fn(handle, fsp, mode); } int smb_vfs_call_sys_acl_get_entry(struct vfs_handle_struct *handle, @@ -1807,8 +1809,8 @@ int smb_vfs_call_sys_acl_get_entry(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T *entry_p) { VFS_FIND(sys_acl_get_entry); - return handle->fns->sys_acl_get_entry(handle, theacl, entry_id, - entry_p); + return handle->fns->sys_acl_get_entry_fn(handle, theacl, entry_id, + entry_p); } int smb_vfs_call_sys_acl_get_tag_type(struct vfs_handle_struct *handle, @@ -1816,7 +1818,8 @@ int smb_vfs_call_sys_acl_get_tag_type(struct vfs_handle_struct *handle, SMB_ACL_TAG_T *tag_type_p) { VFS_FIND(sys_acl_get_tag_type); - return handle->fns->sys_acl_get_tag_type(handle, entry_d, tag_type_p); + return handle->fns->sys_acl_get_tag_type_fn(handle, entry_d, + tag_type_p); } int smb_vfs_call_sys_acl_get_permset(struct vfs_handle_struct *handle, @@ -1824,14 +1827,14 @@ int smb_vfs_call_sys_acl_get_permset(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T *permset_p) { VFS_FIND(sys_acl_get_permset); - return handle->fns->sys_acl_get_permset(handle, entry_d, permset_p); + return handle->fns->sys_acl_get_permset_fn(handle, entry_d, permset_p); } void * smb_vfs_call_sys_acl_get_qualifier(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d) { VFS_FIND(sys_acl_get_qualifier); - return handle->fns->sys_acl_get_qualifier(handle, entry_d); + return handle->fns->sys_acl_get_qualifier_fn(handle, entry_d); } SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle, @@ -1839,21 +1842,21 @@ SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle, SMB_ACL_TYPE_T type) { VFS_FIND(sys_acl_get_file); - return handle->fns->sys_acl_get_file(handle, path_p, type); + return handle->fns->sys_acl_get_file_fn(handle, path_p, type); } SMB_ACL_T smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct *handle, struct files_struct *fsp) { VFS_FIND(sys_acl_get_fd); - return handle->fns->sys_acl_get_fd(handle, fsp); + return handle->fns->sys_acl_get_fd_fn(handle, fsp); } int smb_vfs_call_sys_acl_clear_perms(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset) { VFS_FIND(sys_acl_clear_perms); - return handle->fns->sys_acl_clear_perms(handle, permset); + return handle->fns->sys_acl_clear_perms_fn(handle, permset); } int smb_vfs_call_sys_acl_add_perm(struct vfs_handle_struct *handle, @@ -1861,28 +1864,28 @@ int smb_vfs_call_sys_acl_add_perm(struct vfs_handle_struct *handle, SMB_ACL_PERM_T perm) { VFS_FIND(sys_acl_add_perm); - return handle->fns->sys_acl_add_perm(handle, permset, perm); + return handle->fns->sys_acl_add_perm_fn(handle, permset, perm); } char * smb_vfs_call_sys_acl_to_text(struct vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen) { VFS_FIND(sys_acl_to_text); - return handle->fns->sys_acl_to_text(handle, theacl, plen); + return handle->fns->sys_acl_to_text_fn(handle, theacl, plen); } SMB_ACL_T smb_vfs_call_sys_acl_init(struct vfs_handle_struct *handle, int count) { VFS_FIND(sys_acl_init); - return handle->fns->sys_acl_init(handle, count); + return handle->fns->sys_acl_init_fn(handle, count); } int smb_vfs_call_sys_acl_create_entry(struct vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry) { VFS_FIND(sys_acl_create_entry); - return handle->fns->sys_acl_create_entry(handle, pacl, pentry); + return handle->fns->sys_acl_create_entry_fn(handle, pacl, pentry); } int smb_vfs_call_sys_acl_set_tag_type(struct vfs_handle_struct *handle, @@ -1890,14 +1893,14 @@ int smb_vfs_call_sys_acl_set_tag_type(struct vfs_handle_struct *handle, SMB_ACL_TAG_T tagtype) { VFS_FIND(sys_acl_set_tag_type); - return handle->fns->sys_acl_set_tag_type(handle, entry, tagtype); + return handle->fns->sys_acl_set_tag_type_fn(handle, entry, tagtype); } int smb_vfs_call_sys_acl_set_qualifier(struct vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual) { VFS_FIND(sys_acl_set_qualifier); - return handle->fns->sys_acl_set_qualifier(handle, entry, qual); + return handle->fns->sys_acl_set_qualifier_fn(handle, entry, qual); } int smb_vfs_call_sys_acl_set_permset(struct vfs_handle_struct *handle, @@ -1905,14 +1908,14 @@ int smb_vfs_call_sys_acl_set_permset(struct vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset) { VFS_FIND(sys_acl_set_permset); - return handle->fns->sys_acl_set_permset(handle, entry, permset); + return handle->fns->sys_acl_set_permset_fn(handle, entry, permset); } int smb_vfs_call_sys_acl_valid(struct vfs_handle_struct *handle, SMB_ACL_T theacl) { VFS_FIND(sys_acl_valid); - return handle->fns->sys_acl_valid(handle, theacl); + return handle->fns->sys_acl_valid_fn(handle, theacl); } int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle, @@ -1920,21 +1923,21 @@ int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle, SMB_ACL_T theacl) { VFS_FIND(sys_acl_set_file); - return handle->fns->sys_acl_set_file(handle, name, acltype, theacl); + return handle->fns->sys_acl_set_file_fn(handle, name, acltype, theacl); } int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_ACL_T theacl) { VFS_FIND(sys_acl_set_fd); - return handle->fns->sys_acl_set_fd(handle, fsp, theacl); + return handle->fns->sys_acl_set_fd_fn(handle, fsp, theacl); } int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct *handle, const char *path) { VFS_FIND(sys_acl_delete_def_file); - return handle->fns->sys_acl_delete_def_file(handle, path); + return handle->fns->sys_acl_delete_def_file_fn(handle, path); } int smb_vfs_call_sys_acl_get_perm(struct vfs_handle_struct *handle, @@ -1942,28 +1945,29 @@ int smb_vfs_call_sys_acl_get_perm(struct vfs_handle_struct *handle, SMB_ACL_PERM_T perm) { VFS_FIND(sys_acl_get_perm); - return handle->fns->sys_acl_get_perm(handle, permset, perm); + return handle->fns->sys_acl_get_perm_fn(handle, permset, perm); } int smb_vfs_call_sys_acl_free_text(struct vfs_handle_struct *handle, char *text) { VFS_FIND(sys_acl_free_text); - return handle->fns->sys_acl_free_text(handle, text); + return handle->fns->sys_acl_free_text_fn(handle, text); } int smb_vfs_call_sys_acl_free_acl(struct vfs_handle_struct *handle, SMB_ACL_T posix_acl) { VFS_FIND(sys_acl_free_acl); - return handle->fns->sys_acl_free_acl(handle, posix_acl); + return handle->fns->sys_acl_free_acl_fn(handle, posix_acl); } int smb_vfs_call_sys_acl_free_qualifier(struct vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype) { VFS_FIND(sys_acl_free_qualifier); - return handle->fns->sys_acl_free_qualifier(handle, qualifier, tagtype); + return handle->fns->sys_acl_free_qualifier_fn(handle, qualifier, + tagtype); } ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle, @@ -1971,7 +1975,7 @@ ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle, size_t size) { VFS_FIND(getxattr); - return handle->fns->getxattr(handle, path, name, value, size); + return handle->fns->getxattr_fn(handle, path, name, value, size); } ssize_t smb_vfs_call_lgetxattr(struct vfs_handle_struct *handle, @@ -1979,7 +1983,7 @@ ssize_t smb_vfs_call_lgetxattr(struct vfs_handle_struct *handle, size_t size) { VFS_FIND(lgetxattr); - return handle->fns->lgetxattr(handle, path, name, value, size); + return handle->fns->lgetxattr_fn(handle, path, name, value, size); } ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle, @@ -1987,21 +1991,21 @@ ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle, void *value, size_t size) { VFS_FIND(fgetxattr); - return handle->fns->fgetxattr(handle, fsp, name, value, size); + return handle->fns->fgetxattr_fn(handle, fsp, name, value, size); } ssize_t smb_vfs_call_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size) { VFS_FIND(listxattr); - return handle->fns->listxattr(handle, path, list, size); + return handle->fns->listxattr_fn(handle, path, list, size); } ssize_t smb_vfs_call_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size) { VFS_FIND(llistxattr); - return handle->fns->llistxattr(handle, path, list, size); + return handle->fns->llistxattr_fn(handle, path, list, size); } ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle, @@ -2009,28 +2013,28 @@ ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle, size_t size) { VFS_FIND(flistxattr); - return handle->fns->flistxattr(handle, fsp, list, size); + return handle->fns->flistxattr_fn(handle, fsp, list, size); } int smb_vfs_call_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name) { VFS_FIND(removexattr); - return handle->fns->removexattr(handle, path, name); + return handle->fns->removexattr_fn(handle, path, name); } int smb_vfs_call_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name) { VFS_FIND(lremovexattr); - return handle->fns->lremovexattr(handle, path, name); + return handle->fns->lremovexattr_fn(handle, path, name); } int smb_vfs_call_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name) { VFS_FIND(fremovexattr); - return handle->fns->fremovexattr(handle, fsp, name); + return handle->fns->fremovexattr_fn(handle, fsp, name); } int smb_vfs_call_setxattr(struct vfs_handle_struct *handle, const char *path, @@ -2038,7 +2042,7 @@ int smb_vfs_call_setxattr(struct vfs_handle_struct *handle, const char *path, int flags) { VFS_FIND(setxattr); - return handle->fns->setxattr(handle, path, name, value, size, flags); + return handle->fns->setxattr_fn(handle, path, name, value, size, flags); } int smb_vfs_call_lsetxattr(struct vfs_handle_struct *handle, const char *path, @@ -2046,7 +2050,8 @@ int smb_vfs_call_lsetxattr(struct vfs_handle_struct *handle, const char *path, int flags) { VFS_FIND(lsetxattr); - return handle->fns->lsetxattr(handle, path, name, value, size, flags); + return handle->fns->lsetxattr_fn(handle, path, name, value, size, + flags); } int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle, @@ -2054,28 +2059,28 @@ int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle, const void *value, size_t size, int flags) { VFS_FIND(fsetxattr); - return handle->fns->fsetxattr(handle, fsp, name, value, size, flags); + return handle->fns->fsetxattr_fn(handle, fsp, name, value, size, flags); } int smb_vfs_call_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb) { VFS_FIND(aio_read); - return handle->fns->aio_read(handle, fsp, aiocb); + return handle->fns->aio_read_fn(handle, fsp, aiocb); } int smb_vfs_call_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb) { VFS_FIND(aio_write); - return handle->fns->aio_write(handle, fsp, aiocb); + return handle->fns->aio_write_fn(handle, fsp, aiocb); } -ssize_t smb_vfs_call_aio_return_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp, - SMB_STRUCT_AIOCB *aiocb) +ssize_t smb_vfs_call_aio_return(struct vfs_handle_struct *handle, + struct files_struct *fsp, + SMB_STRUCT_AIOCB *aiocb) { - VFS_FIND(aio_return_fn); + VFS_FIND(aio_return); return handle->fns->aio_return_fn(handle, fsp, aiocb); } @@ -2083,14 +2088,14 @@ int smb_vfs_call_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb) { VFS_FIND(aio_cancel); - return handle->fns->aio_cancel(handle, fsp, aiocb); + return handle->fns->aio_cancel_fn(handle, fsp, aiocb); } -int smb_vfs_call_aio_error_fn(struct vfs_handle_struct *handle, - struct files_struct *fsp, - SMB_STRUCT_AIOCB *aiocb) +int smb_vfs_call_aio_error(struct vfs_handle_struct *handle, + struct files_struct *fsp, + SMB_STRUCT_AIOCB *aiocb) { - VFS_FIND(aio_error_fn); + VFS_FIND(aio_error); return handle->fns->aio_error_fn(handle, fsp, aiocb); } @@ -2099,7 +2104,7 @@ int smb_vfs_call_aio_fsync(struct vfs_handle_struct *handle, SMB_STRUCT_AIOCB *aiocb) { VFS_FIND(aio_fsync); - return handle->fns->aio_fsync(handle, fsp, op, aiocb); + return handle->fns->aio_fsync_fn(handle, fsp, op, aiocb); } int smb_vfs_call_aio_suspend(struct vfs_handle_struct *handle, @@ -2108,14 +2113,14 @@ int smb_vfs_call_aio_suspend(struct vfs_handle_struct *handle, const struct timespec *timeout) { VFS_FIND(aio_suspend); - return handle->fns->aio_suspend(handle, fsp, aiocb, n, timeout); + return handle->fns->aio_suspend_fn(handle, fsp, aiocb, n, timeout); } bool smb_vfs_call_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp) { VFS_FIND(aio_force); - return handle->fns->aio_force(handle, fsp); + return handle->fns->aio_force_fn(handle, fsp); } bool smb_vfs_call_is_offline(struct vfs_handle_struct *handle, @@ -2123,12 +2128,12 @@ bool smb_vfs_call_is_offline(struct vfs_handle_struct *handle, SMB_STRUCT_STAT *sbuf) { VFS_FIND(is_offline); - return handle->fns->is_offline(handle, fname, sbuf); + return handle->fns->is_offline_fn(handle, fname, sbuf); } int smb_vfs_call_set_offline(struct vfs_handle_struct *handle, const struct smb_filename *fname) { VFS_FIND(set_offline); - return handle->fns->set_offline(handle, fname); + return handle->fns->set_offline_fn(handle, fname); } -- 2.34.1