* Failure: set errno, return NULL
*/
static DIR *um_opendir(vfs_handle_struct *handle,
- const char *fname,
+ const struct smb_filename *smb_fname,
const char *mask,
uint32_t attr)
{
struct um_dirinfo_struct *dirInfo;
- DEBUG(10, ("Entering with fname '%s'\n", fname));
+ DEBUG(10, ("Entering with fname '%s'\n", smb_fname->base_name));
- if (alloc_set_client_dirinfo(handle, fname, &dirInfo)) {
+ if (alloc_set_client_dirinfo(handle, smb_fname->base_name, &dirInfo)) {
goto err;
}
if (!dirInfo->isInMediaFiles) {
dirInfo->dirstream = SMB_VFS_NEXT_OPENDIR(
- handle, fname, mask, attr);
+ handle, smb_fname, mask, attr);
} else {
+ struct smb_filename *client_smb_fname =
+ synthetic_smb_fname(talloc_tos(),
+ dirInfo->clientPath,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (client_smb_fname == NULL) {
+ goto err;
+ }
+
dirInfo->dirstream = SMB_VFS_NEXT_OPENDIR(
- handle, dirInfo->clientPath, mask, attr);
+ handle, client_smb_fname, mask, attr);
+
+ TALLOC_FREE(client_smb_fname);
}
if (dirInfo->dirstream == NULL) {
return (DIR*)dirInfo;
err:
- DEBUG(1, ("Failing with fname '%s'\n", fname));
+ DEBUG(1, ("Failing with fname '%s'\n", smb_fname->base_name));
TALLOC_FREE(dirInfo);
return NULL;
}
}
static int um_mkdir(vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
mode_t mode)
{
int status;
- char *clientPath;
- TALLOC_CTX *ctx;
-
+ const char *path = smb_fname->base_name;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering with path '%s'\n", path));
if (!is_in_media_files(path) || !is_in_media_dir(path)) {
- return SMB_VFS_NEXT_MKDIR(handle, path, mode);
+ return SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
}
- clientPath = NULL;
- ctx = talloc_tos();
-
- if ((status = alloc_get_client_path(handle, ctx,
- path,
- &clientPath))) {
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
+ if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_MKDIR(handle, clientPath, mode);
+ status = SMB_VFS_NEXT_MKDIR(handle, client_fname, mode);
err:
- TALLOC_FREE(clientPath);
+ TALLOC_FREE(client_fname);
DEBUG(10, ("Leaving with path '%s'\n", path));
return status;
}
static int um_rmdir(vfs_handle_struct *handle,
- const char *path)
+ const struct smb_filename *smb_fname)
{
int status;
- char *clientPath;
- TALLOC_CTX *ctx;
-
+ const char *path = smb_fname->base_name;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering with path '%s'\n", path));
if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_RMDIR(handle, path);
+ return SMB_VFS_NEXT_RMDIR(handle, smb_fname);
}
- clientPath = NULL;
- ctx = talloc_tos();
-
- if ((status = alloc_get_client_path(handle, ctx,
- path,
- &clientPath))) {
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
+ if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_RMDIR(handle, clientPath);
+ status = SMB_VFS_NEXT_RMDIR(handle, client_fname);
err:
- TALLOC_FREE(clientPath);
+ TALLOC_FREE(client_fname);
DEBUG(10, ("Leaving with path '%s'\n", path));
return status;
}
}
static int um_chmod(vfs_handle_struct *handle,
- const char *path,
- mode_t mode)
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_chmod\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_CHMOD(handle, path, mode);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_CHMOD(handle, client_path, mode);
+ status = SMB_VFS_NEXT_CHMOD(handle, client_fname, mode);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
static int um_chown(vfs_handle_struct *handle,
- const char *path,
- uid_t uid,
- gid_t gid)
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_chown\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_CHOWN(handle, path, uid, gid);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_CHOWN(handle, client_path, uid, gid);
+ status = SMB_VFS_NEXT_CHOWN(handle, client_fname, uid, gid);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
static int um_lchown(vfs_handle_struct *handle,
- const char *path,
- uid_t uid,
- gid_t gid)
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_lchown\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_LCHOWN(handle, client_path, uid, gid);
+ status = SMB_VFS_NEXT_LCHOWN(handle, client_fname, uid, gid);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
}
static int um_mknod(vfs_handle_struct *handle,
- const char *pathname,
+ const struct smb_filename *smb_fname,
mode_t mode,
SMB_DEV_T dev)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_mknod\n"));
- if (!is_in_media_files(pathname)) {
- return SMB_VFS_NEXT_MKNOD(handle, pathname, mode, dev);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- pathname, &client_path);
+ status = alloc_get_client_smb_fname(handle, talloc_tos(),
+ smb_fname, &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_MKNOD(handle, client_path, mode, dev);
+ status = SMB_VFS_NEXT_MKNOD(handle, client_fname, mode, dev);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
}
static int um_chflags(vfs_handle_struct *handle,
- const char *path,
- unsigned int flags)
+ const struct smb_filename *smb_fname,
+ unsigned int flags)
{
int status;
- char *client_path = NULL;
-
- DEBUG(10, ("Entering um_chflags\n"));
+ struct smb_filename *client_fname = NULL;
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_CHFLAGS(handle, path, flags);
+ DEBUG(10, ("Entering um_mknod\n"));
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle, talloc_tos(),
+ smb_fname, &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_CHFLAGS(handle, client_path, flags);
+ status = SMB_VFS_NEXT_CHFLAGS(handle, client_fname, flags);
+
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
static NTSTATUS um_streaminfo(struct vfs_handle_struct *handle,
struct files_struct *fsp,
- const char *fname,
+ const struct smb_filename *smb_fname,
TALLOC_CTX *ctx,
unsigned int *num_streams,
struct stream_struct **streams)
{
NTSTATUS status;
- char *client_path = NULL;
int ret;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_streaminfo\n"));
- if (!is_in_media_files(fname)) {
- return SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname,
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname,
ctx, num_streams, streams);
}
- ret = alloc_get_client_path(handle, talloc_tos(),
- fname, &client_path);
+ ret = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (ret != 0) {
- status = map_nt_error_from_unix(errno);
+ status = NT_STATUS_NO_MEMORY;
goto err;
}
* function do, exactly? Does it need extra modifications for
* the Avid stuff?
*/
- status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, client_path,
+ status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, client_fname,
ctx, num_streams, streams);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
*/
static NTSTATUS um_get_nt_acl(vfs_handle_struct *handle,
- const char *name,
+ const struct smb_filename *smb_fname,
uint32_t security_info,
TALLOC_CTX *mem_ctx,
struct security_descriptor **ppdesc)
{
NTSTATUS status;
char *client_path = NULL;
+ struct smb_filename *client_smb_fname = NULL;
int ret;
DEBUG(10, ("Entering um_get_nt_acl\n"));
- if (!is_in_media_files(name)) {
- return SMB_VFS_NEXT_GET_NT_ACL(handle, name,
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname,
security_info,
mem_ctx, ppdesc);
}
ret = alloc_get_client_path(handle, talloc_tos(),
- name, &client_path);
+ smb_fname->base_name, &client_path);
if (ret != 0) {
status = map_nt_error_from_unix(errno);
goto err;
}
- status = SMB_VFS_NEXT_GET_NT_ACL(handle, client_path,
+ client_smb_fname = synthetic_smb_fname(talloc_tos(),
+ client_path,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (client_smb_fname == NULL) {
+ TALLOC_FREE(client_path);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = SMB_VFS_NEXT_GET_NT_ACL(handle, client_smb_fname,
security_info,
mem_ctx, ppdesc);
err:
+ TALLOC_FREE(client_smb_fname);
TALLOC_FREE(client_path);
return status;
}
static int um_chmod_acl(vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
mode_t mode)
{
int status;
- char *client_path = NULL;
+ int saved_errno;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_chmod_acl\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_CHMOD_ACL(handle, path, mode);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_CHMOD_ACL(handle, smb_fname, mode);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
-
- status = SMB_VFS_NEXT_CHMOD_ACL(handle, client_path, mode);
+ status = SMB_VFS_NEXT_CHMOD_ACL(handle, client_fname, mode);
err:
- TALLOC_FREE(client_path);
+ saved_errno = errno;
+ TALLOC_FREE(client_fname);
+ errno = saved_errno;
return status;
}
static SMB_ACL_T um_sys_acl_get_file(vfs_handle_struct *handle,
- const char *path_p,
- SMB_ACL_TYPE_T type,
- TALLOC_CTX *mem_ctx)
+ const struct smb_filename *smb_fname,
+ SMB_ACL_TYPE_T type,
+ TALLOC_CTX *mem_ctx)
{
SMB_ACL_T ret;
- char *client_path = NULL;
+ int saved_errno = 0;
+ struct smb_filename *client_fname = NULL;
int status;
DEBUG(10, ("Entering um_sys_acl_get_file\n"));
- if (!is_in_media_files(path_p)) {
- return SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p,
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, smb_fname,
type, mem_ctx);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path_p, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
- ret = NULL;
+ ret = (SMB_ACL_T)NULL;
goto err;
}
- ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, client_path, type, mem_ctx);
+ ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, client_fname,
+ type, mem_ctx);
err:
- TALLOC_FREE(client_path);
+ if (ret == (SMB_ACL_T)NULL) {
+ saved_errno = errno;
+ }
+ TALLOC_FREE(client_fname);
+ if (saved_errno != 0) {
+ errno = saved_errno;
+ }
return ret;
}
static int um_sys_acl_set_file(vfs_handle_struct *handle,
- const char *name,
+ const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T acltype,
SMB_ACL_T theacl)
{
int status;
- char *client_path = NULL;
+ int saved_errno = 0;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_sys_acl_set_file\n"));
- if (!is_in_media_files(name)) {
- return SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name,
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, smb_fname,
acltype, theacl);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- name, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, client_path,
+ status = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, client_fname,
acltype, theacl);
err:
- TALLOC_FREE(client_path);
+ if (status == -1) {
+ saved_errno = errno;
+ }
+ TALLOC_FREE(client_fname);
+ if (saved_errno != 0) {
+ errno = saved_errno;
+ }
return status;
}
static int um_sys_acl_delete_def_file(vfs_handle_struct *handle,
- const char *path)
+ const struct smb_filename *smb_fname)
{
int status;
- char *client_path = NULL;
+ int saved_errno = 0;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_sys_acl_delete_def_file\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle,
+ smb_fname);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, client_path);
+ status = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, client_fname);
err:
- TALLOC_FREE(client_path);
+ if (status == -1) {
+ saved_errno = errno;
+ }
+ TALLOC_FREE(client_fname);
+ if (saved_errno != 0) {
+ errno = saved_errno;
+ }
return status;
}
static ssize_t um_getxattr(struct vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
const char *name,
void *value,
size_t size)
{
ssize_t ret;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
int status;
DEBUG(10, ("Entering um_getxattr\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_GETXATTR(handle, path, name, value, size);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_GETXATTR(handle, smb_fname,
+ name, value, size);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
ret = -1;
goto err;
}
- ret = SMB_VFS_NEXT_GETXATTR(handle, client_path, name, value, size);
+ ret = SMB_VFS_NEXT_GETXATTR(handle, client_fname, name, value, size);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return ret;
}
static ssize_t um_listxattr(struct vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
char *list,
size_t size)
{
ssize_t ret;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
int status;
DEBUG(10, ("Entering um_listxattr\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_LISTXATTR(handle, path, list, size);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
ret = -1;
goto err;
}
- ret = SMB_VFS_NEXT_LISTXATTR(handle, client_path, list, size);
+ ret = SMB_VFS_NEXT_LISTXATTR(handle, client_fname, list, size);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return ret;
}
static int um_removexattr(struct vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
const char *name)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_removexattr\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_REMOVEXATTR(handle, path, name);
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_REMOVEXATTR(handle, client_path, name);
+ status = SMB_VFS_NEXT_REMOVEXATTR(handle, client_fname, name);
err:
- TALLOC_FREE(client_path);
+ TALLOC_FREE(client_fname);
return status;
}
static int um_setxattr(struct vfs_handle_struct *handle,
- const char *path,
+ const struct smb_filename *smb_fname,
const char *name,
const void *value,
size_t size,
int flags)
{
int status;
- char *client_path = NULL;
+ struct smb_filename *client_fname = NULL;
DEBUG(10, ("Entering um_setxattr\n"));
- if (!is_in_media_files(path)) {
- return SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
+ if (!is_in_media_files(smb_fname->base_name)) {
+ return SMB_VFS_NEXT_SETXATTR(handle, smb_fname, name, value,
size, flags);
}
- status = alloc_get_client_path(handle, talloc_tos(),
- path, &client_path);
+ status = alloc_get_client_smb_fname(handle,
+ talloc_tos(),
+ smb_fname,
+ &client_fname);
if (status != 0) {
goto err;
}
- status = SMB_VFS_NEXT_SETXATTR(handle, client_path, name, value,
+ status = SMB_VFS_NEXT_SETXATTR(handle, client_fname, name, value,
size, flags);
-err:
- TALLOC_FREE(client_path);
- return status;
-}
-
-static bool um_is_offline(struct vfs_handle_struct *handle,
- const struct smb_filename *fname,
- SMB_STRUCT_STAT *sbuf)
-{
- bool ret;
- struct smb_filename *client_fname = NULL;
- int status;
-
- DEBUG(10, ("Entering um_is_offline\n"));
-
- if (!is_in_media_files(fname->base_name)) {
- return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
- }
-
- status = alloc_get_client_smb_fname(handle, talloc_tos(),
- fname, &client_fname);
- if (status != 0) {
- ret = false;
- goto err;
- }
-
- ret = SMB_VFS_NEXT_IS_OFFLINE(handle, client_fname, sbuf);
-
-err:
- TALLOC_FREE(client_fname);
- return ret;
-}
-
-static int um_set_offline(struct vfs_handle_struct *handle,
- const struct smb_filename *fname)
-{
- int status;
- struct smb_filename *client_fname = NULL;
-
- DEBUG(10, ("Entering um_set_offline\n"));
-
- if (!is_in_media_files(fname->base_name)) {
- return SMB_VFS_NEXT_SET_OFFLINE(handle, fname);
- }
-
- status = alloc_get_client_smb_fname(handle, talloc_tos(),
- fname, &client_fname);
- if (status != 0) {
- goto err;
- }
-
- status = SMB_VFS_NEXT_SET_OFFLINE(handle, client_fname);
-
err:
TALLOC_FREE(client_fname);
return status;
.listxattr_fn = um_listxattr,
.removexattr_fn = um_removexattr,
.setxattr_fn = um_setxattr,
-
- /* aio operations */
-
- /* offline operations */
- .is_offline_fn = um_is_offline,
- .set_offline_fn = um_set_offline
};
-NTSTATUS vfs_unityed_media_init(void);
-NTSTATUS vfs_unityed_media_init(void)
+NTSTATUS vfs_unityed_media_init(TALLOC_CTX *);
+NTSTATUS vfs_unityed_media_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"unityed_media", &vfs_um_fns);