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
,
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 ret
= catia_string_replace_allocate(handle
->conn
, name
,
317 &mapped_name
, direction
);
320 if (!NT_STATUS_IS_OK(ret
)) {
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
);
330 TALLOC_FREE(mapped_name
);
336 static int catia_open(vfs_handle_struct
*handle
,
337 struct smb_filename
*smb_fname
,
342 char *name_mapped
= NULL
;
347 tmp_base_name
= smb_fname
->base_name
;
348 status
= catia_string_replace_allocate(handle
->conn
,
349 smb_fname
->base_name
,
350 &name_mapped
, vfs_translate_to_unix
);
351 if (!NT_STATUS_IS_OK(status
)) {
352 errno
= map_errno_from_nt_status(status
);
356 smb_fname
->base_name
= name_mapped
;
357 ret
= SMB_VFS_NEXT_OPEN(handle
, smb_fname
, fsp
, flags
, mode
);
358 smb_fname
->base_name
= tmp_base_name
;
359 TALLOC_FREE(name_mapped
);
364 static int catia_rename(vfs_handle_struct
*handle
,
365 const struct smb_filename
*smb_fname_src
,
366 const struct smb_filename
*smb_fname_dst
)
368 TALLOC_CTX
*ctx
= talloc_tos();
369 struct smb_filename
*smb_fname_src_tmp
= NULL
;
370 struct smb_filename
*smb_fname_dst_tmp
= NULL
;
371 char *src_name_mapped
= NULL
;
372 char *dst_name_mapped
= NULL
;
376 status
= catia_string_replace_allocate(handle
->conn
,
377 smb_fname_src
->base_name
,
378 &src_name_mapped
, vfs_translate_to_unix
);
379 if (!NT_STATUS_IS_OK(status
)) {
380 errno
= map_errno_from_nt_status(status
);
384 status
= catia_string_replace_allocate(handle
->conn
,
385 smb_fname_dst
->base_name
,
386 &dst_name_mapped
, vfs_translate_to_unix
);
387 if (!NT_STATUS_IS_OK(status
)) {
388 errno
= map_errno_from_nt_status(status
);
392 /* Setup temporary smb_filename structs. */
393 status
= copy_smb_filename(ctx
, smb_fname_src
, &smb_fname_src_tmp
);
395 if (!NT_STATUS_IS_OK(status
)) {
396 errno
= map_errno_from_nt_status(status
);
400 status
= copy_smb_filename(ctx
, smb_fname_dst
, &smb_fname_dst_tmp
);
401 if (!NT_STATUS_IS_OK(status
)) {
402 errno
= map_errno_from_nt_status(status
);
406 smb_fname_src_tmp
->base_name
= src_name_mapped
;
407 smb_fname_dst_tmp
->base_name
= dst_name_mapped
;
408 DEBUG(10, ("converted old name: %s\n",
409 smb_fname_str_dbg(smb_fname_src_tmp
)));
410 DEBUG(10, ("converted new name: %s\n",
411 smb_fname_str_dbg(smb_fname_dst_tmp
)));
413 ret
= SMB_VFS_NEXT_RENAME(handle
, smb_fname_src_tmp
,
416 TALLOC_FREE(src_name_mapped
);
417 TALLOC_FREE(dst_name_mapped
);
418 TALLOC_FREE(smb_fname_src_tmp
);
419 TALLOC_FREE(smb_fname_dst_tmp
);
423 static int catia_stat(vfs_handle_struct
*handle
,
424 struct smb_filename
*smb_fname
)
431 status
= catia_string_replace_allocate(handle
->conn
,
432 smb_fname
->base_name
,
433 &name
, vfs_translate_to_unix
);
434 if (!NT_STATUS_IS_OK(status
)) {
435 errno
= map_errno_from_nt_status(status
);
439 tmp_base_name
= smb_fname
->base_name
;
440 smb_fname
->base_name
= name
;
442 ret
= SMB_VFS_NEXT_STAT(handle
, smb_fname
);
443 smb_fname
->base_name
= tmp_base_name
;
449 static int catia_lstat(vfs_handle_struct
*handle
,
450 struct smb_filename
*smb_fname
)
457 status
= catia_string_replace_allocate(handle
->conn
,
458 smb_fname
->base_name
,
459 &name
, vfs_translate_to_unix
);
460 if (!NT_STATUS_IS_OK(status
)) {
461 errno
= map_errno_from_nt_status(status
);
465 tmp_base_name
= smb_fname
->base_name
;
466 smb_fname
->base_name
= name
;
468 ret
= SMB_VFS_NEXT_LSTAT(handle
, smb_fname
);
469 smb_fname
->base_name
= tmp_base_name
;
475 static int catia_unlink(vfs_handle_struct
*handle
,
476 const struct smb_filename
*smb_fname
)
478 struct smb_filename
*smb_fname_tmp
= NULL
;
483 status
= catia_string_replace_allocate(handle
->conn
,
484 smb_fname
->base_name
,
485 &name
, vfs_translate_to_unix
);
486 if (!NT_STATUS_IS_OK(status
)) {
487 errno
= map_errno_from_nt_status(status
);
491 /* Setup temporary smb_filename structs. */
492 status
= copy_smb_filename(talloc_tos(), smb_fname
, &smb_fname_tmp
);
493 if (!NT_STATUS_IS_OK(status
)) {
494 errno
= map_errno_from_nt_status(status
);
498 smb_fname_tmp
->base_name
= name
;
499 ret
= SMB_VFS_NEXT_UNLINK(handle
, smb_fname_tmp
);
500 TALLOC_FREE(smb_fname_tmp
);
506 static int catia_chown(vfs_handle_struct
*handle
,
515 status
= catia_string_replace_allocate(handle
->conn
, path
,
516 &name
, vfs_translate_to_unix
);
517 if (!NT_STATUS_IS_OK(status
)) {
518 errno
= map_errno_from_nt_status(status
);
522 ret
= SMB_VFS_NEXT_CHOWN(handle
, name
, uid
, gid
);
528 static int catia_lchown(vfs_handle_struct
*handle
,
537 status
= catia_string_replace_allocate(handle
->conn
, path
,
538 &name
, vfs_translate_to_unix
);
539 if (!NT_STATUS_IS_OK(status
)) {
540 errno
= map_errno_from_nt_status(status
);
544 ret
= SMB_VFS_NEXT_LCHOWN(handle
, name
, uid
, gid
);
550 static int catia_rmdir(vfs_handle_struct
*handle
,
557 status
= catia_string_replace_allocate(handle
->conn
, path
,
558 &name
, vfs_translate_to_unix
);
559 if (!NT_STATUS_IS_OK(status
)) {
560 errno
= map_errno_from_nt_status(status
);
564 ret
= SMB_VFS_NEXT_RMDIR(handle
, name
);
570 static int catia_mkdir(vfs_handle_struct
*handle
,
578 status
= catia_string_replace_allocate(handle
->conn
, path
,
579 &name
, vfs_translate_to_unix
);
580 if (!NT_STATUS_IS_OK(status
)) {
581 errno
= map_errno_from_nt_status(status
);
585 ret
= SMB_VFS_NEXT_MKDIR(handle
, name
, mode
);
591 static int catia_chdir(vfs_handle_struct
*handle
,
598 status
= catia_string_replace_allocate(handle
->conn
, path
,
599 &name
, vfs_translate_to_unix
);
600 if (!NT_STATUS_IS_OK(status
)) {
601 errno
= map_errno_from_nt_status(status
);
605 ret
= SMB_VFS_NEXT_CHDIR(handle
, name
);
611 static int catia_ntimes(vfs_handle_struct
*handle
,
612 const struct smb_filename
*smb_fname
,
613 struct smb_file_time
*ft
)
615 struct smb_filename
*smb_fname_tmp
= NULL
;
620 status
= catia_string_replace_allocate(handle
->conn
,
621 smb_fname
->base_name
,
622 &name
, vfs_translate_to_unix
);
623 if (!NT_STATUS_IS_OK(status
)) {
624 errno
= map_errno_from_nt_status(status
);
628 status
= copy_smb_filename(talloc_tos(), smb_fname
, &smb_fname_tmp
);
629 if (!NT_STATUS_IS_OK(status
)) {
630 errno
= map_errno_from_nt_status(status
);
634 smb_fname_tmp
->base_name
= name
;
635 ret
= SMB_VFS_NEXT_NTIMES(handle
, smb_fname_tmp
, ft
);
637 TALLOC_FREE(smb_fname_tmp
);
643 catia_realpath(vfs_handle_struct
*handle
, const char *path
)
645 char *mapped_name
= NULL
;
649 status
= catia_string_replace_allocate(handle
->conn
, path
,
650 &mapped_name
, vfs_translate_to_unix
);
651 if (!NT_STATUS_IS_OK(status
)) {
652 errno
= map_errno_from_nt_status(status
);
656 ret
= SMB_VFS_NEXT_REALPATH(handle
, mapped_name
);
657 TALLOC_FREE(mapped_name
);
662 static int catia_chflags(struct vfs_handle_struct
*handle
,
663 const char *path
, unsigned int flags
)
665 char *mapped_name
= NULL
;
669 status
= catia_string_replace_allocate(handle
->conn
, path
,
670 &mapped_name
, vfs_translate_to_unix
);
671 if (!NT_STATUS_IS_OK(status
)) {
672 errno
= map_errno_from_nt_status(status
);
676 ret
= SMB_VFS_NEXT_CHFLAGS(handle
, mapped_name
, flags
);
677 TALLOC_FREE(mapped_name
);
683 catia_streaminfo(struct vfs_handle_struct
*handle
,
684 struct files_struct
*fsp
,
687 unsigned int *num_streams
,
688 struct stream_struct
**streams
)
690 char *mapped_name
= NULL
;
693 status
= catia_string_replace_allocate(handle
->conn
, path
,
694 &mapped_name
, vfs_translate_to_unix
);
695 if (!NT_STATUS_IS_OK(status
)) {
696 errno
= map_errno_from_nt_status(status
);
700 status
= SMB_VFS_NEXT_STREAMINFO(handle
, fsp
, mapped_name
,
701 mem_ctx
, num_streams
,streams
);
702 TALLOC_FREE(mapped_name
);
708 catia_get_nt_acl(struct vfs_handle_struct
*handle
,
710 uint32 security_info
,
712 struct security_descriptor
**ppdesc
)
714 char *mapped_name
= NULL
;
717 status
= catia_string_replace_allocate(handle
->conn
,
718 path
, &mapped_name
, vfs_translate_to_unix
);
719 if (!NT_STATUS_IS_OK(status
)) {
720 errno
= map_errno_from_nt_status(status
);
723 status
= SMB_VFS_NEXT_GET_NT_ACL(handle
, mapped_name
,
724 security_info
, mem_ctx
, ppdesc
);
725 TALLOC_FREE(mapped_name
);
731 catia_chmod_acl(vfs_handle_struct
*handle
,
735 char *mapped_name
= NULL
;
739 status
= catia_string_replace_allocate(handle
->conn
,
740 path
, &mapped_name
, vfs_translate_to_unix
);
741 if (!NT_STATUS_IS_OK(status
)) {
742 errno
= map_errno_from_nt_status(status
);
746 ret
= SMB_VFS_NEXT_CHMOD_ACL(handle
, mapped_name
, mode
);
747 TALLOC_FREE(mapped_name
);
752 catia_sys_acl_get_file(vfs_handle_struct
*handle
,
757 char *mapped_name
= NULL
;
761 status
= catia_string_replace_allocate(handle
->conn
,
762 path
, &mapped_name
, vfs_translate_to_unix
);
763 if (!NT_STATUS_IS_OK(status
)) {
764 errno
= map_errno_from_nt_status(status
);
768 ret
= SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle
, mapped_name
, type
, mem_ctx
);
769 TALLOC_FREE(mapped_name
);
775 catia_sys_acl_set_file(vfs_handle_struct
*handle
,
780 char *mapped_name
= NULL
;
784 status
= catia_string_replace_allocate(handle
->conn
,
785 path
, &mapped_name
, vfs_translate_to_unix
);
786 if (!NT_STATUS_IS_OK(status
)) {
787 errno
= map_errno_from_nt_status(status
);
791 ret
= SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle
, mapped_name
, type
, theacl
);
792 TALLOC_FREE(mapped_name
);
798 catia_sys_acl_delete_def_file(vfs_handle_struct
*handle
,
801 char *mapped_name
= NULL
;
805 status
= catia_string_replace_allocate(handle
->conn
,
806 path
, &mapped_name
, vfs_translate_to_unix
);
807 if (!NT_STATUS_IS_OK(status
)) {
808 errno
= map_errno_from_nt_status(status
);
812 ret
= SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle
, mapped_name
);
813 TALLOC_FREE(mapped_name
);
819 catia_getxattr(vfs_handle_struct
*handle
, const char *path
,
820 const char *name
, void *value
, size_t size
)
822 char *mapped_name
= NULL
;
826 status
= catia_string_replace_allocate(handle
->conn
,
827 name
, &mapped_name
, vfs_translate_to_unix
);
828 if (!NT_STATUS_IS_OK(status
)) {
829 errno
= map_errno_from_nt_status(status
);
834 ret
= SMB_VFS_NEXT_GETXATTR(handle
, path
, mapped_name
, value
, size
);
835 TALLOC_FREE(mapped_name
);
841 catia_listxattr(vfs_handle_struct
*handle
, const char *path
,
842 char *list
, size_t size
)
844 char *mapped_name
= NULL
;
848 status
= catia_string_replace_allocate(handle
->conn
,
849 path
, &mapped_name
, vfs_translate_to_unix
);
850 if (!NT_STATUS_IS_OK(status
)) {
851 errno
= map_errno_from_nt_status(status
);
856 ret
= SMB_VFS_NEXT_LISTXATTR(handle
, mapped_name
, list
, size
);
857 TALLOC_FREE(mapped_name
);
863 catia_removexattr(vfs_handle_struct
*handle
, const char *path
,
866 char *mapped_name
= NULL
;
870 status
= catia_string_replace_allocate(handle
->conn
,
871 name
, &mapped_name
, vfs_translate_to_unix
);
872 if (!NT_STATUS_IS_OK(status
)) {
873 errno
= map_errno_from_nt_status(status
);
878 ret
= SMB_VFS_NEXT_REMOVEXATTR(handle
, path
, mapped_name
);
879 TALLOC_FREE(mapped_name
);
885 catia_setxattr(vfs_handle_struct
*handle
, const char *path
,
886 const char *name
, const void *value
, size_t size
,
889 char *mapped_name
= NULL
;
893 status
= catia_string_replace_allocate(handle
->conn
,
894 name
, &mapped_name
, vfs_translate_to_unix
);
895 if (!NT_STATUS_IS_OK(status
)) {
896 errno
= map_errno_from_nt_status(status
);
901 ret
= SMB_VFS_NEXT_SETXATTR(handle
, path
, mapped_name
, value
, size
, flags
);
902 TALLOC_FREE(mapped_name
);
907 static struct vfs_fn_pointers vfs_catia_fns
= {
908 .mkdir_fn
= catia_mkdir
,
909 .rmdir_fn
= catia_rmdir
,
910 .opendir_fn
= catia_opendir
,
911 .open_fn
= catia_open
,
912 .rename_fn
= catia_rename
,
913 .stat_fn
= catia_stat
,
914 .lstat_fn
= catia_lstat
,
915 .unlink_fn
= catia_unlink
,
916 .chown_fn
= catia_chown
,
917 .lchown_fn
= catia_lchown
,
918 .chdir_fn
= catia_chdir
,
919 .ntimes_fn
= catia_ntimes
,
920 .realpath_fn
= catia_realpath
,
921 .chflags_fn
= catia_chflags
,
922 .streaminfo_fn
= catia_streaminfo
,
923 .translate_name_fn
= catia_translate_name
,
924 .get_nt_acl_fn
= catia_get_nt_acl
,
925 .chmod_acl_fn
= catia_chmod_acl
,
926 .sys_acl_get_file_fn
= catia_sys_acl_get_file
,
927 .sys_acl_set_file_fn
= catia_sys_acl_set_file
,
928 .sys_acl_delete_def_file_fn
= catia_sys_acl_delete_def_file
,
929 .getxattr_fn
= catia_getxattr
,
930 .listxattr_fn
= catia_listxattr
,
931 .removexattr_fn
= catia_removexattr
,
932 .setxattr_fn
= catia_setxattr
,
935 NTSTATUS
vfs_catia_init(void)
939 ret
= smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "catia",
941 if (!NT_STATUS_IS_OK(ret
))
944 vfs_catia_debug_level
= debug_add_class("catia");
945 if (vfs_catia_debug_level
== -1) {
946 vfs_catia_debug_level
= DBGC_VFS
;
947 DEBUG(0, ("vfs_catia: Couldn't register custom debugging "
950 DEBUG(10, ("vfs_catia: Debug class number of "
951 "'catia': %d\n", vfs_catia_debug_level
));