4 * Implement a fixed mapping of forbidden NT characters in filenames that are
5 * used a lot by the CAD package Catia.
7 * Yes, this a BAD BAD UGLY INCOMPLETE hack, but it helps quite some people
8 * out there. Catia V4 on AIX uses characters like "<*$ a *lot*, all forbidden
11 * Copyright (C) Volker Lendecke, 2005
12 * Copyright (C) Aravind Srinivasan, 2009
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 3 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <http://www.gnu.org/licenses/>.
30 #include "smbd/smbd.h"
32 static int vfs_catia_debug_level
= DBGC_VFS
;
35 #define DBGC_CLASS vfs_catia_debug_level
37 #define GLOBAL_SNUM 0xFFFFFFF
39 #define MAP_NUM 0x101 /* max unicode charval / MAP_SIZE */
40 #define T_OFFSET(_v_) ((_v_ % MAP_SIZE))
41 #define T_START(_v_) (((_v_ / MAP_SIZE) * MAP_SIZE))
42 #define T_PICK(_v_) ((_v_ / MAP_SIZE))
44 struct char_mappings
{
45 smb_ucs2_t entry
[MAP_SIZE
][2];
48 struct share_mapping_entry
{
50 struct share_mapping_entry
*next
;
51 struct char_mappings
**mappings
;
54 struct share_mapping_entry
*srt_head
= NULL
;
56 static bool build_table(struct char_mappings
**cmaps
, int value
)
59 int start
= T_START(value
);
61 (*cmaps
) = talloc_zero(NULL
, struct char_mappings
);
66 for (i
= 0; i
< MAP_SIZE
;i
++) {
67 (*cmaps
)->entry
[i
][vfs_translate_to_unix
] = start
+ i
;
68 (*cmaps
)->entry
[i
][vfs_translate_to_windows
] = start
+ i
;
74 static void set_tables(struct char_mappings
**cmaps
,
80 /* set unix -> windows */
81 i
= T_OFFSET(unix_map
);
82 cmaps
[T_PICK(unix_map
)]->entry
[i
][vfs_translate_to_windows
] = windows_map
;
84 /* set windows -> unix */
85 i
= T_OFFSET(windows_map
);
86 cmaps
[T_PICK(windows_map
)]->entry
[i
][vfs_translate_to_unix
] = unix_map
;
89 static bool build_ranges(struct char_mappings
**cmaps
,
94 if (!cmaps
[T_PICK(unix_map
)]) {
95 if (!build_table(&cmaps
[T_PICK(unix_map
)], unix_map
))
99 if (!cmaps
[T_PICK(windows_map
)]) {
100 if (!build_table(&cmaps
[T_PICK(windows_map
)], windows_map
))
104 set_tables(cmaps
, unix_map
, windows_map
);
109 static struct share_mapping_entry
*get_srt(connection_struct
*conn
,
110 struct share_mapping_entry
**global
)
112 struct share_mapping_entry
*share
;
114 for (share
= srt_head
; share
!= NULL
; share
= share
->next
) {
115 if (share
->snum
== GLOBAL_SNUM
)
118 if (share
->snum
== SNUM(conn
))
125 static struct share_mapping_entry
*add_srt(int snum
, const char **mappings
)
131 long unix_map
, windows_map
;
132 struct share_mapping_entry
*ret
= NULL
;
134 ret
= (struct share_mapping_entry
*)
135 TALLOC_ZERO(NULL
, sizeof(struct share_mapping_entry
) +
136 (mappings
? (MAP_NUM
* sizeof(struct char_mappings
*)) : 0));
144 ret
->mappings
= (struct char_mappings
**) ((unsigned char*) ret
+
145 sizeof(struct share_mapping_entry
));
146 memset(ret
->mappings
, 0,
147 MAP_NUM
* sizeof(struct char_mappings
*));
149 ret
->mappings
= NULL
;
154 * catia mappings are of the form :
155 * UNIX char (in 0xnn hex) : WINDOWS char (in 0xnn hex)
157 * multiple mappings are comma seperated in smb.conf
159 for (i
=0;mappings
[i
];i
++) {
160 fstrcpy(mapping
, mappings
[i
]);
161 unix_map
= strtol(mapping
, &tmp
, 16);
162 if (unix_map
== 0 && errno
== EINVAL
) {
163 DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping
));
166 windows_map
= strtol(++tmp
, NULL
, 16);
167 if (windows_map
== 0 && errno
== EINVAL
) {
168 DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping
));
172 if (!build_ranges(ret
->mappings
, unix_map
, windows_map
)) {
173 DEBUG(0, ("TABLE ERROR - CATIA MAPPINGS - %s\n", mapping
));
178 ret
->next
= srt_head
;
184 static bool init_mappings(connection_struct
*conn
,
185 struct share_mapping_entry
**selected_out
)
187 const char **mappings
= NULL
;
188 struct share_mapping_entry
*share_level
= NULL
;
189 struct share_mapping_entry
*global
= NULL
;
191 /* check srt cache */
192 share_level
= get_srt(conn
, &global
);
194 *selected_out
= share_level
;
195 return (share_level
->mappings
!= NULL
);
198 /* see if we have a global setting */
201 mappings
= lp_parm_string_list(-1, "catia", "mappings", NULL
);
202 global
= add_srt(GLOBAL_SNUM
, mappings
);
205 /* no global setting - what about share level ? */
206 mappings
= lp_parm_string_list(SNUM(conn
), "catia", "mappings", NULL
);
207 share_level
= add_srt(SNUM(conn
), mappings
);
209 if (share_level
->mappings
) {
210 (*selected_out
) = share_level
;
212 } else if (global
->mappings
) {
213 share_level
->mappings
= global
->mappings
;
214 (*selected_out
) = share_level
;
221 static NTSTATUS
catia_string_replace_allocate(connection_struct
*conn
,
226 static smb_ucs2_t
*tmpbuf
= NULL
;
228 struct share_mapping_entry
*selected
;
229 struct char_mappings
*map
= NULL
;
230 size_t converted_size
;
231 TALLOC_CTX
*ctx
= talloc_tos();
233 if (!init_mappings(conn
, &selected
)) {
234 /* No mappings found. Just use the old name */
235 *mapped_name
= talloc_strdup(NULL
, name_in
);
238 return NT_STATUS_NO_MEMORY
;
243 if ((push_ucs2_talloc(ctx
, &tmpbuf
, name_in
,
244 &converted_size
)) == false) {
245 return map_nt_error_from_unix(errno
);
251 map
= selected
->mappings
[T_PICK((*ptr
))];
257 *ptr
= map
->entry
[T_OFFSET((*ptr
))][direction
];
260 if ((pull_ucs2_talloc(ctx
, mapped_name
, tmpbuf
,
261 &converted_size
)) == false) {
263 return map_nt_error_from_unix(errno
);
269 static DIR *catia_opendir(vfs_handle_struct
*handle
,
274 char *name_mapped
= NULL
;
278 status
= catia_string_replace_allocate(handle
->conn
, fname
,
279 &name_mapped
, vfs_translate_to_unix
);
280 if (!NT_STATUS_IS_OK(status
)) {
281 errno
= map_errno_from_nt_status(status
);
285 ret
= SMB_VFS_NEXT_OPENDIR(handle
, name_mapped
, mask
, attr
);
286 TALLOC_FREE(name_mapped
);
292 * TRANSLATE_NAME call which converts the given name to
293 * "WINDOWS displayable" name
295 static NTSTATUS
catia_translate_name(struct vfs_handle_struct
*handle
,
296 const char *orig_name
,
297 enum vfs_translate_direction direction
,
303 NTSTATUS status
, ret
;
306 * Copy the supplied name and free the memory for mapped_name,
307 * already allocated by the caller.
308 * We will be allocating new memory for mapped_name in
309 * catia_string_replace_allocate
311 name
= talloc_strdup(talloc_tos(), orig_name
);
314 return NT_STATUS_NO_MEMORY
;
316 status
= catia_string_replace_allocate(handle
->conn
, name
,
317 &mapped_name
, direction
);
320 if (!NT_STATUS_IS_OK(status
)) {
324 ret
= SMB_VFS_NEXT_TRANSLATE_NAME(handle
, mapped_name
, direction
,
325 mem_ctx
, pmapped_name
);
327 if (NT_STATUS_EQUAL(ret
, NT_STATUS_NONE_MAPPED
)) {
328 *pmapped_name
= talloc_move(mem_ctx
, &mapped_name
);
329 /* we need to return the former translation result here */
332 TALLOC_FREE(mapped_name
);
338 static int catia_open(vfs_handle_struct
*handle
,
339 struct smb_filename
*smb_fname
,
344 char *name_mapped
= NULL
;
349 tmp_base_name
= smb_fname
->base_name
;
350 status
= catia_string_replace_allocate(handle
->conn
,
351 smb_fname
->base_name
,
352 &name_mapped
, vfs_translate_to_unix
);
353 if (!NT_STATUS_IS_OK(status
)) {
354 errno
= map_errno_from_nt_status(status
);
358 smb_fname
->base_name
= name_mapped
;
359 ret
= SMB_VFS_NEXT_OPEN(handle
, smb_fname
, fsp
, flags
, mode
);
360 smb_fname
->base_name
= tmp_base_name
;
361 TALLOC_FREE(name_mapped
);
366 static int catia_rename(vfs_handle_struct
*handle
,
367 const struct smb_filename
*smb_fname_src
,
368 const struct smb_filename
*smb_fname_dst
)
370 TALLOC_CTX
*ctx
= talloc_tos();
371 struct smb_filename
*smb_fname_src_tmp
= NULL
;
372 struct smb_filename
*smb_fname_dst_tmp
= NULL
;
373 char *src_name_mapped
= NULL
;
374 char *dst_name_mapped
= NULL
;
378 status
= catia_string_replace_allocate(handle
->conn
,
379 smb_fname_src
->base_name
,
380 &src_name_mapped
, vfs_translate_to_unix
);
381 if (!NT_STATUS_IS_OK(status
)) {
382 errno
= map_errno_from_nt_status(status
);
386 status
= catia_string_replace_allocate(handle
->conn
,
387 smb_fname_dst
->base_name
,
388 &dst_name_mapped
, vfs_translate_to_unix
);
389 if (!NT_STATUS_IS_OK(status
)) {
390 errno
= map_errno_from_nt_status(status
);
394 /* Setup temporary smb_filename structs. */
395 status
= copy_smb_filename(ctx
, smb_fname_src
, &smb_fname_src_tmp
);
397 if (!NT_STATUS_IS_OK(status
)) {
398 errno
= map_errno_from_nt_status(status
);
402 status
= copy_smb_filename(ctx
, smb_fname_dst
, &smb_fname_dst_tmp
);
403 if (!NT_STATUS_IS_OK(status
)) {
404 errno
= map_errno_from_nt_status(status
);
408 smb_fname_src_tmp
->base_name
= src_name_mapped
;
409 smb_fname_dst_tmp
->base_name
= dst_name_mapped
;
410 DEBUG(10, ("converted old name: %s\n",
411 smb_fname_str_dbg(smb_fname_src_tmp
)));
412 DEBUG(10, ("converted new name: %s\n",
413 smb_fname_str_dbg(smb_fname_dst_tmp
)));
415 ret
= SMB_VFS_NEXT_RENAME(handle
, smb_fname_src_tmp
,
418 TALLOC_FREE(src_name_mapped
);
419 TALLOC_FREE(dst_name_mapped
);
420 TALLOC_FREE(smb_fname_src_tmp
);
421 TALLOC_FREE(smb_fname_dst_tmp
);
425 static int catia_stat(vfs_handle_struct
*handle
,
426 struct smb_filename
*smb_fname
)
433 status
= catia_string_replace_allocate(handle
->conn
,
434 smb_fname
->base_name
,
435 &name
, vfs_translate_to_unix
);
436 if (!NT_STATUS_IS_OK(status
)) {
437 errno
= map_errno_from_nt_status(status
);
441 tmp_base_name
= smb_fname
->base_name
;
442 smb_fname
->base_name
= name
;
444 ret
= SMB_VFS_NEXT_STAT(handle
, smb_fname
);
445 smb_fname
->base_name
= tmp_base_name
;
451 static int catia_lstat(vfs_handle_struct
*handle
,
452 struct smb_filename
*smb_fname
)
459 status
= catia_string_replace_allocate(handle
->conn
,
460 smb_fname
->base_name
,
461 &name
, vfs_translate_to_unix
);
462 if (!NT_STATUS_IS_OK(status
)) {
463 errno
= map_errno_from_nt_status(status
);
467 tmp_base_name
= smb_fname
->base_name
;
468 smb_fname
->base_name
= name
;
470 ret
= SMB_VFS_NEXT_LSTAT(handle
, smb_fname
);
471 smb_fname
->base_name
= tmp_base_name
;
477 static int catia_unlink(vfs_handle_struct
*handle
,
478 const struct smb_filename
*smb_fname
)
480 struct smb_filename
*smb_fname_tmp
= NULL
;
485 status
= catia_string_replace_allocate(handle
->conn
,
486 smb_fname
->base_name
,
487 &name
, vfs_translate_to_unix
);
488 if (!NT_STATUS_IS_OK(status
)) {
489 errno
= map_errno_from_nt_status(status
);
493 /* Setup temporary smb_filename structs. */
494 status
= copy_smb_filename(talloc_tos(), smb_fname
, &smb_fname_tmp
);
495 if (!NT_STATUS_IS_OK(status
)) {
496 errno
= map_errno_from_nt_status(status
);
500 smb_fname_tmp
->base_name
= name
;
501 ret
= SMB_VFS_NEXT_UNLINK(handle
, smb_fname_tmp
);
502 TALLOC_FREE(smb_fname_tmp
);
508 static int catia_chown(vfs_handle_struct
*handle
,
517 status
= catia_string_replace_allocate(handle
->conn
, path
,
518 &name
, vfs_translate_to_unix
);
519 if (!NT_STATUS_IS_OK(status
)) {
520 errno
= map_errno_from_nt_status(status
);
524 ret
= SMB_VFS_NEXT_CHOWN(handle
, name
, uid
, gid
);
530 static int catia_lchown(vfs_handle_struct
*handle
,
539 status
= catia_string_replace_allocate(handle
->conn
, path
,
540 &name
, vfs_translate_to_unix
);
541 if (!NT_STATUS_IS_OK(status
)) {
542 errno
= map_errno_from_nt_status(status
);
546 ret
= SMB_VFS_NEXT_LCHOWN(handle
, name
, uid
, gid
);
552 static int catia_rmdir(vfs_handle_struct
*handle
,
559 status
= catia_string_replace_allocate(handle
->conn
, path
,
560 &name
, vfs_translate_to_unix
);
561 if (!NT_STATUS_IS_OK(status
)) {
562 errno
= map_errno_from_nt_status(status
);
566 ret
= SMB_VFS_NEXT_RMDIR(handle
, name
);
572 static int catia_mkdir(vfs_handle_struct
*handle
,
580 status
= catia_string_replace_allocate(handle
->conn
, path
,
581 &name
, vfs_translate_to_unix
);
582 if (!NT_STATUS_IS_OK(status
)) {
583 errno
= map_errno_from_nt_status(status
);
587 ret
= SMB_VFS_NEXT_MKDIR(handle
, name
, mode
);
593 static int catia_chdir(vfs_handle_struct
*handle
,
600 status
= catia_string_replace_allocate(handle
->conn
, path
,
601 &name
, vfs_translate_to_unix
);
602 if (!NT_STATUS_IS_OK(status
)) {
603 errno
= map_errno_from_nt_status(status
);
607 ret
= SMB_VFS_NEXT_CHDIR(handle
, name
);
613 static int catia_ntimes(vfs_handle_struct
*handle
,
614 const struct smb_filename
*smb_fname
,
615 struct smb_file_time
*ft
)
617 struct smb_filename
*smb_fname_tmp
= NULL
;
622 status
= catia_string_replace_allocate(handle
->conn
,
623 smb_fname
->base_name
,
624 &name
, vfs_translate_to_unix
);
625 if (!NT_STATUS_IS_OK(status
)) {
626 errno
= map_errno_from_nt_status(status
);
630 status
= copy_smb_filename(talloc_tos(), smb_fname
, &smb_fname_tmp
);
631 if (!NT_STATUS_IS_OK(status
)) {
632 errno
= map_errno_from_nt_status(status
);
636 smb_fname_tmp
->base_name
= name
;
637 ret
= SMB_VFS_NEXT_NTIMES(handle
, smb_fname_tmp
, ft
);
639 TALLOC_FREE(smb_fname_tmp
);
645 catia_realpath(vfs_handle_struct
*handle
, const char *path
)
647 char *mapped_name
= NULL
;
651 status
= catia_string_replace_allocate(handle
->conn
, path
,
652 &mapped_name
, vfs_translate_to_unix
);
653 if (!NT_STATUS_IS_OK(status
)) {
654 errno
= map_errno_from_nt_status(status
);
658 ret
= SMB_VFS_NEXT_REALPATH(handle
, mapped_name
);
659 TALLOC_FREE(mapped_name
);
664 static int catia_chflags(struct vfs_handle_struct
*handle
,
665 const char *path
, unsigned int flags
)
667 char *mapped_name
= NULL
;
671 status
= catia_string_replace_allocate(handle
->conn
, path
,
672 &mapped_name
, vfs_translate_to_unix
);
673 if (!NT_STATUS_IS_OK(status
)) {
674 errno
= map_errno_from_nt_status(status
);
678 ret
= SMB_VFS_NEXT_CHFLAGS(handle
, mapped_name
, flags
);
679 TALLOC_FREE(mapped_name
);
685 catia_streaminfo(struct vfs_handle_struct
*handle
,
686 struct files_struct
*fsp
,
689 unsigned int *num_streams
,
690 struct stream_struct
**streams
)
692 char *mapped_name
= NULL
;
695 status
= catia_string_replace_allocate(handle
->conn
, path
,
696 &mapped_name
, vfs_translate_to_unix
);
697 if (!NT_STATUS_IS_OK(status
)) {
698 errno
= map_errno_from_nt_status(status
);
702 status
= SMB_VFS_NEXT_STREAMINFO(handle
, fsp
, mapped_name
,
703 mem_ctx
, num_streams
,streams
);
704 TALLOC_FREE(mapped_name
);
710 catia_get_nt_acl(struct vfs_handle_struct
*handle
,
712 uint32 security_info
,
714 struct security_descriptor
**ppdesc
)
716 char *mapped_name
= NULL
;
719 status
= catia_string_replace_allocate(handle
->conn
,
720 path
, &mapped_name
, vfs_translate_to_unix
);
721 if (!NT_STATUS_IS_OK(status
)) {
722 errno
= map_errno_from_nt_status(status
);
725 status
= SMB_VFS_NEXT_GET_NT_ACL(handle
, mapped_name
,
726 security_info
, mem_ctx
, ppdesc
);
727 TALLOC_FREE(mapped_name
);
733 catia_chmod_acl(vfs_handle_struct
*handle
,
737 char *mapped_name
= NULL
;
741 status
= catia_string_replace_allocate(handle
->conn
,
742 path
, &mapped_name
, vfs_translate_to_unix
);
743 if (!NT_STATUS_IS_OK(status
)) {
744 errno
= map_errno_from_nt_status(status
);
748 ret
= SMB_VFS_NEXT_CHMOD_ACL(handle
, mapped_name
, mode
);
749 TALLOC_FREE(mapped_name
);
754 catia_sys_acl_get_file(vfs_handle_struct
*handle
,
759 char *mapped_name
= NULL
;
763 status
= catia_string_replace_allocate(handle
->conn
,
764 path
, &mapped_name
, vfs_translate_to_unix
);
765 if (!NT_STATUS_IS_OK(status
)) {
766 errno
= map_errno_from_nt_status(status
);
770 ret
= SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle
, mapped_name
, type
, mem_ctx
);
771 TALLOC_FREE(mapped_name
);
777 catia_sys_acl_set_file(vfs_handle_struct
*handle
,
782 char *mapped_name
= NULL
;
786 status
= catia_string_replace_allocate(handle
->conn
,
787 path
, &mapped_name
, vfs_translate_to_unix
);
788 if (!NT_STATUS_IS_OK(status
)) {
789 errno
= map_errno_from_nt_status(status
);
793 ret
= SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle
, mapped_name
, type
, theacl
);
794 TALLOC_FREE(mapped_name
);
800 catia_sys_acl_delete_def_file(vfs_handle_struct
*handle
,
803 char *mapped_name
= NULL
;
807 status
= catia_string_replace_allocate(handle
->conn
,
808 path
, &mapped_name
, vfs_translate_to_unix
);
809 if (!NT_STATUS_IS_OK(status
)) {
810 errno
= map_errno_from_nt_status(status
);
814 ret
= SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle
, mapped_name
);
815 TALLOC_FREE(mapped_name
);
821 catia_getxattr(vfs_handle_struct
*handle
, const char *path
,
822 const char *name
, void *value
, size_t size
)
824 char *mapped_name
= NULL
;
828 status
= catia_string_replace_allocate(handle
->conn
,
829 name
, &mapped_name
, vfs_translate_to_unix
);
830 if (!NT_STATUS_IS_OK(status
)) {
831 errno
= map_errno_from_nt_status(status
);
836 ret
= SMB_VFS_NEXT_GETXATTR(handle
, path
, mapped_name
, value
, size
);
837 TALLOC_FREE(mapped_name
);
843 catia_listxattr(vfs_handle_struct
*handle
, const char *path
,
844 char *list
, size_t size
)
846 char *mapped_name
= NULL
;
850 status
= catia_string_replace_allocate(handle
->conn
,
851 path
, &mapped_name
, vfs_translate_to_unix
);
852 if (!NT_STATUS_IS_OK(status
)) {
853 errno
= map_errno_from_nt_status(status
);
858 ret
= SMB_VFS_NEXT_LISTXATTR(handle
, mapped_name
, list
, size
);
859 TALLOC_FREE(mapped_name
);
865 catia_removexattr(vfs_handle_struct
*handle
, const char *path
,
868 char *mapped_name
= NULL
;
872 status
= catia_string_replace_allocate(handle
->conn
,
873 name
, &mapped_name
, vfs_translate_to_unix
);
874 if (!NT_STATUS_IS_OK(status
)) {
875 errno
= map_errno_from_nt_status(status
);
880 ret
= SMB_VFS_NEXT_REMOVEXATTR(handle
, path
, mapped_name
);
881 TALLOC_FREE(mapped_name
);
887 catia_setxattr(vfs_handle_struct
*handle
, const char *path
,
888 const char *name
, const void *value
, size_t size
,
891 char *mapped_name
= NULL
;
895 status
= catia_string_replace_allocate(handle
->conn
,
896 name
, &mapped_name
, vfs_translate_to_unix
);
897 if (!NT_STATUS_IS_OK(status
)) {
898 errno
= map_errno_from_nt_status(status
);
903 ret
= SMB_VFS_NEXT_SETXATTR(handle
, path
, mapped_name
, value
, size
, flags
);
904 TALLOC_FREE(mapped_name
);
909 static struct vfs_fn_pointers vfs_catia_fns
= {
910 .mkdir_fn
= catia_mkdir
,
911 .rmdir_fn
= catia_rmdir
,
912 .opendir_fn
= catia_opendir
,
913 .open_fn
= catia_open
,
914 .rename_fn
= catia_rename
,
915 .stat_fn
= catia_stat
,
916 .lstat_fn
= catia_lstat
,
917 .unlink_fn
= catia_unlink
,
918 .chown_fn
= catia_chown
,
919 .lchown_fn
= catia_lchown
,
920 .chdir_fn
= catia_chdir
,
921 .ntimes_fn
= catia_ntimes
,
922 .realpath_fn
= catia_realpath
,
923 .chflags_fn
= catia_chflags
,
924 .streaminfo_fn
= catia_streaminfo
,
925 .translate_name_fn
= catia_translate_name
,
926 .get_nt_acl_fn
= catia_get_nt_acl
,
927 .chmod_acl_fn
= catia_chmod_acl
,
928 .sys_acl_get_file_fn
= catia_sys_acl_get_file
,
929 .sys_acl_set_file_fn
= catia_sys_acl_set_file
,
930 .sys_acl_delete_def_file_fn
= catia_sys_acl_delete_def_file
,
931 .getxattr_fn
= catia_getxattr
,
932 .listxattr_fn
= catia_listxattr
,
933 .removexattr_fn
= catia_removexattr
,
934 .setxattr_fn
= catia_setxattr
,
937 NTSTATUS
vfs_catia_init(void)
941 ret
= smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "catia",
943 if (!NT_STATUS_IS_OK(ret
))
946 vfs_catia_debug_level
= debug_add_class("catia");
947 if (vfs_catia_debug_level
== -1) {
948 vfs_catia_debug_level
= DBGC_VFS
;
949 DEBUG(0, ("vfs_catia: Couldn't register custom debugging "
952 DEBUG(10, ("vfs_catia: Debug class number of "
953 "'catia': %d\n", vfs_catia_debug_level
));