| 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_READDIR(conn, dirp, sbuf) \
|
|---|
| 78 | smb_vfs_call_readdir((conn)->vfs_handles, (dirp), (sbuf))
|
|---|
| 79 | #define SMB_VFS_NEXT_READDIR(handle, dirp, sbuf) \
|
|---|
| 80 | smb_vfs_call_readdir((handle)->next, (dirp), (sbuf))
|
|---|
| 81 |
|
|---|
| 82 | #define SMB_VFS_SEEKDIR(conn, dirp, offset) \
|
|---|
| 83 | smb_vfs_call_seekdir((conn)->vfs_handles, (dirp), (offset))
|
|---|
| 84 | #define SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset) \
|
|---|
| 85 | smb_vfs_call_seekdir((handle)->next, (dirp), (offset))
|
|---|
| 86 |
|
|---|
| 87 | #define SMB_VFS_TELLDIR(conn, dirp) \
|
|---|
| 88 | smb_vfs_call_telldir((conn)->vfs_handles, (dirp))
|
|---|
| 89 | #define SMB_VFS_NEXT_TELLDIR(handle, dirp) \
|
|---|
| 90 | smb_vfs_call_telldir((handle)->next, (dirp))
|
|---|
| 91 |
|
|---|
| 92 | #define SMB_VFS_REWINDDIR(conn, dirp) \
|
|---|
| 93 | smb_vfs_call_rewind_dir((conn)->vfs_handles, (dirp))
|
|---|
| 94 | #define SMB_VFS_NEXT_REWINDDIR(handle, dirp) \
|
|---|
| 95 | smb_vfs_call_rewind_dir((handle)->next, (dirp))
|
|---|
| 96 |
|
|---|
| 97 | #define SMB_VFS_MKDIR(conn, path, mode) \
|
|---|
| 98 | smb_vfs_call_mkdir((conn)->vfs_handles,(path), (mode))
|
|---|
| 99 | #define SMB_VFS_NEXT_MKDIR(handle, path, mode) \
|
|---|
| 100 | smb_vfs_call_mkdir((handle)->next,(path), (mode))
|
|---|
| 101 |
|
|---|
| 102 | #define SMB_VFS_RMDIR(conn, path) \
|
|---|
| 103 | smb_vfs_call_rmdir((conn)->vfs_handles, (path))
|
|---|
| 104 | #define SMB_VFS_NEXT_RMDIR(handle, path) \
|
|---|
| 105 | smb_vfs_call_rmdir((handle)->next, (path))
|
|---|
| 106 |
|
|---|
| 107 | #define SMB_VFS_CLOSEDIR(conn, dir) \
|
|---|
| 108 | smb_vfs_call_closedir((conn)->vfs_handles, dir)
|
|---|
| 109 | #define SMB_VFS_NEXT_CLOSEDIR(handle, dir) \
|
|---|
| 110 | smb_vfs_call_closedir((handle)->next, (dir))
|
|---|
| 111 |
|
|---|
| 112 | #define SMB_VFS_INIT_SEARCH_OP(conn, dirp) \
|
|---|
| 113 | smb_vfs_call_init_search_op((conn)->vfs_handles, (dirp))
|
|---|
| 114 | #define SMB_VFS_NEXT_INIT_SEARCH_OP(handle, dirp) \
|
|---|
| 115 | smb_vfs_call_init_search_op((handle)->next, (dirp))
|
|---|
| 116 |
|
|---|
| 117 | /* File operations */
|
|---|
| 118 | #define SMB_VFS_OPEN(conn, fname, fsp, flags, mode) \
|
|---|
| 119 | smb_vfs_call_open((conn)->vfs_handles, (fname), (fsp), (flags), (mode))
|
|---|
| 120 | #define SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode) \
|
|---|
| 121 | smb_vfs_call_open((handle)->next, (fname), (fsp), (flags), (mode))
|
|---|
| 122 |
|
|---|
| 123 | #define SMB_VFS_CREATE_FILE(conn, req, root_dir_fid, smb_fname, access_mask, share_access, create_disposition, create_options, file_attributes, oplock_request, allocation_size, sd, ea_list, result, pinfo) \
|
|---|
| 124 | smb_vfs_call_create_file((conn)->vfs_handles, (req), (root_dir_fid), (smb_fname), (access_mask), (share_access), (create_disposition), (create_options), (file_attributes), (oplock_request), (allocation_size), (sd), (ea_list), (result), (pinfo))
|
|---|
| 125 | #define SMB_VFS_NEXT_CREATE_FILE(handle, req, root_dir_fid, smb_fname, access_mask, share_access, create_disposition, create_options, file_attributes, oplock_request, allocation_size, sd, ea_list, result, pinfo) \
|
|---|
| 126 | smb_vfs_call_create_file((handle)->next, (req), (root_dir_fid), (smb_fname), (access_mask), (share_access), (create_disposition), (create_options), (file_attributes), (oplock_request), (allocation_size), (sd), (ea_list), (result), (pinfo))
|
|---|
| 127 |
|
|---|
| 128 | #define SMB_VFS_CLOSE(fsp) \
|
|---|
| 129 | smb_vfs_call_close_fn((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 130 | #define SMB_VFS_NEXT_CLOSE(handle, fsp) \
|
|---|
| 131 | smb_vfs_call_close_fn((handle)->next, (fsp))
|
|---|
| 132 |
|
|---|
| 133 | #define SMB_VFS_READ(fsp, data, n) \
|
|---|
| 134 | smb_vfs_call_vfs_read((fsp)->conn->vfs_handles, (fsp), (data), (n))
|
|---|
| 135 | #define SMB_VFS_NEXT_READ(handle, fsp, data, n) \
|
|---|
| 136 | smb_vfs_call_vfs_read((handle)->next, (fsp), (data), (n))
|
|---|
| 137 |
|
|---|
| 138 | #define SMB_VFS_PREAD(fsp, data, n, off) \
|
|---|
| 139 | smb_vfs_call_pread((fsp)->conn->vfs_handles, (fsp), (data), (n), (off))
|
|---|
| 140 | #define SMB_VFS_NEXT_PREAD(handle, fsp, data, n, off) \
|
|---|
| 141 | smb_vfs_call_pread((handle)->next, (fsp), (data), (n), (off))
|
|---|
| 142 |
|
|---|
| 143 | #define SMB_VFS_WRITE(fsp, data, n) \
|
|---|
| 144 | smb_vfs_call_write((fsp)->conn->vfs_handles, (fsp), (data), (n))
|
|---|
| 145 | #define SMB_VFS_NEXT_WRITE(handle, fsp, data, n) \
|
|---|
| 146 | smb_vfs_call_write((handle)->next, (fsp), (data), (n))
|
|---|
| 147 |
|
|---|
| 148 | #define SMB_VFS_PWRITE(fsp, data, n, off) \
|
|---|
| 149 | smb_vfs_call_pwrite((fsp)->conn->vfs_handles, (fsp), (data), (n), (off))
|
|---|
| 150 | #define SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, off) \
|
|---|
| 151 | smb_vfs_call_pwrite((handle)->next, (fsp), (data), (n), (off))
|
|---|
| 152 |
|
|---|
| 153 | #define SMB_VFS_LSEEK(fsp, offset, whence) \
|
|---|
| 154 | smb_vfs_call_lseek((fsp)->conn->vfs_handles, (fsp), (offset), (whence))
|
|---|
| 155 | #define SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence) \
|
|---|
| 156 | smb_vfs_call_lseek((handle)->next, (fsp), (offset), (whence))
|
|---|
| 157 |
|
|---|
| 158 | #define SMB_VFS_SENDFILE(tofd, fromfsp, header, offset, count) \
|
|---|
| 159 | smb_vfs_call_sendfile((fromfsp)->conn->vfs_handles, (tofd), (fromfsp), (header), (offset), (count))
|
|---|
| 160 | #define SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, header, offset, count) \
|
|---|
| 161 | smb_vfs_call_sendfile((handle)->next, (tofd), (fromfsp), (header), (offset), (count))
|
|---|
| 162 |
|
|---|
| 163 | #define SMB_VFS_RECVFILE(fromfd, tofsp, offset, count) \
|
|---|
| 164 | smb_vfs_call_recvfile((tofsp)->conn->vfs_handles, (fromfd), (tofsp), (offset), (count))
|
|---|
| 165 | #define SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, count) \
|
|---|
| 166 | smb_vfs_call_recvfile((handle)->next, (fromfd), (tofsp), (offset), (count))
|
|---|
| 167 |
|
|---|
| 168 | #define SMB_VFS_RENAME(conn, old, new) \
|
|---|
| 169 | smb_vfs_call_rename((conn)->vfs_handles, (old), (new))
|
|---|
| 170 | #define SMB_VFS_NEXT_RENAME(handle, old, new) \
|
|---|
| 171 | smb_vfs_call_rename((handle)->next, (old), (new))
|
|---|
| 172 |
|
|---|
| 173 | #define SMB_VFS_FSYNC(fsp) \
|
|---|
| 174 | smb_vfs_call_fsync((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 175 | #define SMB_VFS_NEXT_FSYNC(handle, fsp) \
|
|---|
| 176 | smb_vfs_call_fsync((handle)->next, (fsp))
|
|---|
| 177 |
|
|---|
| 178 | #define SMB_VFS_STAT(conn, smb_fname) \
|
|---|
| 179 | smb_vfs_call_stat((conn)->vfs_handles, (smb_fname))
|
|---|
| 180 | #define SMB_VFS_NEXT_STAT(handle, smb_fname) \
|
|---|
| 181 | smb_vfs_call_stat((handle)->next, (smb_fname))
|
|---|
| 182 |
|
|---|
| 183 | #define SMB_VFS_FSTAT(fsp, sbuf) \
|
|---|
| 184 | smb_vfs_call_fstat((fsp)->conn->vfs_handles, (fsp), (sbuf))
|
|---|
| 185 | #define SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf) \
|
|---|
| 186 | smb_vfs_call_fstat((handle)->next, (fsp), (sbuf))
|
|---|
| 187 |
|
|---|
| 188 | #define SMB_VFS_LSTAT(conn, smb_fname) \
|
|---|
| 189 | smb_vfs_call_lstat((conn)->vfs_handles, (smb_fname))
|
|---|
| 190 | #define SMB_VFS_NEXT_LSTAT(handle, smb_fname) \
|
|---|
| 191 | smb_vfs_call_lstat((handle)->next, (smb_fname))
|
|---|
| 192 |
|
|---|
| 193 | #define SMB_VFS_GET_ALLOC_SIZE(conn, fsp, sbuf) \
|
|---|
| 194 | smb_vfs_call_get_alloc_size((conn)->vfs_handles, (fsp), (sbuf))
|
|---|
| 195 | #define SMB_VFS_NEXT_GET_ALLOC_SIZE(conn, fsp, sbuf) \
|
|---|
| 196 | smb_vfs_call_get_alloc_size((conn)->next, (fsp), (sbuf))
|
|---|
| 197 |
|
|---|
| 198 | #define SMB_VFS_UNLINK(conn, path) \
|
|---|
| 199 | smb_vfs_call_unlink((conn)->vfs_handles, (path))
|
|---|
| 200 | #define SMB_VFS_NEXT_UNLINK(handle, path) \
|
|---|
| 201 | smb_vfs_call_unlink((handle)->next, (path))
|
|---|
| 202 |
|
|---|
| 203 | #define SMB_VFS_CHMOD(conn, path, mode) \
|
|---|
| 204 | smb_vfs_call_chmod((conn)->vfs_handles, (path), (mode))
|
|---|
| 205 | #define SMB_VFS_NEXT_CHMOD(handle, path, mode) \
|
|---|
| 206 | smb_vfs_call_chmod((handle)->next, (path), (mode))
|
|---|
| 207 |
|
|---|
| 208 | #define SMB_VFS_FCHMOD(fsp, mode) \
|
|---|
| 209 | smb_vfs_call_fchmod((fsp)->conn->vfs_handles, (fsp), (mode))
|
|---|
| 210 | #define SMB_VFS_NEXT_FCHMOD(handle, fsp, mode) \
|
|---|
| 211 | smb_vfs_call_fchmod((handle)->next, (fsp), (mode))
|
|---|
| 212 |
|
|---|
| 213 | #define SMB_VFS_CHOWN(conn, path, uid, gid) \
|
|---|
| 214 | smb_vfs_call_chown((conn)->vfs_handles, (path), (uid), (gid))
|
|---|
| 215 | #define SMB_VFS_NEXT_CHOWN(handle, path, uid, gid) \
|
|---|
| 216 | smb_vfs_call_chown((handle)->next, (path), (uid), (gid))
|
|---|
| 217 |
|
|---|
| 218 | #define SMB_VFS_FCHOWN(fsp, uid, gid) \
|
|---|
| 219 | smb_vfs_call_fchown((fsp)->conn->vfs_handles, (fsp), (uid), (gid))
|
|---|
| 220 | #define SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid) \
|
|---|
| 221 | smb_vfs_call_fchown((handle)->next, (fsp), (uid), (gid))
|
|---|
| 222 |
|
|---|
| 223 | #define SMB_VFS_LCHOWN(conn, path, uid, gid) \
|
|---|
| 224 | smb_vfs_call_lchown((conn)->vfs_handles, (path), (uid), (gid))
|
|---|
| 225 | #define SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid) \
|
|---|
| 226 | smb_vfs_call_lchown((handle)->next, (path), (uid), (gid))
|
|---|
| 227 |
|
|---|
| 228 | #define SMB_VFS_CHDIR(conn, path) \
|
|---|
| 229 | smb_vfs_call_chdir((conn)->vfs_handles, (path))
|
|---|
| 230 | #define SMB_VFS_NEXT_CHDIR(handle, path) \
|
|---|
| 231 | smb_vfs_call_chdir((handle)->next, (path))
|
|---|
| 232 |
|
|---|
| 233 | #define SMB_VFS_GETWD(conn, buf) \
|
|---|
| 234 | smb_vfs_call_getwd((conn)->vfs_handles, (buf))
|
|---|
| 235 | #define SMB_VFS_NEXT_GETWD(handle, buf) \
|
|---|
| 236 | smb_vfs_call_getwd((handle)->next, (buf))
|
|---|
| 237 |
|
|---|
| 238 | #define SMB_VFS_NTIMES(conn, path, ts) \
|
|---|
| 239 | smb_vfs_call_ntimes((conn)->vfs_handles, (path), (ts))
|
|---|
| 240 | #define SMB_VFS_NEXT_NTIMES(handle, path, ts) \
|
|---|
| 241 | smb_vfs_call_ntimes((handle)->next, (path), (ts))
|
|---|
| 242 |
|
|---|
| 243 | #define SMB_VFS_FTRUNCATE(fsp, offset) \
|
|---|
| 244 | smb_vfs_call_ftruncate((fsp)->conn->vfs_handles, (fsp), (offset))
|
|---|
| 245 | #define SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset) \
|
|---|
| 246 | smb_vfs_call_ftruncate((handle)->next, (fsp), (offset))
|
|---|
| 247 |
|
|---|
| 248 | #define SMB_VFS_LOCK(fsp, op, offset, count, type) \
|
|---|
| 249 | smb_vfs_call_lock((fsp)->conn->vfs_handles, (fsp), (op), (offset), (count), (type))
|
|---|
| 250 | #define SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type) \
|
|---|
| 251 | smb_vfs_call_lock((handle)->next, (fsp), (op), (offset), (count), (type))
|
|---|
| 252 |
|
|---|
| 253 | #define SMB_VFS_KERNEL_FLOCK(fsp, share_mode, access_mask) \
|
|---|
| 254 | smb_vfs_call_kernel_flock((fsp)->conn->vfs_handles, (fsp), (share_mode), (access_mask))
|
|---|
| 255 | #define SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask) \
|
|---|
| 256 | smb_vfs_call_kernel_flock((handle)->next, (fsp), (share_mode), (access_mask))
|
|---|
| 257 |
|
|---|
| 258 | #define SMB_VFS_LINUX_SETLEASE(fsp, leasetype) \
|
|---|
| 259 | smb_vfs_call_linux_setlease((fsp)->conn->vfs_handles, (fsp), (leasetype))
|
|---|
| 260 | #define SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype) \
|
|---|
| 261 | smb_vfs_call_linux_setlease((handle)->next, (fsp), (leasetype))
|
|---|
| 262 |
|
|---|
| 263 | #define SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, ppid) \
|
|---|
| 264 | smb_vfs_call_getlock((fsp)->conn->vfs_handles, (fsp), (poffset), (pcount), (ptype), (ppid))
|
|---|
| 265 | #define SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid) \
|
|---|
| 266 | smb_vfs_call_getlock((handle)->next, (fsp), (poffset), (pcount), (ptype), (ppid))
|
|---|
| 267 |
|
|---|
| 268 | #define SMB_VFS_SYMLINK(conn, oldpath, newpath) \
|
|---|
| 269 | smb_vfs_call_symlink((conn)->vfs_handles, (oldpath), (newpath))
|
|---|
| 270 | #define SMB_VFS_NEXT_SYMLINK(handle, oldpath, newpath) \
|
|---|
| 271 | smb_vfs_call_symlink((handle)->next, (oldpath), (newpath))
|
|---|
| 272 |
|
|---|
| 273 | #define SMB_VFS_READLINK(conn, path, buf, bufsiz) \
|
|---|
| 274 | smb_vfs_call_vfs_readlink((conn)->vfs_handles, (path), (buf), (bufsiz))
|
|---|
| 275 | #define SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz) \
|
|---|
| 276 | smb_vfs_call_vfs_readlink((handle)->next, (path), (buf), (bufsiz))
|
|---|
| 277 |
|
|---|
| 278 | #define SMB_VFS_LINK(conn, oldpath, newpath) \
|
|---|
| 279 | smb_vfs_call_link((conn)->vfs_handles, (oldpath), (newpath))
|
|---|
| 280 | #define SMB_VFS_NEXT_LINK(handle, oldpath, newpath) \
|
|---|
| 281 | smb_vfs_call_link((handle)->next, (oldpath), (newpath))
|
|---|
| 282 |
|
|---|
| 283 | #define SMB_VFS_MKNOD(conn, path, mode, dev) \
|
|---|
| 284 | smb_vfs_call_mknod((conn)->vfs_handles, (path), (mode), (dev))
|
|---|
| 285 | #define SMB_VFS_NEXT_MKNOD(handle, path, mode, dev) \
|
|---|
| 286 | smb_vfs_call_mknod((handle)->next, (path), (mode), (dev))
|
|---|
| 287 |
|
|---|
| 288 | #define SMB_VFS_REALPATH(conn, path, resolved_path) \
|
|---|
| 289 | smb_vfs_call_realpath((conn)->vfs_handles, (path), (resolved_path))
|
|---|
| 290 | #define SMB_VFS_NEXT_REALPATH(handle, path, resolved_path) \
|
|---|
| 291 | smb_vfs_call_realpath((handle)->next, (path), (resolved_path))
|
|---|
| 292 |
|
|---|
| 293 | #define SMB_VFS_NOTIFY_WATCH(conn, ctx, e, callback, private_data, handle_p) \
|
|---|
| 294 | smb_vfs_call_notify_watch((conn)->vfs_handles, (ctx), (e), (callback), (private_data), (handle_p))
|
|---|
| 295 | #define SMB_VFS_NEXT_NOTIFY_WATCH(conn, ctx, e, callback, private_data, handle_p) \
|
|---|
| 296 | smb_vfs_call_notify_watch((conn)->next, (ctx), (e), (callback), (private_data), (handle_p))
|
|---|
| 297 |
|
|---|
| 298 | #define SMB_VFS_CHFLAGS(conn, path, flags) \
|
|---|
| 299 | smb_vfs_call_chflags((conn)->vfs_handles, (path), (flags))
|
|---|
| 300 | #define SMB_VFS_NEXT_CHFLAGS(handle, path, flags) \
|
|---|
| 301 | smb_vfs_call_chflags((handle)->next, (path), (flags))
|
|---|
| 302 |
|
|---|
| 303 | #define SMB_VFS_FILE_ID_CREATE(conn, sbuf) \
|
|---|
| 304 | smb_vfs_call_file_id_create((conn)->vfs_handles, (sbuf))
|
|---|
| 305 | #define SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf) \
|
|---|
| 306 | smb_vfs_call_file_id_create((handle)->next, (sbuf))
|
|---|
| 307 |
|
|---|
| 308 | #define SMB_VFS_STREAMINFO(conn, fsp, fname, mem_ctx, num_streams, streams) \
|
|---|
| 309 | smb_vfs_call_streaminfo((conn)->vfs_handles, (fsp), (fname), (mem_ctx), (num_streams), (streams))
|
|---|
| 310 | #define SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname, mem_ctx, num_streams, streams) \
|
|---|
| 311 | smb_vfs_call_streaminfo((handle)->next, (fsp), (fname), (mem_ctx), (num_streams), (streams))
|
|---|
| 312 |
|
|---|
| 313 | #define SMB_VFS_GET_REAL_FILENAME(conn, path, name, mem_ctx, found_name) \
|
|---|
| 314 | smb_vfs_call_get_real_filename((conn)->vfs_handles, (path), (name), (mem_ctx), (found_name))
|
|---|
| 315 | #define SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx, found_name) \
|
|---|
| 316 | smb_vfs_call_get_real_filename((handle)->next, (path), (name), (mem_ctx), (found_name))
|
|---|
| 317 |
|
|---|
| 318 | #define SMB_VFS_CONNECTPATH(conn, fname) \
|
|---|
| 319 | smb_vfs_call_connectpath((conn)->vfs_handles, (fname))
|
|---|
| 320 | #define SMB_VFS_NEXT_CONNECTPATH(conn, fname) \
|
|---|
| 321 | smb_vfs_call_connectpath((conn)->next, (fname))
|
|---|
| 322 |
|
|---|
| 323 | #define SMB_VFS_BRL_LOCK_WINDOWS(conn, br_lck, plock, blocking_lock, blr) \
|
|---|
| 324 | smb_vfs_call_brl_lock_windows((conn)->vfs_handles, (br_lck), (plock), (blocking_lock), (blr))
|
|---|
| 325 | #define SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock, blocking_lock, blr) \
|
|---|
| 326 | smb_vfs_call_brl_lock_windows((handle)->next, (br_lck), (plock), (blocking_lock), (blr))
|
|---|
| 327 |
|
|---|
| 328 | #define SMB_VFS_BRL_UNLOCK_WINDOWS(conn, msg_ctx, br_lck, plock) \
|
|---|
| 329 | smb_vfs_call_brl_unlock_windows((conn)->vfs_handles, (msg_ctx), (br_lck), (plock))
|
|---|
| 330 | #define SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck, plock) \
|
|---|
| 331 | smb_vfs_call_brl_unlock_windows((handle)->next, (msg_ctx), (br_lck), (plock))
|
|---|
| 332 |
|
|---|
| 333 | #define SMB_VFS_BRL_CANCEL_WINDOWS(conn, br_lck, plock, blr) \
|
|---|
| 334 | smb_vfs_call_brl_cancel_windows((conn)->vfs_handles, (br_lck), (plock), (blr))
|
|---|
| 335 | #define SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock, blr) \
|
|---|
| 336 | smb_vfs_call_brl_cancel_windows((handle)->next, (br_lck), (plock), (blr))
|
|---|
| 337 |
|
|---|
| 338 | #define SMB_VFS_STRICT_LOCK(conn, fsp, plock) \
|
|---|
| 339 | smb_vfs_call_strict_lock((conn)->vfs_handles, (fsp), (plock))
|
|---|
| 340 | #define SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock) \
|
|---|
| 341 | smb_vfs_call_strict_lock((handle)->next, (fsp), (plock))
|
|---|
| 342 |
|
|---|
| 343 | #define SMB_VFS_STRICT_UNLOCK(conn, fsp, plock) \
|
|---|
| 344 | smb_vfs_call_strict_unlock((conn)->vfs_handles, (fsp), (plock))
|
|---|
| 345 | #define SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock) \
|
|---|
| 346 | smb_vfs_call_strict_unlock((handle)->next, (fsp), (plock))
|
|---|
| 347 |
|
|---|
| 348 | #define SMB_VFS_TRANSLATE_NAME(conn, name, direction, mem_ctx, mapped_name) \
|
|---|
| 349 | smb_vfs_call_translate_name((conn)->vfs_handles, (name), (direction), (mem_ctx), (mapped_name))
|
|---|
| 350 | #define SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx, mapped_name) \
|
|---|
| 351 | smb_vfs_call_translate_name((handle)->next, (name), (direction), (mem_ctx), (mapped_name))
|
|---|
| 352 |
|
|---|
| 353 | #define SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock) \
|
|---|
| 354 | smb_vfs_call_strict_unlock((handle)->next, (fsp), (plock))
|
|---|
| 355 |
|
|---|
| 356 | #define SMB_VFS_FGET_NT_ACL(fsp, security_info, ppdesc) \
|
|---|
| 357 | smb_vfs_call_fget_nt_acl((fsp)->conn->vfs_handles, (fsp), (security_info), (ppdesc))
|
|---|
| 358 | #define SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, ppdesc) \
|
|---|
| 359 | smb_vfs_call_fget_nt_acl((handle)->next, (fsp), (security_info), (ppdesc))
|
|---|
| 360 |
|
|---|
| 361 | #define SMB_VFS_GET_NT_ACL(conn, name, security_info, ppdesc) \
|
|---|
| 362 | smb_vfs_call_get_nt_acl((conn)->vfs_handles, (name), (security_info), (ppdesc))
|
|---|
| 363 | #define SMB_VFS_NEXT_GET_NT_ACL(handle, name, security_info, ppdesc) \
|
|---|
| 364 | smb_vfs_call_get_nt_acl((handle)->next, (name), (security_info), (ppdesc))
|
|---|
| 365 |
|
|---|
| 366 | #define SMB_VFS_FSET_NT_ACL(fsp, security_info_sent, psd) \
|
|---|
| 367 | smb_vfs_call_fset_nt_acl((fsp)->conn->vfs_handles, (fsp), (security_info_sent), (psd))
|
|---|
| 368 | #define SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd) \
|
|---|
| 369 | smb_vfs_call_fset_nt_acl((handle)->next, (fsp), (security_info_sent), (psd))
|
|---|
| 370 |
|
|---|
| 371 | #define SMB_VFS_CHMOD_ACL(conn, name, mode) \
|
|---|
| 372 | smb_vfs_call_chmod_acl((conn)->vfs_handles, (name), (mode))
|
|---|
| 373 | #define SMB_VFS_NEXT_CHMOD_ACL(handle, name, mode) \
|
|---|
| 374 | smb_vfs_call_chmod_acl((handle)->next, (name), (mode))
|
|---|
| 375 |
|
|---|
| 376 | #define SMB_VFS_FCHMOD_ACL(fsp, mode) \
|
|---|
| 377 | smb_vfs_call_fchmod_acl((fsp)->conn->vfs_handles, (fsp), (mode))
|
|---|
| 378 | #define SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, mode) \
|
|---|
| 379 | smb_vfs_call_fchmod_acl((handle)->next, (fsp), (mode))
|
|---|
| 380 |
|
|---|
| 381 | #define SMB_VFS_SYS_ACL_GET_ENTRY(conn, theacl, entry_id, entry_p) \
|
|---|
| 382 | smb_vfs_call_sys_acl_get_entry((conn)->vfs_handles, (theacl), (entry_id), (entry_p))
|
|---|
| 383 | #define SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle, theacl, entry_id, entry_p) \
|
|---|
| 384 | smb_vfs_call_sys_acl_get_entry((handle)->next, (theacl), (entry_id), (entry_p))
|
|---|
| 385 |
|
|---|
| 386 | #define SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry_d, tag_type_p) \
|
|---|
| 387 | smb_vfs_call_sys_acl_get_tag_type((conn)->vfs_handles, (entry_d), (tag_type_p))
|
|---|
| 388 | #define SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle, entry_d, tag_type_p) \
|
|---|
| 389 | smb_vfs_call_sys_acl_get_tag_type((handle)->next, (entry_d), (tag_type_p))
|
|---|
| 390 |
|
|---|
| 391 | #define SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry_d, permset_p) \
|
|---|
| 392 | smb_vfs_call_sys_acl_get_permset((conn)->vfs_handles, (entry_d), (permset_p))
|
|---|
| 393 | #define SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle, entry_d, permset_p) \
|
|---|
| 394 | smb_vfs_call_sys_acl_get_permset((handle)->next, (entry_d), (permset_p))
|
|---|
| 395 |
|
|---|
| 396 | #define SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry_d) \
|
|---|
| 397 | smb_vfs_call_sys_acl_get_qualifier((conn)->vfs_handles, (entry_d))
|
|---|
| 398 | #define SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle, entry_d) \
|
|---|
| 399 | smb_vfs_call_sys_acl_get_qualifier((handle)->next, (entry_d))
|
|---|
| 400 |
|
|---|
| 401 | #define SMB_VFS_SYS_ACL_GET_FILE(conn, path_p, type) \
|
|---|
| 402 | smb_vfs_call_sys_acl_get_file((conn)->vfs_handles, (path_p), (type))
|
|---|
| 403 | #define SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p, type) \
|
|---|
| 404 | smb_vfs_call_sys_acl_get_file((handle)->next, (path_p), (type))
|
|---|
| 405 |
|
|---|
| 406 | #define SMB_VFS_SYS_ACL_GET_FD(fsp) \
|
|---|
| 407 | smb_vfs_call_sys_acl_get_fd((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 408 | #define SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp) \
|
|---|
| 409 | smb_vfs_call_sys_acl_get_fd((handle)->next, (fsp))
|
|---|
| 410 |
|
|---|
| 411 | #define SMB_VFS_SYS_ACL_CLEAR_PERMS(conn, permset) \
|
|---|
| 412 | smb_vfs_call_sys_acl_clear_perms((conn)->vfs_handles, (permset))
|
|---|
| 413 | #define SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle, permset) \
|
|---|
| 414 | smb_vfs_call_sys_acl_clear_perms((handle)->next, (permset))
|
|---|
| 415 |
|
|---|
| 416 | #define SMB_VFS_SYS_ACL_ADD_PERM(conn, permset, perm) \
|
|---|
| 417 | smb_vfs_call_sys_acl_add_perm((conn)->vfs_handles, (permset), (perm))
|
|---|
| 418 | #define SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle, permset, perm) \
|
|---|
| 419 | smb_vfs_call_sys_acl_add_perm((handle)->next, (permset), (perm))
|
|---|
| 420 |
|
|---|
| 421 | #define SMB_VFS_SYS_ACL_TO_TEXT(conn, theacl, plen) \
|
|---|
| 422 | smb_vfs_call_sys_acl_to_text((conn)->vfs_handles, (theacl), (plen))
|
|---|
| 423 | #define SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle, theacl, plen) \
|
|---|
| 424 | smb_vfs_call_sys_acl_to_text((handle)->next, (theacl), (plen))
|
|---|
| 425 |
|
|---|
| 426 | #define SMB_VFS_SYS_ACL_INIT(conn, count) \
|
|---|
| 427 | smb_vfs_call_sys_acl_init((conn)->vfs_handles, (count))
|
|---|
| 428 | #define SMB_VFS_NEXT_SYS_ACL_INIT(handle, count) \
|
|---|
| 429 | smb_vfs_call_sys_acl_init((handle)->next, (count))
|
|---|
| 430 |
|
|---|
| 431 | #define SMB_VFS_SYS_ACL_CREATE_ENTRY(conn, pacl, pentry) \
|
|---|
| 432 | smb_vfs_call_sys_acl_create_entry((conn)->vfs_handles, (pacl), (pentry))
|
|---|
| 433 | #define SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle, pacl, pentry) \
|
|---|
| 434 | smb_vfs_call_sys_acl_create_entry((handle)->next, (pacl), (pentry))
|
|---|
| 435 |
|
|---|
| 436 | #define SMB_VFS_SYS_ACL_SET_TAG_TYPE(conn, entry, tagtype) \
|
|---|
| 437 | smb_vfs_call_sys_acl_set_tag_type((conn)->vfs_handles, (entry), (tagtype))
|
|---|
| 438 | #define SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle, entry, tagtype) \
|
|---|
| 439 | smb_vfs_call_sys_acl_set_tag_type((handle)->next, (entry), (tagtype))
|
|---|
| 440 |
|
|---|
| 441 | #define SMB_VFS_SYS_ACL_SET_QUALIFIER(conn, entry, qual) \
|
|---|
| 442 | smb_vfs_call_sys_acl_set_qualifier((conn)->vfs_handles, (entry), (qual))
|
|---|
| 443 | #define SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle, entry, qual) \
|
|---|
| 444 | smb_vfs_call_sys_acl_set_qualifier((handle)->next, (entry), (qual))
|
|---|
| 445 |
|
|---|
| 446 | #define SMB_VFS_SYS_ACL_SET_PERMSET(conn, entry, permset) \
|
|---|
| 447 | smb_vfs_call_sys_acl_set_permset((conn)->vfs_handles, (entry), (permset))
|
|---|
| 448 | #define SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle, entry, permset) \
|
|---|
| 449 | smb_vfs_call_sys_acl_set_permset((handle)->next, (entry), (permset))
|
|---|
| 450 |
|
|---|
| 451 | #define SMB_VFS_SYS_ACL_VALID(conn, theacl) \
|
|---|
| 452 | smb_vfs_call_sys_acl_valid((conn)->vfs_handles, (theacl))
|
|---|
| 453 | #define SMB_VFS_NEXT_SYS_ACL_VALID(handle, theacl) \
|
|---|
| 454 | smb_vfs_call_sys_acl_valid((handle)->next, (theacl))
|
|---|
| 455 |
|
|---|
| 456 | #define SMB_VFS_SYS_ACL_SET_FILE(conn, name, acltype, theacl) \
|
|---|
| 457 | smb_vfs_call_sys_acl_set_file((conn)->vfs_handles, (name), (acltype), (theacl))
|
|---|
| 458 | #define SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name, acltype, theacl) \
|
|---|
| 459 | smb_vfs_call_sys_acl_set_file((handle)->next, (name), (acltype), (theacl))
|
|---|
| 460 |
|
|---|
| 461 | #define SMB_VFS_SYS_ACL_SET_FD(fsp, theacl) \
|
|---|
| 462 | smb_vfs_call_sys_acl_set_fd((fsp)->conn->vfs_handles, (fsp), (theacl))
|
|---|
| 463 | #define SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl) \
|
|---|
| 464 | smb_vfs_call_sys_acl_set_fd((handle)->next, (fsp), (theacl))
|
|---|
| 465 |
|
|---|
| 466 | #define SMB_VFS_SYS_ACL_DELETE_DEF_FILE(conn, path) \
|
|---|
| 467 | smb_vfs_call_sys_acl_delete_def_file((conn)->vfs_handles, (path))
|
|---|
| 468 | #define SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path) \
|
|---|
| 469 | smb_vfs_call_sys_acl_delete_def_file((handle)->next, (path))
|
|---|
| 470 |
|
|---|
| 471 | #define SMB_VFS_SYS_ACL_GET_PERM(conn, permset, perm) \
|
|---|
| 472 | smb_vfs_call_sys_acl_get_perm((conn)->vfs_handles, (permset), (perm))
|
|---|
| 473 | #define SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle, permset, perm) \
|
|---|
| 474 | smb_vfs_call_sys_acl_get_perm((handle)->next, (permset), (perm))
|
|---|
| 475 |
|
|---|
| 476 | #define SMB_VFS_SYS_ACL_FREE_TEXT(conn, text) \
|
|---|
| 477 | smb_vfs_call_sys_acl_free_text((conn)->vfs_handles, (text))
|
|---|
| 478 | #define SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle, text) \
|
|---|
| 479 | smb_vfs_call_sys_acl_free_text((handle)->next, (text))
|
|---|
| 480 |
|
|---|
| 481 | #define SMB_VFS_SYS_ACL_FREE_ACL(conn, posix_acl) \
|
|---|
| 482 | smb_vfs_call_sys_acl_free_acl((conn)->vfs_handles, (posix_acl))
|
|---|
| 483 | #define SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle, posix_acl) \
|
|---|
| 484 | smb_vfs_call_sys_acl_free_acl((handle)->next, (posix_acl))
|
|---|
| 485 |
|
|---|
| 486 | #define SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, qualifier, tagtype) \
|
|---|
| 487 | smb_vfs_call_sys_acl_free_qualifier((conn)->vfs_handles, (qualifier), (tagtype))
|
|---|
| 488 | #define SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle, qualifier, tagtype) \
|
|---|
| 489 | smb_vfs_call_sys_acl_free_qualifier((handle)->next, (qualifier), (tagtype))
|
|---|
| 490 |
|
|---|
| 491 | #define SMB_VFS_GETXATTR(conn,path,name,value,size) \
|
|---|
| 492 | smb_vfs_call_getxattr((conn)->vfs_handles,(path),(name),(value),(size))
|
|---|
| 493 | #define SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size) \
|
|---|
| 494 | smb_vfs_call_getxattr((handle)->next,(path),(name),(value),(size))
|
|---|
| 495 |
|
|---|
| 496 | #define SMB_VFS_LGETXATTR(conn,path,name,value,size) \
|
|---|
| 497 | smb_vfs_call_lgetxattr((conn)->vfs_handles,(path),(name),(value),(size))
|
|---|
| 498 | #define SMB_VFS_NEXT_LGETXATTR(handle,path,name,value,size) \
|
|---|
| 499 | smb_vfs_call_lgetxattr((handle)->next,(path),(name),(value),(size))
|
|---|
| 500 |
|
|---|
| 501 | #define SMB_VFS_FGETXATTR(fsp,name,value,size) \
|
|---|
| 502 | smb_vfs_call_fgetxattr((fsp)->conn->vfs_handles, (fsp), (name),(value),(size))
|
|---|
| 503 | #define SMB_VFS_NEXT_FGETXATTR(handle,fsp,name,value,size) \
|
|---|
| 504 | smb_vfs_call_fgetxattr((handle)->next,(fsp),(name),(value),(size))
|
|---|
| 505 |
|
|---|
| 506 | #define SMB_VFS_LISTXATTR(conn,path,list,size) \
|
|---|
| 507 | smb_vfs_call_listxattr((conn)->vfs_handles,(path),(list),(size))
|
|---|
| 508 | #define SMB_VFS_NEXT_LISTXATTR(handle,path,list,size) \
|
|---|
| 509 | smb_vfs_call_listxattr((handle)->next,(path),(list),(size))
|
|---|
| 510 |
|
|---|
| 511 | #define SMB_VFS_LLISTXATTR(conn,path,list,size) \
|
|---|
| 512 | smb_vfs_call_llistxattr((conn)->vfs_handles,(path),(list),(size))
|
|---|
| 513 | #define SMB_VFS_NEXT_LLISTXATTR(handle,path,list,size) \
|
|---|
| 514 | smb_vfs_call_llistxattr((handle)->next,(path),(list),(size))
|
|---|
| 515 |
|
|---|
| 516 | #define SMB_VFS_FLISTXATTR(fsp,list,size) \
|
|---|
| 517 | smb_vfs_call_flistxattr((fsp)->conn->vfs_handles, (fsp), (list),(size))
|
|---|
| 518 | #define SMB_VFS_NEXT_FLISTXATTR(handle,fsp,list,size) \
|
|---|
| 519 | smb_vfs_call_flistxattr((handle)->next,(fsp),(list),(size))
|
|---|
| 520 |
|
|---|
| 521 | #define SMB_VFS_REMOVEXATTR(conn,path,name) \
|
|---|
| 522 | smb_vfs_call_removexattr((conn)->vfs_handles,(path),(name))
|
|---|
| 523 | #define SMB_VFS_NEXT_REMOVEXATTR(handle,path,name) \
|
|---|
| 524 | smb_vfs_call_removexattr((handle)->next,(path),(name))
|
|---|
| 525 |
|
|---|
| 526 | #define SMB_VFS_LREMOVEXATTR(conn,path,name) \
|
|---|
| 527 | smb_vfs_call_lremovexattr((conn)->vfs_handles,(path),(name))
|
|---|
| 528 | #define SMB_VFS_NEXT_LREMOVEXATTR(handle,path,name) \
|
|---|
| 529 | smb_vfs_call_lremovexattr((handle)->next,(path),(name))
|
|---|
| 530 |
|
|---|
| 531 | #define SMB_VFS_FREMOVEXATTR(fsp,name) \
|
|---|
| 532 | smb_vfs_call_fremovexattr((fsp)->conn->vfs_handles, (fsp), (name))
|
|---|
| 533 | #define SMB_VFS_NEXT_FREMOVEXATTR(handle,fsp,name) \
|
|---|
| 534 | smb_vfs_call_fremovexattr((handle)->next,(fsp),(name))
|
|---|
| 535 |
|
|---|
| 536 | #define SMB_VFS_SETXATTR(conn,path,name,value,size,flags) \
|
|---|
| 537 | smb_vfs_call_setxattr((conn)->vfs_handles,(path),(name),(value),(size),(flags))
|
|---|
| 538 | #define SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags) \
|
|---|
| 539 | smb_vfs_call_setxattr((handle)->next,(path),(name),(value),(size),(flags))
|
|---|
| 540 |
|
|---|
| 541 | #define SMB_VFS_LSETXATTR(conn,path,name,value,size,flags) \
|
|---|
| 542 | smb_vfs_call_lsetxattr((conn)->vfs_handles,(path),(name),(value),(size),(flags))
|
|---|
| 543 | #define SMB_VFS_NEXT_LSETXATTR(handle,path,name,value,size,flags) \
|
|---|
| 544 | smb_vfs_call_lsetxattr((handle)->next,(path),(name),(value),(size),(flags))
|
|---|
| 545 |
|
|---|
| 546 | #define SMB_VFS_FSETXATTR(fsp,name,value,size,flags) \
|
|---|
| 547 | smb_vfs_call_fsetxattr((fsp)->conn->vfs_handles, (fsp), (name),(value),(size),(flags))
|
|---|
| 548 | #define SMB_VFS_NEXT_FSETXATTR(handle,fsp,name,value,size,flags) \
|
|---|
| 549 | smb_vfs_call_fsetxattr((handle)->next,(fsp),(name),(value),(size),(flags))
|
|---|
| 550 |
|
|---|
| 551 | #define SMB_VFS_AIO_READ(fsp,aiocb) \
|
|---|
| 552 | smb_vfs_call_aio_read((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 553 | #define SMB_VFS_NEXT_AIO_READ(handle,fsp,aiocb) \
|
|---|
| 554 | smb_vfs_call_aio_read((handle)->next,(fsp),(aiocb))
|
|---|
| 555 |
|
|---|
| 556 | #define SMB_VFS_AIO_WRITE(fsp,aiocb) \
|
|---|
| 557 | smb_vfs_call_aio_write((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 558 | #define SMB_VFS_NEXT_AIO_WRITE(handle,fsp,aiocb) \
|
|---|
| 559 | smb_vfs_call_aio_write((handle)->next,(fsp),(aiocb))
|
|---|
| 560 |
|
|---|
| 561 | #define SMB_VFS_AIO_RETURN(fsp,aiocb) \
|
|---|
| 562 | smb_vfs_call_aio_return_fn((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 563 | #define SMB_VFS_NEXT_AIO_RETURN(handle,fsp,aiocb) \
|
|---|
| 564 | smb_vfs_call_aio_return_fn((handle)->next,(fsp),(aiocb))
|
|---|
| 565 |
|
|---|
| 566 | #define SMB_VFS_AIO_CANCEL(fsp,aiocb) \
|
|---|
| 567 | smb_vfs_call_aio_cancel((fsp)->conn->vfs_handles, (fsp), (aiocb))
|
|---|
| 568 | #define SMB_VFS_NEXT_AIO_CANCEL(handle,fsp,aiocb) \
|
|---|
| 569 | smb_vfs_call_aio_cancel((handle)->next,(fsp),(aiocb))
|
|---|
| 570 |
|
|---|
| 571 | #define SMB_VFS_AIO_ERROR(fsp,aiocb) \
|
|---|
| 572 | smb_vfs_call_aio_error_fn((fsp)->conn->vfs_handles, (fsp),(aiocb))
|
|---|
| 573 | #define SMB_VFS_NEXT_AIO_ERROR(handle,fsp,aiocb) \
|
|---|
| 574 | smb_vfs_call_aio_error_fn((handle)->next,(fsp),(aiocb))
|
|---|
| 575 |
|
|---|
| 576 | #define SMB_VFS_AIO_FSYNC(fsp,op,aiocb) \
|
|---|
| 577 | smb_vfs_call_aio_fsync((fsp)->conn->vfs_handles, (fsp), (op),(aiocb))
|
|---|
| 578 | #define SMB_VFS_NEXT_AIO_FSYNC(handle,fsp,op,aiocb) \
|
|---|
| 579 | smb_vfs_call_aio_fsync((handle)->next,(fsp),(op),(aiocb))
|
|---|
| 580 |
|
|---|
| 581 | #define SMB_VFS_AIO_SUSPEND(fsp,aiocb,n,ts) \
|
|---|
| 582 | smb_vfs_call_aio_suspend((fsp)->conn->vfs_handles, (fsp),(aiocb),(n),(ts))
|
|---|
| 583 | #define SMB_VFS_NEXT_AIO_SUSPEND(handle,fsp,aiocb,n,ts) \
|
|---|
| 584 | smb_vfs_call_aio_suspend((handle)->next,(fsp),(aiocb),(n),(ts))
|
|---|
| 585 |
|
|---|
| 586 | #define SMB_VFS_AIO_FORCE(fsp) \
|
|---|
| 587 | smb_vfs_call_aio_force((fsp)->conn->vfs_handles, (fsp))
|
|---|
| 588 | #define SMB_VFS_NEXT_AIO_FORCE(handle,fsp) \
|
|---|
| 589 | smb_vfs_call_aio_force((handle)->next,(fsp))
|
|---|
| 590 |
|
|---|
| 591 | #define SMB_VFS_IS_OFFLINE(conn,path,sbuf) \
|
|---|
| 592 | smb_vfs_call_is_offline((conn)->vfs_handles,(path),(sbuf))
|
|---|
| 593 | #define SMB_VFS_NEXT_IS_OFFLINE(handle,path,sbuf) \
|
|---|
| 594 | smb_vfs_call_is_offline((handle)->next,(path),(sbuf))
|
|---|
| 595 |
|
|---|
| 596 | #define SMB_VFS_SET_OFFLINE(conn,path) \
|
|---|
| 597 | smb_vfs_call_set_offline((conn)->vfs_handles,(path))
|
|---|
| 598 | #define SMB_VFS_NEXT_SET_OFFLINE(handle,path) \
|
|---|
| 599 | smb_vfs_call_set_offline((handle)->next, (path))
|
|---|
| 600 |
|
|---|
| 601 | #endif /* _VFS_MACROS_H */
|
|---|
