| 1 | /*
|
|---|
| 2 | Unix SMB/CIFS implementation.
|
|---|
| 3 | VFS wrapper macros
|
|---|
| 4 | Copyright (C) Stefan (metze) Metzmacher 2003
|
|---|
| 5 | Copyright (C) Volker Lendecke 2009
|
|---|
| 6 |
|
|---|
| 7 | This program is free software; you can redistribute it and/or modify
|
|---|
| 8 | it under the terms of the GNU General Public License as published by
|
|---|
| 9 | the Free Software Foundation; either version 3 of the License, or
|
|---|
| 10 | (at your option) any later version.
|
|---|
| 11 |
|
|---|
| 12 | This program is distributed in the hope that it will be useful,
|
|---|
| 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|---|
| 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|---|
| 15 | GNU General Public License for more details.
|
|---|
| 16 |
|
|---|
| 17 | You should have received a copy of the GNU General Public License
|
|---|
| 18 | along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|---|
| 19 | */
|
|---|
| 20 |
|
|---|
| 21 | #ifndef _VFS_MACROS_H
|
|---|
| 22 | #define _VFS_MACROS_H
|
|---|
| 23 |
|
|---|
| 24 | /*******************************************************************
|
|---|
| 25 | Don't access conn->vfs.ops.* directly!!!
|
|---|
| 26 | Use this macros!
|
|---|
| 27 | (Fixes should go also into the vfs_opaque_* and vfs_next_* macros!)
|
|---|
| 28 | ********************************************************************/
|
|---|
| 29 |
|
|---|
| 30 | /* Disk operations */
|
|---|
| 31 | #define SMB_VFS_CONNECT(conn, service, user) \
|
|---|
| 32 | smb_vfs_call_connect((conn)->vfs_handles, (service), (user))
|
|---|
| 33 | #define SMB_VFS_NEXT_CONNECT(handle, service, user) \
|
|---|
| 34 | smb_vfs_call_connect((handle)->next, (service), (user))
|
|---|
| 35 |
|
|---|
| 36 | #define SMB_VFS_DISCONNECT(conn) \
|
|---|
| 37 | smb_vfs_call_disconnect((conn)->vfs_handles)
|
|---|
| 38 | #define SMB_VFS_NEXT_DISCONNECT(handle) \
|
|---|
| 39 | smb_vfs_call_disconnect((handle)->next)
|
|---|
| 40 |
|
|---|
| 41 | #define SMB_VFS_DISK_FREE(conn, path, small_query, bsize, dfree ,dsize) \
|
|---|
| 42 | smb_vfs_call_disk_free((conn)->vfs_handles, (path), (small_query), (bsize), (dfree), (dsize))
|
|---|
| 43 | #define SMB_VFS_NEXT_DISK_FREE(handle, path, small_query, bsize, dfree ,dsize)\
|
|---|
| 44 | smb_vfs_call_disk_free((handle)->next, (path), (small_query), (bsize), (dfree), (dsize))
|
|---|
| 45 |
|
|---|
| 46 | #define SMB_VFS_GET_QUOTA(conn, qtype, id, qt) \
|
|---|
| 47 | smb_vfs_call_get_quota((conn)->vfs_handles, (qtype), (id), (qt))
|
|---|
| 48 | #define SMB_VFS_NEXT_GET_QUOTA(handle, qtype, id, qt) \
|
|---|
| 49 | smb_vfs_call_get_quota((handle)->next, (qtype), (id), (qt))
|
|---|
| 50 |
|
|---|
| 51 | #define SMB_VFS_SET_QUOTA(conn, qtype, id, qt) \
|
|---|
| 52 | smb_vfs_call_set_quota((conn)->vfs_handles, (qtype), (id), (qt))
|
|---|
| 53 | #define SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt) \
|
|---|
| 54 | smb_vfs_call_set_quota((handle)->next, (qtype), (id), (qt))
|
|---|
| 55 |
|
|---|
| 56 | #define SMB_VFS_GET_SHADOW_COPY_DATA(fsp,shadow_copy_data,labels) \
|
|---|
| 57 | smb_vfs_call_get_shadow_copy_data((fsp)->conn->vfs_handles, (fsp), (shadow_copy_data), (labels))
|
|---|
| 58 | #define SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp, shadow_copy_data ,labels) \
|
|---|
| 59 | smb_vfs_call_get_shadow_copy_data((handle)->next, (fsp), (shadow_copy_data), (labels))
|
|---|
| 60 |
|
|---|
| 61 | #define SMB_VFS_STATVFS(conn, path, statbuf) \
|
|---|
| 62 | smb_vfs_call_statvfs((conn)->vfs_handles, (path), (statbuf))
|
|---|
| 63 | #define SMB_VFS_NEXT_STATVFS(handle, path, statbuf) \
|
|---|
| 64 | smb_vfs_call_statvfs((handle)->next, (path), (statbuf))
|
|---|
| 65 |
|
|---|
| 66 | #define SMB_VFS_FS_CAPABILITIES(conn, p_ts_res) \
|
|---|
| 67 | smb_vfs_call_fs_capabilities((conn)->vfs_handles, (p_ts_res))
|
|---|
| 68 | #define SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res) \
|
|---|
| 69 | smb_vfs_call_fs_capabilities((handle)->next, (p_ts_res))
|
|---|
| 70 |
|
|---|
| 71 | /* Directory operations */
|
|---|
| 72 | #define SMB_VFS_OPENDIR(conn, fname, mask, attr) \
|
|---|
| 73 | smb_vfs_call_opendir((conn)->vfs_handles, (fname), (mask), (attr))
|
|---|
| 74 | #define SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr) \
|
|---|
| 75 | smb_vfs_call_opendir((handle)->next, (fname), (mask), (attr))
|
|---|
| 76 |
|
|---|
| 77 | #define SMB_VFS_FDOPENDIR(fsp, mask, attr) \
|
|---|
| 78 | smb_vfs_call_fdopendir((fsp)->conn->vfs_handles, (fsp), (mask), (attr))
|
|---|
| 79 | #define SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr) \
|
|---|
| 80 | smb_vfs_call_fdopendir((handle)->next, (fsp), (mask), (attr))
|
|---|
| 81 |
|
|---|
| 82 | #define SMB_VFS_READDIR(conn, dirp, sbuf) \
|
|---|
| 83 | smb_vfs_call_readdir((conn)->vfs_handles, (dirp), (sbuf))
|
|---|
| 84 | #define SMB_VFS_NEXT_READDIR(handle, dirp, sbuf) \
|
|---|
| 85 | smb_vfs_call_readdir((handle)->next, (dirp), (sbuf))
|
|---|
| 86 |
|
|---|
| 87 | #define SMB_VFS_SEEKDIR(conn, dirp, offset) \
|
|---|
| 88 | smb_vfs_call_seekdir((conn)->vfs_handles, (dirp), (offset))
|
|---|
| 89 | #define SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset) \
|
|---|
| 90 | smb_vfs_call_seekdir((handle)->next, (dirp), (offset))
|
|---|
| 91 |
|
|---|
| 92 | #define SMB_VFS_TELLDIR(conn, dirp) \
|
|---|
| 93 | smb_vfs_call_telldir((conn)->vfs_handles, (dirp))
|
|---|
| 94 | #define SMB_VFS_NEXT_TELLDIR(handle, dirp) \
|
|---|
| 95 | smb_vfs_call_telldir((handle)->next, (dirp))
|
|---|
| 96 |
|
|---|
| 97 | #define SMB_VFS_REWINDDIR(conn, dirp) \
|
|---|
| 98 | smb_vfs_call_rewind_dir((conn)->vfs_handles, (dirp))
|
|---|
| 99 | #define SMB_VFS_NEXT_REWINDDIR(handle, dirp) \
|
|---|
| 100 | smb_vfs_call_rewind_dir((handle)->next, (dirp))
|
|---|
| 101 |
|
|---|
| 102 | #define SMB_VFS_MKDIR(conn, path, mode) \
|
|---|
| 103 | smb_vfs_call_mkdir((conn)->vfs_handles,(path), (mode))
|
|---|
| 104 | #define SMB_VFS_NEXT_MKDIR(handle, path, mode) \
|
|---|
| 105 | smb_vfs_call_mkdir((handle)->next,(path), (mode))
|
|---|
| 106 |
|
|---|
| 107 | #define SMB_VFS_RMDIR(conn, path) \
|
|---|
| 108 | smb_vfs_call_rmdir((conn)->vfs_handles, (path))
|
|---|
| 109 | #define SMB_VFS_NEXT_RMDIR(handle, path) \
|
|---|
| 110 | smb_vfs_call_rmdir((handle)->next, (path))
|
|---|
| 111 |
|
|---|
| 112 | #define SMB_VFS_CLOSEDIR(conn, dir) \
|
|---|
| 113 | smb_vfs_call_closedir((conn)->vfs_handles, dir)
|
|---|
| 114 | #define SMB_VFS_NEXT_CLOSEDIR(handle, dir) \
|
|---|
| 115 | smb_vfs_call_closedir((handle)->next, (dir))
|
|---|
| 116 |
|
|---|
| 117 | #define SMB_VFS_INIT_SEARCH_OP(conn, dirp) \
|
|---|
| 118 | smb_vfs_call_init_search_op((conn)->vfs_handles, (dirp))
|
|---|
| 119 | #define SMB_VFS_NEXT_INIT_SEARCH_OP(handle, dirp) \
|
|---|
| 120 | smb_vfs_call_init_search_op((handle)->next, (dirp))
|
|---|
| 121 |
|
|---|
| 122 | /* File operations */
|
|---|
| 123 | #define SMB_VFS_OPEN(conn, fname, fsp, flags, mode) \
|
|---|
| 124 | smb_vfs_call_open((conn)->vfs_handles, (fname), (fsp), (flags), (mode))
|
|---|
| 125 | #define SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode) \
|
|---|
| 126 | smb_vfs_call_open((handle)->next, (fname), (fsp), (flags), (mode))
|
|---|
| 127 |
|
|---|
| 128 | #define SMB_VFS_CREATE_FILE(conn, req, root_dir_fid, smb_fname, access_mask, share_access, create_disposition, \
|
|---|
| 129 | create_options, file_attributes, oplock_request, allocation_size, private_flags, sd, ea_list, result, pinfo) \
|
|---|
| 130 | smb_vfs_call_create_file((conn)->vfs_handles, (req), (root_dir_fid), (smb_fname), (access_mask), (share_access), (create_disposition), \
|
|---|
| 131 | (create_options), (file_attributes), (oplock_request), (allocation_size), (private_flags), (sd), (ea_list), (result), (pinfo))
|
|---|
| 132 | #define SMB_VFS_NEXT_CREATE_FILE(handle, req, root_dir_fid, smb_fname, access_mask, share_access, create_disposition, \
|
|---|
| 133 | create_options, file_attributes, oplock_request, allocation_size, private_flags, sd, ea_list, result, pinfo) \
|
|---|
| 134 | smb_vfs_call_create_file((handle)->next, (req), (root_dir_fid), (smb_fname), (access_mask), (share_access), (create_disposition), \
|
|---|
| 135 | (create_options), (file_attributes), (oplock_request), (allocation_size), (private_flags), (sd), (ea_list), (result), (pinfo))
|
|---|
| 136 |
|
|---|
| 137 | #define SMB_VFS_CLOSE(fsp) \
|
|---|
| 138 | smb_vfs_call_close_fn((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 139 | #define SMB_VFS_NEXT_CLOSE(handle, fsp) \
|
|---|
| 140 | smb_vfs_call_close_fn((handle)->next, (fsp))
|
|---|
| 141 |
|
|---|
| 142 | #define SMB_VFS_READ(fsp, data, n) \
|
|---|
| 143 | smb_vfs_call_vfs_read((fsp)->conn->vfs_handles, (fsp), (data), (n))
|
|---|
| 144 | #define SMB_VFS_NEXT_READ(handle, fsp, data, n) \
|
|---|
| 145 | smb_vfs_call_vfs_read((handle)->next, (fsp), (data), (n))
|
|---|
| 146 |
|
|---|
| 147 | #define SMB_VFS_PREAD(fsp, data, n, off) \
|
|---|
| 148 | smb_vfs_call_pread((fsp)->conn->vfs_handles, (fsp), (data), (n), (off))
|
|---|
| 149 | #define SMB_VFS_NEXT_PREAD(handle, fsp, data, n, off) \
|
|---|
| 150 | smb_vfs_call_pread((handle)->next, (fsp), (data), (n), (off))
|
|---|
| 151 |
|
|---|
| 152 | #define SMB_VFS_WRITE(fsp, data, n) \
|
|---|
| 153 | smb_vfs_call_write((fsp)->conn->vfs_handles, (fsp), (data), (n))
|
|---|
| 154 | #define SMB_VFS_NEXT_WRITE(handle, fsp, data, n) \
|
|---|
| 155 | smb_vfs_call_write((handle)->next, (fsp), (data), (n))
|
|---|
| 156 |
|
|---|
| 157 | #define SMB_VFS_PWRITE(fsp, data, n, off) \
|
|---|
| 158 | smb_vfs_call_pwrite((fsp)->conn->vfs_handles, (fsp), (data), (n), (off))
|
|---|
| 159 | #define SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, off) \
|
|---|
| 160 | smb_vfs_call_pwrite((handle)->next, (fsp), (data), (n), (off))
|
|---|
| 161 |
|
|---|
| 162 | #define SMB_VFS_LSEEK(fsp, offset, whence) \
|
|---|
| 163 | smb_vfs_call_lseek((fsp)->conn->vfs_handles, (fsp), (offset), (whence))
|
|---|
| 164 | #define SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence) \
|
|---|
| 165 | smb_vfs_call_lseek((handle)->next, (fsp), (offset), (whence))
|
|---|
| 166 |
|
|---|
| 167 | #define SMB_VFS_SENDFILE(tofd, fromfsp, header, offset, count) \
|
|---|
| 168 | smb_vfs_call_sendfile((fromfsp)->conn->vfs_handles, (tofd), (fromfsp), (header), (offset), (count))
|
|---|
| 169 | #define SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, header, offset, count) \
|
|---|
| 170 | smb_vfs_call_sendfile((handle)->next, (tofd), (fromfsp), (header), (offset), (count))
|
|---|
| 171 |
|
|---|
| 172 | #define SMB_VFS_RECVFILE(fromfd, tofsp, offset, count) \
|
|---|
| 173 | smb_vfs_call_recvfile((tofsp)->conn->vfs_handles, (fromfd), (tofsp), (offset), (count))
|
|---|
| 174 | #define SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, count) \
|
|---|
| 175 | smb_vfs_call_recvfile((handle)->next, (fromfd), (tofsp), (offset), (count))
|
|---|
| 176 |
|
|---|
| 177 | #define SMB_VFS_RENAME(conn, old, new) \
|
|---|
| 178 | smb_vfs_call_rename((conn)->vfs_handles, (old), (new))
|
|---|
| 179 | #define SMB_VFS_NEXT_RENAME(handle, old, new) \
|
|---|
| 180 | smb_vfs_call_rename((handle)->next, (old), (new))
|
|---|
| 181 |
|
|---|
| 182 | #define SMB_VFS_FSYNC(fsp) \
|
|---|
| 183 | smb_vfs_call_fsync((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 184 | #define SMB_VFS_NEXT_FSYNC(handle, fsp) \
|
|---|
| 185 | smb_vfs_call_fsync((handle)->next, (fsp))
|
|---|
| 186 |
|
|---|
| 187 | #define SMB_VFS_STAT(conn, smb_fname) \
|
|---|
| 188 | smb_vfs_call_stat((conn)->vfs_handles, (smb_fname))
|
|---|
| 189 | #define SMB_VFS_NEXT_STAT(handle, smb_fname) \
|
|---|
| 190 | smb_vfs_call_stat((handle)->next, (smb_fname))
|
|---|
| 191 |
|
|---|
| 192 | #define SMB_VFS_FSTAT(fsp, sbuf) \
|
|---|
| 193 | smb_vfs_call_fstat((fsp)->conn->vfs_handles, (fsp), (sbuf))
|
|---|
| 194 | #define SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf) \
|
|---|
| 195 | smb_vfs_call_fstat((handle)->next, (fsp), (sbuf))
|
|---|
| 196 |
|
|---|
| 197 | #define SMB_VFS_LSTAT(conn, smb_fname) \
|
|---|
| 198 | smb_vfs_call_lstat((conn)->vfs_handles, (smb_fname))
|
|---|
| 199 | #define SMB_VFS_NEXT_LSTAT(handle, smb_fname) \
|
|---|
| 200 | smb_vfs_call_lstat((handle)->next, (smb_fname))
|
|---|
| 201 |
|
|---|
| 202 | #define SMB_VFS_GET_ALLOC_SIZE(conn, fsp, sbuf) \
|
|---|
| 203 | smb_vfs_call_get_alloc_size((conn)->vfs_handles, (fsp), (sbuf))
|
|---|
| 204 | #define SMB_VFS_NEXT_GET_ALLOC_SIZE(conn, fsp, sbuf) \
|
|---|
| 205 | smb_vfs_call_get_alloc_size((conn)->next, (fsp), (sbuf))
|
|---|
| 206 |
|
|---|
| 207 | #define SMB_VFS_UNLINK(conn, path) \
|
|---|
| 208 | smb_vfs_call_unlink((conn)->vfs_handles, (path))
|
|---|
| 209 | #define SMB_VFS_NEXT_UNLINK(handle, path) \
|
|---|
| 210 | smb_vfs_call_unlink((handle)->next, (path))
|
|---|
| 211 |
|
|---|
| 212 | #define SMB_VFS_CHMOD(conn, path, mode) \
|
|---|
| 213 | smb_vfs_call_chmod((conn)->vfs_handles, (path), (mode))
|
|---|
| 214 | #define SMB_VFS_NEXT_CHMOD(handle, path, mode) \
|
|---|
| 215 | smb_vfs_call_chmod((handle)->next, (path), (mode))
|
|---|
| 216 |
|
|---|
| 217 | #define SMB_VFS_FCHMOD(fsp, mode) \
|
|---|
| 218 | smb_vfs_call_fchmod((fsp)->conn->vfs_handles, (fsp), (mode))
|
|---|
| 219 | #define SMB_VFS_NEXT_FCHMOD(handle, fsp, mode) \
|
|---|
| 220 | smb_vfs_call_fchmod((handle)->next, (fsp), (mode))
|
|---|
| 221 |
|
|---|
| 222 | #define SMB_VFS_CHOWN(conn, path, uid, gid) \
|
|---|
| 223 | smb_vfs_call_chown((conn)->vfs_handles, (path), (uid), (gid))
|
|---|
| 224 | #define SMB_VFS_NEXT_CHOWN(handle, path, uid, gid) \
|
|---|
| 225 | smb_vfs_call_chown((handle)->next, (path), (uid), (gid))
|
|---|
| 226 |
|
|---|
| 227 | #define SMB_VFS_FCHOWN(fsp, uid, gid) \
|
|---|
| 228 | smb_vfs_call_fchown((fsp)->conn->vfs_handles, (fsp), (uid), (gid))
|
|---|
| 229 | #define SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid) \
|
|---|
| 230 | smb_vfs_call_fchown((handle)->next, (fsp), (uid), (gid))
|
|---|
| 231 |
|
|---|
| 232 | #define SMB_VFS_LCHOWN(conn, path, uid, gid) \
|
|---|
| 233 | smb_vfs_call_lchown((conn)->vfs_handles, (path), (uid), (gid))
|
|---|
| 234 | #define SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid) \
|
|---|
| 235 | smb_vfs_call_lchown((handle)->next, (path), (uid), (gid))
|
|---|
| 236 |
|
|---|
| 237 | #define SMB_VFS_CHDIR(conn, path) \
|
|---|
| 238 | smb_vfs_call_chdir((conn)->vfs_handles, (path))
|
|---|
| 239 | #define SMB_VFS_NEXT_CHDIR(handle, path) \
|
|---|
| 240 | smb_vfs_call_chdir((handle)->next, (path))
|
|---|
| 241 |
|
|---|
| 242 | #define SMB_VFS_GETWD(conn, buf) \
|
|---|
| 243 | smb_vfs_call_getwd((conn)->vfs_handles, (buf))
|
|---|
| 244 | #define SMB_VFS_NEXT_GETWD(handle, buf) \
|
|---|
| 245 | smb_vfs_call_getwd((handle)->next, (buf))
|
|---|
| 246 |
|
|---|
| 247 | #define SMB_VFS_NTIMES(conn, path, ts) \
|
|---|
| 248 | smb_vfs_call_ntimes((conn)->vfs_handles, (path), (ts))
|
|---|
| 249 | #define SMB_VFS_NEXT_NTIMES(handle, path, ts) \
|
|---|
| 250 | smb_vfs_call_ntimes((handle)->next, (path), (ts))
|
|---|
| 251 |
|
|---|
| 252 | #define SMB_VFS_FTRUNCATE(fsp, offset) \
|
|---|
| 253 | smb_vfs_call_ftruncate((fsp)->conn->vfs_handles, (fsp), (offset))
|
|---|
| 254 | #define SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset) \
|
|---|
| 255 | smb_vfs_call_ftruncate((handle)->next, (fsp), (offset))
|
|---|
| 256 |
|
|---|
| 257 | #define SMB_VFS_FALLOCATE(fsp, mode, offset, len) \
|
|---|
| 258 | smb_vfs_call_fallocate((fsp)->conn->vfs_handles, (fsp), (mode), (offset), (len))
|
|---|
| 259 | #define SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len) \
|
|---|
| 260 | smb_vfs_call_fallocate((handle)->next, (fsp), (mode), (offset), (len))
|
|---|
| 261 |
|
|---|
| 262 | #define SMB_VFS_LOCK(fsp, op, offset, count, type) \
|
|---|
| 263 | smb_vfs_call_lock((fsp)->conn->vfs_handles, (fsp), (op), (offset), (count), (type))
|
|---|
| 264 | #define SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type) \
|
|---|
| 265 | smb_vfs_call_lock((handle)->next, (fsp), (op), (offset), (count), (type))
|
|---|
| 266 |
|
|---|
| 267 | #define SMB_VFS_KERNEL_FLOCK(fsp, share_mode, access_mask) \
|
|---|
| 268 | smb_vfs_call_kernel_flock((fsp)->conn->vfs_handles, (fsp), (share_mode), (access_mask))
|
|---|
| 269 | #define SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask) \
|
|---|
| 270 | smb_vfs_call_kernel_flock((handle)->next, (fsp), (share_mode), (access_mask))
|
|---|
| 271 |
|
|---|
| 272 | #define SMB_VFS_LINUX_SETLEASE(fsp, leasetype) \
|
|---|
| 273 | smb_vfs_call_linux_setlease((fsp)->conn->vfs_handles, (fsp), (leasetype))
|
|---|
| 274 | #define SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype) \
|
|---|
| 275 | smb_vfs_call_linux_setlease((handle)->next, (fsp), (leasetype))
|
|---|
| 276 |
|
|---|
| 277 | #define SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, ppid) \
|
|---|
| 278 | smb_vfs_call_getlock((fsp)->conn->vfs_handles, (fsp), (poffset), (pcount), (ptype), (ppid))
|
|---|
| 279 | #define SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid) \
|
|---|
| 280 | smb_vfs_call_getlock((handle)->next, (fsp), (poffset), (pcount), (ptype), (ppid))
|
|---|
| 281 |
|
|---|
| 282 | #define SMB_VFS_SYMLINK(conn, oldpath, newpath) \
|
|---|
| 283 | smb_vfs_call_symlink((conn)->vfs_handles, (oldpath), (newpath))
|
|---|
| 284 | #define SMB_VFS_NEXT_SYMLINK(handle, oldpath, newpath) \
|
|---|
| 285 | smb_vfs_call_symlink((handle)->next, (oldpath), (newpath))
|
|---|
| 286 |
|
|---|
| 287 | #define SMB_VFS_READLINK(conn, path, buf, bufsiz) \
|
|---|
| 288 | smb_vfs_call_vfs_readlink((conn)->vfs_handles, (path), (buf), (bufsiz))
|
|---|
| 289 | #define SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz) \
|
|---|
| 290 | smb_vfs_call_vfs_readlink((handle)->next, (path), (buf), (bufsiz))
|
|---|
| 291 |
|
|---|
| 292 | #define SMB_VFS_LINK(conn, oldpath, newpath) \
|
|---|
| 293 | smb_vfs_call_link((conn)->vfs_handles, (oldpath), (newpath))
|
|---|
| 294 | #define SMB_VFS_NEXT_LINK(handle, oldpath, newpath) \
|
|---|
| 295 | smb_vfs_call_link((handle)->next, (oldpath), (newpath))
|
|---|
| 296 |
|
|---|
| 297 | #define SMB_VFS_MKNOD(conn, path, mode, dev) \
|
|---|
| 298 | smb_vfs_call_mknod((conn)->vfs_handles, (path), (mode), (dev))
|
|---|
| 299 | #define SMB_VFS_NEXT_MKNOD(handle, path, mode, dev) \
|
|---|
| 300 | smb_vfs_call_mknod((handle)->next, (path), (mode), (dev))
|
|---|
| 301 |
|
|---|
| 302 | #define SMB_VFS_REALPATH(conn, path) \
|
|---|
| 303 | smb_vfs_call_realpath((conn)->vfs_handles, (path))
|
|---|
| 304 | #define SMB_VFS_NEXT_REALPATH(handle, path) \
|
|---|
| 305 | smb_vfs_call_realpath((handle)->next, (path))
|
|---|
| 306 |
|
|---|
| 307 | #define SMB_VFS_NOTIFY_WATCH(conn, ctx, e, callback, private_data, handle_p) \
|
|---|
| 308 | smb_vfs_call_notify_watch((conn)->vfs_handles, (ctx), (e), (callback), (private_data), (handle_p))
|
|---|
| 309 | #define SMB_VFS_NEXT_NOTIFY_WATCH(conn, ctx, e, callback, private_data, handle_p) \
|
|---|
| 310 | smb_vfs_call_notify_watch((conn)->next, (ctx), (e), (callback), (private_data), (handle_p))
|
|---|
| 311 |
|
|---|
| 312 | #define SMB_VFS_CHFLAGS(conn, path, flags) \
|
|---|
| 313 | smb_vfs_call_chflags((conn)->vfs_handles, (path), (flags))
|
|---|
| 314 | #define SMB_VFS_NEXT_CHFLAGS(handle, path, flags) \
|
|---|
| 315 | smb_vfs_call_chflags((handle)->next, (path), (flags))
|
|---|
| 316 |
|
|---|
| 317 | #define SMB_VFS_FILE_ID_CREATE(conn, sbuf) \
|
|---|
| 318 | smb_vfs_call_file_id_create((conn)->vfs_handles, (sbuf))
|
|---|
| 319 | #define SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf) \
|
|---|
| 320 | smb_vfs_call_file_id_create((handle)->next, (sbuf))
|
|---|
| 321 |
|
|---|
| 322 | #define SMB_VFS_STREAMINFO(conn, fsp, fname, mem_ctx, num_streams, streams) \
|
|---|
| 323 | smb_vfs_call_streaminfo((conn)->vfs_handles, (fsp), (fname), (mem_ctx), (num_streams), (streams))
|
|---|
| 324 | #define SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname, mem_ctx, num_streams, streams) \
|
|---|
| 325 | smb_vfs_call_streaminfo((handle)->next, (fsp), (fname), (mem_ctx), (num_streams), (streams))
|
|---|
| 326 |
|
|---|
| 327 | #define SMB_VFS_GET_REAL_FILENAME(conn, path, name, mem_ctx, found_name) \
|
|---|
| 328 | smb_vfs_call_get_real_filename((conn)->vfs_handles, (path), (name), (mem_ctx), (found_name))
|
|---|
| 329 | #define SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx, found_name) \
|
|---|
| 330 | smb_vfs_call_get_real_filename((handle)->next, (path), (name), (mem_ctx), (found_name))
|
|---|
| 331 |
|
|---|
| 332 | #define SMB_VFS_CONNECTPATH(conn, fname) \
|
|---|
| 333 | smb_vfs_call_connectpath((conn)->vfs_handles, (fname))
|
|---|
| 334 | #define SMB_VFS_NEXT_CONNECTPATH(conn, fname) \
|
|---|
| 335 | smb_vfs_call_connectpath((conn)->next, (fname))
|
|---|
| 336 |
|
|---|
| 337 | #define SMB_VFS_BRL_LOCK_WINDOWS(conn, br_lck, plock, blocking_lock, blr) \
|
|---|
| 338 | smb_vfs_call_brl_lock_windows((conn)->vfs_handles, (br_lck), (plock), (blocking_lock), (blr))
|
|---|
| 339 | #define SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock, blocking_lock, blr) \
|
|---|
| 340 | smb_vfs_call_brl_lock_windows((handle)->next, (br_lck), (plock), (blocking_lock), (blr))
|
|---|
| 341 |
|
|---|
| 342 | #define SMB_VFS_BRL_UNLOCK_WINDOWS(conn, msg_ctx, br_lck, plock) \
|
|---|
| 343 | smb_vfs_call_brl_unlock_windows((conn)->vfs_handles, (msg_ctx), (br_lck), (plock))
|
|---|
| 344 | #define SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck, plock) \
|
|---|
| 345 | smb_vfs_call_brl_unlock_windows((handle)->next, (msg_ctx), (br_lck), (plock))
|
|---|
| 346 |
|
|---|
| 347 | #define SMB_VFS_BRL_CANCEL_WINDOWS(conn, br_lck, plock, blr) \
|
|---|
| 348 | smb_vfs_call_brl_cancel_windows((conn)->vfs_handles, (br_lck), (plock), (blr))
|
|---|
| 349 | #define SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock, blr) \
|
|---|
| 350 | smb_vfs_call_brl_cancel_windows((handle)->next, (br_lck), (plock), (blr))
|
|---|
| 351 |
|
|---|
| 352 | #define SMB_VFS_STRICT_LOCK(conn, fsp, plock) \
|
|---|
| 353 | smb_vfs_call_strict_lock((conn)->vfs_handles, (fsp), (plock))
|
|---|
| 354 | #define SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock) \
|
|---|
| 355 | smb_vfs_call_strict_lock((handle)->next, (fsp), (plock))
|
|---|
| 356 |
|
|---|
| 357 | #define SMB_VFS_STRICT_UNLOCK(conn, fsp, plock) \
|
|---|
| 358 | smb_vfs_call_strict_unlock((conn)->vfs_handles, (fsp), (plock))
|
|---|
| 359 | #define SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock) \
|
|---|
| 360 | smb_vfs_call_strict_unlock((handle)->next, (fsp), (plock))
|
|---|
| 361 |
|
|---|
| 362 | #define SMB_VFS_TRANSLATE_NAME(conn, name, direction, mem_ctx, mapped_name) \
|
|---|
| 363 | smb_vfs_call_translate_name((conn)->vfs_handles, (name), (direction), (mem_ctx), (mapped_name))
|
|---|
| 364 | #define SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx, mapped_name) \
|
|---|
| 365 | smb_vfs_call_translate_name((handle)->next, (name), (direction), (mem_ctx), (mapped_name))
|
|---|
| 366 |
|
|---|
| 367 | #define SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock) \
|
|---|
| 368 | smb_vfs_call_strict_unlock((handle)->next, (fsp), (plock))
|
|---|
| 369 |
|
|---|
| 370 | #define SMB_VFS_FGET_NT_ACL(fsp, security_info, ppdesc) \
|
|---|
| 371 | smb_vfs_call_fget_nt_acl((fsp)->conn->vfs_handles, (fsp), (security_info), (ppdesc))
|
|---|
| 372 | #define SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, ppdesc) \
|
|---|
| 373 | smb_vfs_call_fget_nt_acl((handle)->next, (fsp), (security_info), (ppdesc))
|
|---|
| 374 |
|
|---|
| 375 | #define SMB_VFS_GET_NT_ACL(conn, name, security_info, ppdesc) \
|
|---|
| 376 | smb_vfs_call_get_nt_acl((conn)->vfs_handles, (name), (security_info), (ppdesc))
|
|---|
| 377 | #define SMB_VFS_NEXT_GET_NT_ACL(handle, name, security_info, ppdesc) \
|
|---|
| 378 | smb_vfs_call_get_nt_acl((handle)->next, (name), (security_info), (ppdesc))
|
|---|
| 379 |
|
|---|
| 380 | #define SMB_VFS_FSET_NT_ACL(fsp, security_info_sent, psd) \
|
|---|
| 381 | smb_vfs_call_fset_nt_acl((fsp)->conn->vfs_handles, (fsp), (security_info_sent), (psd))
|
|---|
| 382 | #define SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd) \
|
|---|
| 383 | smb_vfs_call_fset_nt_acl((handle)->next, (fsp), (security_info_sent), (psd))
|
|---|
| 384 |
|
|---|
| 385 | #define SMB_VFS_CHMOD_ACL(conn, name, mode) \
|
|---|
| 386 | smb_vfs_call_chmod_acl((conn)->vfs_handles, (name), (mode))
|
|---|
| 387 | #define SMB_VFS_NEXT_CHMOD_ACL(handle, name, mode) \
|
|---|
| 388 | smb_vfs_call_chmod_acl((handle)->next, (name), (mode))
|
|---|
| 389 |
|
|---|
| 390 | #define SMB_VFS_FCHMOD_ACL(fsp, mode) \
|
|---|
| 391 | smb_vfs_call_fchmod_acl((fsp)->conn->vfs_handles, (fsp), (mode))
|
|---|
| 392 | #define SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, mode) \
|
|---|
| 393 | smb_vfs_call_fchmod_acl((handle)->next, (fsp), (mode))
|
|---|
| 394 |
|
|---|
| 395 | #define SMB_VFS_SYS_ACL_GET_ENTRY(conn, theacl, entry_id, entry_p) \
|
|---|
| 396 | smb_vfs_call_sys_acl_get_entry((conn)->vfs_handles, (theacl), (entry_id), (entry_p))
|
|---|
| 397 | #define SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle, theacl, entry_id, entry_p) \
|
|---|
| 398 | smb_vfs_call_sys_acl_get_entry((handle)->next, (theacl), (entry_id), (entry_p))
|
|---|
| 399 |
|
|---|
| 400 | #define SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry_d, tag_type_p) \
|
|---|
| 401 | smb_vfs_call_sys_acl_get_tag_type((conn)->vfs_handles, (entry_d), (tag_type_p))
|
|---|
| 402 | #define SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle, entry_d, tag_type_p) \
|
|---|
| 403 | smb_vfs_call_sys_acl_get_tag_type((handle)->next, (entry_d), (tag_type_p))
|
|---|
| 404 |
|
|---|
| 405 | #define SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry_d, permset_p) \
|
|---|
| 406 | smb_vfs_call_sys_acl_get_permset((conn)->vfs_handles, (entry_d), (permset_p))
|
|---|
| 407 | #define SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle, entry_d, permset_p) \
|
|---|
| 408 | smb_vfs_call_sys_acl_get_permset((handle)->next, (entry_d), (permset_p))
|
|---|
| 409 |
|
|---|
| 410 | #define SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry_d) \
|
|---|
| 411 | smb_vfs_call_sys_acl_get_qualifier((conn)->vfs_handles, (entry_d))
|
|---|
| 412 | #define SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle, entry_d) \
|
|---|
| 413 | smb_vfs_call_sys_acl_get_qualifier((handle)->next, (entry_d))
|
|---|
| 414 |
|
|---|
| 415 | #define SMB_VFS_SYS_ACL_GET_FILE(conn, path_p, type) \
|
|---|
| 416 | smb_vfs_call_sys_acl_get_file((conn)->vfs_handles, (path_p), (type))
|
|---|
| 417 | #define SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p, type) \
|
|---|
| 418 | smb_vfs_call_sys_acl_get_file((handle)->next, (path_p), (type))
|
|---|
| 419 |
|
|---|
| 420 | #define SMB_VFS_SYS_ACL_GET_FD(fsp) \
|
|---|
| 421 | smb_vfs_call_sys_acl_get_fd((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 422 | #define SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp) \
|
|---|
| 423 | smb_vfs_call_sys_acl_get_fd((handle)->next, (fsp))
|
|---|
| 424 |
|
|---|
| 425 | #define SMB_VFS_SYS_ACL_CLEAR_PERMS(conn, permset) \
|
|---|
| 426 | smb_vfs_call_sys_acl_clear_perms((conn)->vfs_handles, (permset))
|
|---|
| 427 | #define SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle, permset) \
|
|---|
| 428 | smb_vfs_call_sys_acl_clear_perms((handle)->next, (permset))
|
|---|
| 429 |
|
|---|
| 430 | #define SMB_VFS_SYS_ACL_ADD_PERM(conn, permset, perm) \
|
|---|
| 431 | smb_vfs_call_sys_acl_add_perm((conn)->vfs_handles, (permset), (perm))
|
|---|
| 432 | #define SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle, permset, perm) \
|
|---|
| 433 | smb_vfs_call_sys_acl_add_perm((handle)->next, (permset), (perm))
|
|---|
| 434 |
|
|---|
| 435 | #define SMB_VFS_SYS_ACL_TO_TEXT(conn, theacl, plen) \
|
|---|
| 436 | smb_vfs_call_sys_acl_to_text((conn)->vfs_handles, (theacl), (plen))
|
|---|
| 437 | #define SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle, theacl, plen) \
|
|---|
| 438 | smb_vfs_call_sys_acl_to_text((handle)->next, (theacl), (plen))
|
|---|
| 439 |
|
|---|
| 440 | #define SMB_VFS_SYS_ACL_INIT(conn, count) \
|
|---|
| 441 | smb_vfs_call_sys_acl_init((conn)->vfs_handles, (count))
|
|---|
| 442 | #define SMB_VFS_NEXT_SYS_ACL_INIT(handle, count) \
|
|---|
| 443 | smb_vfs_call_sys_acl_init((handle)->next, (count))
|
|---|
| 444 |
|
|---|
| 445 | #define SMB_VFS_SYS_ACL_CREATE_ENTRY(conn, pacl, pentry) \
|
|---|
| 446 | smb_vfs_call_sys_acl_create_entry((conn)->vfs_handles, (pacl), (pentry))
|
|---|
| 447 | #define SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle, pacl, pentry) \
|
|---|
| 448 | smb_vfs_call_sys_acl_create_entry((handle)->next, (pacl), (pentry))
|
|---|
| 449 |
|
|---|
| 450 | #define SMB_VFS_SYS_ACL_SET_TAG_TYPE(conn, entry, tagtype) \
|
|---|
| 451 | smb_vfs_call_sys_acl_set_tag_type((conn)->vfs_handles, (entry), (tagtype))
|
|---|
| 452 | #define SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle, entry, tagtype) \
|
|---|
| 453 | smb_vfs_call_sys_acl_set_tag_type((handle)->next, (entry), (tagtype))
|
|---|
| 454 |
|
|---|
| 455 | #define SMB_VFS_SYS_ACL_SET_QUALIFIER(conn, entry, qual) \
|
|---|
| 456 | smb_vfs_call_sys_acl_set_qualifier((conn)->vfs_handles, (entry), (qual))
|
|---|
| 457 | #define SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle, entry, qual) \
|
|---|
| 458 | smb_vfs_call_sys_acl_set_qualifier((handle)->next, (entry), (qual))
|
|---|
| 459 |
|
|---|
| 460 | #define SMB_VFS_SYS_ACL_SET_PERMSET(conn, entry, permset) \
|
|---|
| 461 | smb_vfs_call_sys_acl_set_permset((conn)->vfs_handles, (entry), (permset))
|
|---|
| 462 | #define SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle, entry, permset) \
|
|---|
| 463 | smb_vfs_call_sys_acl_set_permset((handle)->next, (entry), (permset))
|
|---|
| 464 |
|
|---|
| 465 | #define SMB_VFS_SYS_ACL_VALID(conn, theacl) \
|
|---|
| 466 | smb_vfs_call_sys_acl_valid((conn)->vfs_handles, (theacl))
|
|---|
| 467 | #define SMB_VFS_NEXT_SYS_ACL_VALID(handle, theacl) \
|
|---|
| 468 | smb_vfs_call_sys_acl_valid((handle)->next, (theacl))
|
|---|
| 469 |
|
|---|
| 470 | #define SMB_VFS_SYS_ACL_SET_FILE(conn, name, acltype, theacl) \
|
|---|
| 471 | smb_vfs_call_sys_acl_set_file((conn)->vfs_handles, (name), (acltype), (theacl))
|
|---|
| 472 | #define SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name, acltype, theacl) \
|
|---|
| 473 | smb_vfs_call_sys_acl_set_file((handle)->next, (name), (acltype), (theacl))
|
|---|
| 474 |
|
|---|
| 475 | #define SMB_VFS_SYS_ACL_SET_FD(fsp, theacl) \
|
|---|
| 476 | smb_vfs_call_sys_acl_set_fd((fsp)->conn->vfs_handles, (fsp), (theacl))
|
|---|
| 477 | #define SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl) \
|
|---|
| 478 | smb_vfs_call_sys_acl_set_fd((handle)->next, (fsp), (theacl))
|
|---|
| 479 |
|
|---|
| 480 | #define SMB_VFS_SYS_ACL_DELETE_DEF_FILE(conn, path) \
|
|---|
| 481 | smb_vfs_call_sys_acl_delete_def_file((conn)->vfs_handles, (path))
|
|---|
| 482 | #define SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path) \
|
|---|
| 483 | smb_vfs_call_sys_acl_delete_def_file((handle)->next, (path))
|
|---|
| 484 |
|
|---|
| 485 | #define SMB_VFS_SYS_ACL_GET_PERM(conn, permset, perm) \
|
|---|
| 486 | smb_vfs_call_sys_acl_get_perm((conn)->vfs_handles, (permset), (perm))
|
|---|
| 487 | #define SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle, permset, perm) \
|
|---|
| 488 | smb_vfs_call_sys_acl_get_perm((handle)->next, (permset), (perm))
|
|---|
| 489 |
|
|---|
| 490 | #define SMB_VFS_SYS_ACL_FREE_TEXT(conn, text) \
|
|---|
| 491 | smb_vfs_call_sys_acl_free_text((conn)->vfs_handles, (text))
|
|---|
| 492 | #define SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle, text) \
|
|---|
| 493 | smb_vfs_call_sys_acl_free_text((handle)->next, (text))
|
|---|
| 494 |
|
|---|
| 495 | #define SMB_VFS_SYS_ACL_FREE_ACL(conn, posix_acl) \
|
|---|
| 496 | smb_vfs_call_sys_acl_free_acl((conn)->vfs_handles, (posix_acl))
|
|---|
| 497 | #define SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle, posix_acl) \
|
|---|
| 498 | smb_vfs_call_sys_acl_free_acl((handle)->next, (posix_acl))
|
|---|
| 499 |
|
|---|
| 500 | #define SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, qualifier, tagtype) \
|
|---|
| 501 | smb_vfs_call_sys_acl_free_qualifier((conn)->vfs_handles, (qualifier), (tagtype))
|
|---|
| 502 | #define SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle, qualifier, tagtype) \
|
|---|
| 503 | smb_vfs_call_sys_acl_free_qualifier((handle)->next, (qualifier), (tagtype))
|
|---|
| 504 |
|
|---|
| 505 | #define SMB_VFS_GETXATTR(conn,path,name,value,size) \
|
|---|
| 506 | smb_vfs_call_getxattr((conn)->vfs_handles,(path),(name),(value),(size))
|
|---|
| 507 | #define SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size) \
|
|---|
| 508 | smb_vfs_call_getxattr((handle)->next,(path),(name),(value),(size))
|
|---|
| 509 |
|
|---|
| 510 | #define SMB_VFS_LGETXATTR(conn,path,name,value,size) \
|
|---|
| 511 | smb_vfs_call_lgetxattr((conn)->vfs_handles,(path),(name),(value),(size))
|
|---|
| 512 | #define SMB_VFS_NEXT_LGETXATTR(handle,path,name,value,size) \
|
|---|
| 513 | smb_vfs_call_lgetxattr((handle)->next,(path),(name),(value),(size))
|
|---|
| 514 |
|
|---|
| 515 | #define SMB_VFS_FGETXATTR(fsp,name,value,size) \
|
|---|
| 516 | smb_vfs_call_fgetxattr((fsp)->conn->vfs_handles, (fsp), (name),(value),(size))
|
|---|
| 517 | #define SMB_VFS_NEXT_FGETXATTR(handle,fsp,name,value,size) \
|
|---|
| 518 | smb_vfs_call_fgetxattr((handle)->next,(fsp),(name),(value),(size))
|
|---|
| 519 |
|
|---|
| 520 | #define SMB_VFS_LISTXATTR(conn,path,list,size) \
|
|---|
| 521 | smb_vfs_call_listxattr((conn)->vfs_handles,(path),(list),(size))
|
|---|
| 522 | #define SMB_VFS_NEXT_LISTXATTR(handle,path,list,size) \
|
|---|
| 523 | smb_vfs_call_listxattr((handle)->next,(path),(list),(size))
|
|---|
| 524 |
|
|---|
| 525 | #define SMB_VFS_LLISTXATTR(conn,path,list,size) \
|
|---|
| 526 | smb_vfs_call_llistxattr((conn)->vfs_handles,(path),(list),(size))
|
|---|
| 527 | #define SMB_VFS_NEXT_LLISTXATTR(handle,path,list,size) \
|
|---|
| 528 | smb_vfs_call_llistxattr((handle)->next,(path),(list),(size))
|
|---|
| 529 |
|
|---|
| 530 | #define SMB_VFS_FLISTXATTR(fsp,list,size) \
|
|---|
| 531 | smb_vfs_call_flistxattr((fsp)->conn->vfs_handles, (fsp), (list),(size))
|
|---|
| 532 | #define SMB_VFS_NEXT_FLISTXATTR(handle,fsp,list,size) \
|
|---|
| 533 | smb_vfs_call_flistxattr((handle)->next,(fsp),(list),(size))
|
|---|
| 534 |
|
|---|
| 535 | #define SMB_VFS_REMOVEXATTR(conn,path,name) \
|
|---|
| 536 | smb_vfs_call_removexattr((conn)->vfs_handles,(path),(name))
|
|---|
| 537 | #define SMB_VFS_NEXT_REMOVEXATTR(handle,path,name) \
|
|---|
| 538 | smb_vfs_call_removexattr((handle)->next,(path),(name))
|
|---|
| 539 |
|
|---|
| 540 | #define SMB_VFS_LREMOVEXATTR(conn,path,name) \
|
|---|
| 541 | smb_vfs_call_lremovexattr((conn)->vfs_handles,(path),(name))
|
|---|
| 542 | #define SMB_VFS_NEXT_LREMOVEXATTR(handle,path,name) \
|
|---|
| 543 | smb_vfs_call_lremovexattr((handle)->next,(path),(name))
|
|---|
| 544 |
|
|---|
| 545 | #define SMB_VFS_FREMOVEXATTR(fsp,name) \
|
|---|
| 546 | smb_vfs_call_fremovexattr((fsp)->conn->vfs_handles, (fsp), (name))
|
|---|
| 547 | #define SMB_VFS_NEXT_FREMOVEXATTR(handle,fsp,name) \
|
|---|
| 548 | smb_vfs_call_fremovexattr((handle)->next,(fsp),(name))
|
|---|
| 549 |
|
|---|
| 550 | #define SMB_VFS_SETXATTR(conn,path,name,value,size,flags) \
|
|---|
| 551 | smb_vfs_call_setxattr((conn)->vfs_handles,(path),(name),(value),(size),(flags))
|
|---|
| 552 | #define SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags) \
|
|---|
| 553 | smb_vfs_call_setxattr((handle)->next,(path),(name),(value),(size),(flags))
|
|---|
| 554 |
|
|---|
| 555 | #define SMB_VFS_LSETXATTR(conn,path,name,value,size,flags) \
|
|---|
| 556 | smb_vfs_call_lsetxattr((conn)->vfs_handles,(path),(name),(value),(size),(flags))
|
|---|
| 557 | #define SMB_VFS_NEXT_LSETXATTR(handle,path,name,value,size,flags) \
|
|---|
| 558 | smb_vfs_call_lsetxattr((handle)->next,(path),(name),(value),(size),(flags))
|
|---|
| 559 |
|
|---|
| 560 | #define SMB_VFS_FSETXATTR(fsp,name,value,size,flags) \
|
|---|
| 561 | smb_vfs_call_fsetxattr((fsp)->conn->vfs_handles, (fsp), (name),(value),(size),(flags))
|
|---|
| 562 | #define SMB_VFS_NEXT_FSETXATTR(handle,fsp,name,value,size,flags) \
|
|---|
| 563 | smb_vfs_call_fsetxattr((handle)->next,(fsp),(name),(value),(size),(flags))
|
|---|
| 564 |
|
|---|
| 565 | #define SMB_VFS_AIO_READ(fsp,aiocb) \
|
|---|
| 566 | smb_vfs_call_aio_read((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 567 | #define SMB_VFS_NEXT_AIO_READ(handle,fsp,aiocb) \
|
|---|
| 568 | smb_vfs_call_aio_read((handle)->next,(fsp),(aiocb))
|
|---|
| 569 |
|
|---|
| 570 | #define SMB_VFS_AIO_WRITE(fsp,aiocb) \
|
|---|
| 571 | smb_vfs_call_aio_write((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 572 | #define SMB_VFS_NEXT_AIO_WRITE(handle,fsp,aiocb) \
|
|---|
| 573 | smb_vfs_call_aio_write((handle)->next,(fsp),(aiocb))
|
|---|
| 574 |
|
|---|
| 575 | #define SMB_VFS_AIO_RETURN(fsp,aiocb) \
|
|---|
| 576 | smb_vfs_call_aio_return_fn((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 577 | #define SMB_VFS_NEXT_AIO_RETURN(handle,fsp,aiocb) \
|
|---|
| 578 | smb_vfs_call_aio_return_fn((handle)->next,(fsp),(aiocb))
|
|---|
| 579 |
|
|---|
| 580 | #define SMB_VFS_AIO_CANCEL(fsp,aiocb) \
|
|---|
| 581 | smb_vfs_call_aio_cancel((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 582 | #define SMB_VFS_NEXT_AIO_CANCEL(handle,fsp,aiocb) \
|
|---|
| 583 | smb_vfs_call_aio_cancel((handle)->next,(fsp),(aiocb))
|
|---|
| 584 |
|
|---|
| 585 | #define SMB_VFS_AIO_ERROR(fsp,aiocb) \
|
|---|
| 586 | smb_vfs_call_aio_error_fn((fsp)->conn->vfs_handles, (fsp),(aiocb))
|
|---|
| 587 | #define SMB_VFS_NEXT_AIO_ERROR(handle,fsp,aiocb) \
|
|---|
| 588 | smb_vfs_call_aio_error_fn((handle)->next,(fsp),(aiocb))
|
|---|
| 589 |
|
|---|
| 590 | #define SMB_VFS_AIO_FSYNC(fsp,op,aiocb) \
|
|---|
| 591 | smb_vfs_call_aio_fsync((fsp)->conn->vfs_handles, (fsp), (op),(aiocb))
|
|---|
| 592 | #define SMB_VFS_NEXT_AIO_FSYNC(handle,fsp,op,aiocb) \
|
|---|
| 593 | smb_vfs_call_aio_fsync((handle)->next,(fsp),(op),(aiocb))
|
|---|
| 594 |
|
|---|
| 595 | #define SMB_VFS_AIO_SUSPEND(fsp,aiocb,n,ts) \
|
|---|
| 596 | smb_vfs_call_aio_suspend((fsp)->conn->vfs_handles, (fsp),(aiocb),(n),(ts))
|
|---|
| 597 | #define SMB_VFS_NEXT_AIO_SUSPEND(handle,fsp,aiocb,n,ts) \
|
|---|
| 598 | smb_vfs_call_aio_suspend((handle)->next,(fsp),(aiocb),(n),(ts))
|
|---|
| 599 |
|
|---|
| 600 | #define SMB_VFS_AIO_FORCE(fsp) \
|
|---|
| 601 | smb_vfs_call_aio_force((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 602 | #define SMB_VFS_NEXT_AIO_FORCE(handle,fsp) \
|
|---|
| 603 | smb_vfs_call_aio_force((handle)->next,(fsp))
|
|---|
| 604 |
|
|---|
| 605 | #define SMB_VFS_IS_OFFLINE(conn,fname,sbuf) \
|
|---|
| 606 | smb_vfs_call_is_offline((conn)->vfs_handles,(fname),(sbuf))
|
|---|
| 607 | #define SMB_VFS_NEXT_IS_OFFLINE(handle,fname,sbuf) \
|
|---|
| 608 | smb_vfs_call_is_offline((handle)->next,(fname),(sbuf))
|
|---|
| 609 |
|
|---|
| 610 | #define SMB_VFS_SET_OFFLINE(conn,fname) \
|
|---|
| 611 | smb_vfs_call_set_offline((conn)->vfs_handles,(fname))
|
|---|
| 612 | #define SMB_VFS_NEXT_SET_OFFLINE(handle,fname) \
|
|---|
| 613 | smb_vfs_call_set_offline((handle)->next, (fname))
|
|---|
| 614 |
|
|---|
| 615 | #endif /* _VFS_MACROS_H */
|
|---|
