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/>.
31 #define GLOBAL_SNUM 0xFFFFFFF
33 #define MAP_NUM 0x101 /* max unicode charval / MAP_SIZE */
34 #define T_OFFSET(_v_) ((_v_ % MAP_SIZE))
35 #define T_START(_v_) (((_v_ / MAP_SIZE) * MAP_SIZE))
36 #define T_PICK(_v_) ((_v_ / MAP_SIZE))
38 struct char_mappings {
39 smb_ucs2_t entry[MAP_SIZE][2];
42 struct share_mapping_entry {
44 struct share_mapping_entry *next;
45 struct char_mappings **mappings;
48 struct share_mapping_entry *srt_head = NULL;
50 static bool build_table(struct char_mappings **cmaps, int value)
53 int start = T_START(value);
55 (*cmaps) = talloc_zero(NULL, struct char_mappings);
60 for (i = 0; i < MAP_SIZE;i++) {
61 (*cmaps)->entry[i][vfs_translate_to_unix] = start + i;
62 (*cmaps)->entry[i][vfs_translate_to_windows] = start + i;
68 static void set_tables(struct char_mappings **cmaps,
74 /* set unix -> windows */
75 i = T_OFFSET(unix_map);
76 cmaps[T_PICK(unix_map)]->entry[i][vfs_translate_to_windows] = windows_map;
78 /* set windows -> unix */
79 i = T_OFFSET(windows_map);
80 cmaps[T_PICK(windows_map)]->entry[i][vfs_translate_to_unix] = unix_map;
83 static bool build_ranges(struct char_mappings **cmaps,
88 if (!cmaps[T_PICK(unix_map)]) {
89 if (!build_table(&cmaps[T_PICK(unix_map)], unix_map))
93 if (!cmaps[T_PICK(windows_map)]) {
94 if (!build_table(&cmaps[T_PICK(windows_map)], windows_map))
98 set_tables(cmaps, unix_map, windows_map);
103 static struct share_mapping_entry *get_srt(connection_struct *conn,
104 struct share_mapping_entry **global)
106 struct share_mapping_entry *share;
108 for (share = srt_head; share != NULL; share = share->next) {
109 if (share->snum == GLOBAL_SNUM)
112 if (share->snum == SNUM(conn))
119 static struct share_mapping_entry *add_srt(int snum, const char **mappings)
125 long unix_map, windows_map;
126 struct share_mapping_entry *ret = NULL;
128 ret = (struct share_mapping_entry *)
129 TALLOC_ZERO(NULL, sizeof(struct share_mapping_entry) +
130 (mappings ? (MAP_NUM * sizeof(struct char_mappings *)) : 0));
138 ret->mappings = (struct char_mappings**) ((unsigned char*) ret +
139 sizeof(struct share_mapping_entry));
140 memset(ret->mappings, 0,
141 MAP_NUM * sizeof(struct char_mappings *));
143 ret->mappings = NULL;
148 * catia mappings are of the form :
149 * UNIX char (in 0xnn hex) : WINDOWS char (in 0xnn hex)
151 * multiple mappings are comma seperated in smb.conf
153 for (i=0;mappings[i];i++) {
154 fstrcpy(mapping, mappings[i]);
155 unix_map = strtol(mapping, &tmp, 16);
156 if (unix_map == 0 && errno == EINVAL) {
157 DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
160 windows_map = strtol(++tmp, NULL, 16);
161 if (windows_map == 0 && errno == EINVAL) {
162 DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
166 if (!build_ranges(ret->mappings, unix_map, windows_map)) {
167 DEBUG(0, ("TABLE ERROR - CATIA MAPPINGS - %s\n", mapping));
172 ret->next = srt_head;
178 static bool init_mappings(connection_struct *conn,
179 struct share_mapping_entry **selected_out)
181 const char **mappings = NULL;
182 struct share_mapping_entry *share_level = NULL;
183 struct share_mapping_entry *global = NULL;
185 /* check srt cache */
186 share_level = get_srt(conn, &global);
188 *selected_out = share_level;
189 return (share_level->mappings != NULL);
192 /* see if we have a global setting */
195 mappings = lp_parm_string_list(-1, "catia", "mappings", NULL);
196 global = add_srt(GLOBAL_SNUM, mappings);
199 /* no global setting - what about share level ? */
200 mappings = lp_parm_string_list(SNUM(conn), "catia", "mappings", NULL);
201 share_level = add_srt(SNUM(conn), mappings);
203 if (share_level->mappings) {
204 (*selected_out) = share_level;
206 } else if (global->mappings) {
207 share_level->mappings = global->mappings;
208 (*selected_out) = share_level;
215 static NTSTATUS catia_string_replace_allocate(connection_struct *conn,
220 static smb_ucs2_t *tmpbuf = NULL;
222 struct share_mapping_entry *selected;
223 struct char_mappings *map = NULL;
224 size_t converted_size;
225 TALLOC_CTX *ctx = talloc_tos();
227 if (!init_mappings(conn, &selected)) {
228 /* No mappings found. Just use the old name */
229 *mapped_name = talloc_strdup(NULL, name_in);
232 return NT_STATUS_NO_MEMORY;
237 if ((push_ucs2_talloc(ctx, &tmpbuf, name_in,
238 &converted_size)) == false) {
239 return map_nt_error_from_unix(errno);
245 map = selected->mappings[T_PICK((*ptr))];
251 *ptr = map->entry[T_OFFSET((*ptr))][direction];
254 if ((pull_ucs2_talloc(ctx, mapped_name, tmpbuf,
255 &converted_size)) == false) {
257 return map_nt_error_from_unix(errno);
263 static SMB_STRUCT_DIR *catia_opendir(vfs_handle_struct *handle,
268 char *name_mapped = NULL;
272 status = catia_string_replace_allocate(handle->conn, fname,
273 &name_mapped, vfs_translate_to_unix);
274 if (!NT_STATUS_IS_OK(status)) {
275 errno = map_errno_from_nt_status(status);
279 ret = SMB_VFS_NEXT_OPENDIR(handle, name_mapped, mask, attr);
280 TALLOC_FREE(name_mapped);
286 * TRANSLATE_NAME call which converts the given name to
287 * "WINDOWS displayable" name
289 static NTSTATUS catia_translate_name(struct vfs_handle_struct *handle,
290 const char *orig_name,
291 enum vfs_translate_direction direction,
300 * Copy the supplied name and free the memory for mapped_name,
301 * already allocated by the caller.
302 * We will be allocating new memory for mapped_name in
303 * catia_string_replace_allocate
305 name = talloc_strdup(talloc_tos(), orig_name);
308 return NT_STATUS_NO_MEMORY;
310 ret = catia_string_replace_allocate(handle->conn, name,
311 &mapped_name, direction);
314 if (!NT_STATUS_IS_OK(ret)) {
318 ret = SMB_VFS_NEXT_TRANSLATE_NAME(handle, mapped_name, direction,
319 mem_ctx, pmapped_name);
321 if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
322 *pmapped_name = talloc_move(mem_ctx, &mapped_name);
324 TALLOC_FREE(mapped_name);
330 static int catia_open(vfs_handle_struct *handle,
331 struct smb_filename *smb_fname,
336 char *name_mapped = NULL;
341 tmp_base_name = smb_fname->base_name;
342 status = catia_string_replace_allocate(handle->conn,
343 smb_fname->base_name,
344 &name_mapped, vfs_translate_to_unix);
345 if (!NT_STATUS_IS_OK(status)) {
346 errno = map_errno_from_nt_status(status);
350 smb_fname->base_name = name_mapped;
351 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
352 smb_fname->base_name = tmp_base_name;
353 TALLOC_FREE(name_mapped);
358 static int catia_rename(vfs_handle_struct *handle,
359 const struct smb_filename *smb_fname_src,
360 const struct smb_filename *smb_fname_dst)
362 TALLOC_CTX *ctx = talloc_tos();
363 struct smb_filename *smb_fname_src_tmp = NULL;
364 struct smb_filename *smb_fname_dst_tmp = NULL;
365 char *src_name_mapped = NULL;
366 char *dst_name_mapped = NULL;
370 status = catia_string_replace_allocate(handle->conn,
371 smb_fname_src->base_name,
372 &src_name_mapped, vfs_translate_to_unix);
373 if (!NT_STATUS_IS_OK(status)) {
374 errno = map_errno_from_nt_status(status);
378 status = catia_string_replace_allocate(handle->conn,
379 smb_fname_dst->base_name,
380 &dst_name_mapped, vfs_translate_to_unix);
381 if (!NT_STATUS_IS_OK(status)) {
382 errno = map_errno_from_nt_status(status);
386 /* Setup temporary smb_filename structs. */
387 status = copy_smb_filename(ctx, smb_fname_src, &smb_fname_src_tmp);
389 if (!NT_STATUS_IS_OK(status)) {
390 errno = map_errno_from_nt_status(status);
394 status = copy_smb_filename(ctx, smb_fname_dst, &smb_fname_dst_tmp);
395 if (!NT_STATUS_IS_OK(status)) {
396 errno = map_errno_from_nt_status(status);
400 smb_fname_src_tmp->base_name = src_name_mapped;
401 smb_fname_dst_tmp->base_name = dst_name_mapped;
402 DEBUG(10, ("converted old name: %s\n",
403 smb_fname_str_dbg(smb_fname_src_tmp)));
404 DEBUG(10, ("converted new name: %s\n",
405 smb_fname_str_dbg(smb_fname_dst_tmp)));
407 ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
410 TALLOC_FREE(src_name_mapped);
411 TALLOC_FREE(dst_name_mapped);
412 TALLOC_FREE(smb_fname_src_tmp);
413 TALLOC_FREE(smb_fname_dst_tmp);
417 static int catia_stat(vfs_handle_struct *handle,
418 struct smb_filename *smb_fname)
425 status = catia_string_replace_allocate(handle->conn,
426 smb_fname->base_name,
427 &name, vfs_translate_to_unix);
428 if (!NT_STATUS_IS_OK(status)) {
429 errno = map_errno_from_nt_status(status);
433 tmp_base_name = smb_fname->base_name;
434 smb_fname->base_name = name;
436 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
437 smb_fname->base_name = tmp_base_name;
443 static int catia_lstat(vfs_handle_struct *handle,
444 struct smb_filename *smb_fname)
451 status = catia_string_replace_allocate(handle->conn,
452 smb_fname->base_name,
453 &name, vfs_translate_to_unix);
454 if (!NT_STATUS_IS_OK(status)) {
455 errno = map_errno_from_nt_status(status);
459 tmp_base_name = smb_fname->base_name;
460 smb_fname->base_name = name;
462 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
463 smb_fname->base_name = tmp_base_name;
469 static int catia_unlink(vfs_handle_struct *handle,
470 const struct smb_filename *smb_fname)
472 struct smb_filename *smb_fname_tmp = NULL;
477 status = catia_string_replace_allocate(handle->conn,
478 smb_fname->base_name,
479 &name, vfs_translate_to_unix);
480 if (!NT_STATUS_IS_OK(status)) {
481 errno = map_errno_from_nt_status(status);
485 /* Setup temporary smb_filename structs. */
486 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
487 if (!NT_STATUS_IS_OK(status)) {
488 errno = map_errno_from_nt_status(status);
492 smb_fname_tmp->base_name = name;
493 ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
494 TALLOC_FREE(smb_fname_tmp);
500 static int catia_chown(vfs_handle_struct *handle,
509 status = catia_string_replace_allocate(handle->conn, path,
510 &name, vfs_translate_to_unix);
511 if (!NT_STATUS_IS_OK(status)) {
512 errno = map_errno_from_nt_status(status);
516 ret = SMB_VFS_NEXT_CHOWN(handle, name, uid, gid);
522 static int catia_lchown(vfs_handle_struct *handle,
531 status = catia_string_replace_allocate(handle->conn, path,
532 &name, vfs_translate_to_unix);
533 if (!NT_STATUS_IS_OK(status)) {
534 errno = map_errno_from_nt_status(status);
538 ret = SMB_VFS_NEXT_LCHOWN(handle, name, uid, gid);
544 static int catia_rmdir(vfs_handle_struct *handle,
551 status = catia_string_replace_allocate(handle->conn, path,
552 &name, vfs_translate_to_unix);
553 if (!NT_STATUS_IS_OK(status)) {
554 errno = map_errno_from_nt_status(status);
558 ret = SMB_VFS_NEXT_RMDIR(handle, name);
564 static int catia_mkdir(vfs_handle_struct *handle,
572 status = catia_string_replace_allocate(handle->conn, path,
573 &name, vfs_translate_to_unix);
574 if (!NT_STATUS_IS_OK(status)) {
575 errno = map_errno_from_nt_status(status);
579 ret = SMB_VFS_NEXT_MKDIR(handle, name, mode);
585 static int catia_chdir(vfs_handle_struct *handle,
592 status = catia_string_replace_allocate(handle->conn, path,
593 &name, vfs_translate_to_unix);
594 if (!NT_STATUS_IS_OK(status)) {
595 errno = map_errno_from_nt_status(status);
599 ret = SMB_VFS_NEXT_CHDIR(handle, name);
605 static int catia_ntimes(vfs_handle_struct *handle,
606 const struct smb_filename *smb_fname,
607 struct smb_file_time *ft)
609 struct smb_filename *smb_fname_tmp = NULL;
614 status = catia_string_replace_allocate(handle->conn,
615 smb_fname->base_name,
616 &name, vfs_translate_to_unix);
617 if (!NT_STATUS_IS_OK(status)) {
618 errno = map_errno_from_nt_status(status);
622 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
623 if (!NT_STATUS_IS_OK(status)) {
624 errno = map_errno_from_nt_status(status);
628 smb_fname_tmp->base_name = name;
629 ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname_tmp, ft);
631 TALLOC_FREE(smb_fname_tmp);
637 catia_realpath(vfs_handle_struct *handle, const char *path)
639 char *mapped_name = NULL;
643 status = catia_string_replace_allocate(handle->conn, path,
644 &mapped_name, vfs_translate_to_unix);
645 if (!NT_STATUS_IS_OK(status)) {
646 errno = map_errno_from_nt_status(status);
650 ret = SMB_VFS_NEXT_REALPATH(handle, mapped_name);
651 TALLOC_FREE(mapped_name);
656 static int catia_chflags(struct vfs_handle_struct *handle,
657 const char *path, unsigned int flags)
659 char *mapped_name = NULL;
663 status = catia_string_replace_allocate(handle->conn, path,
664 &mapped_name, vfs_translate_to_unix);
665 if (!NT_STATUS_IS_OK(status)) {
666 errno = map_errno_from_nt_status(status);
670 ret = SMB_VFS_NEXT_CHFLAGS(handle, mapped_name, flags);
671 TALLOC_FREE(mapped_name);
677 catia_streaminfo(struct vfs_handle_struct *handle,
678 struct files_struct *fsp,
681 unsigned int *num_streams,
682 struct stream_struct **streams)
684 char *mapped_name = NULL;
687 status = catia_string_replace_allocate(handle->conn, path,
688 &mapped_name, vfs_translate_to_unix);
689 if (!NT_STATUS_IS_OK(status)) {
690 errno = map_errno_from_nt_status(status);
694 status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, mapped_name,
695 mem_ctx, num_streams,streams);
696 TALLOC_FREE(mapped_name);
702 catia_get_nt_acl(struct vfs_handle_struct *handle,
704 uint32 security_info,
705 struct security_descriptor **ppdesc)
707 char *mapped_name = NULL;
710 status = catia_string_replace_allocate(handle->conn,
711 path, &mapped_name, vfs_translate_to_unix);
712 if (!NT_STATUS_IS_OK(status)) {
713 errno = map_errno_from_nt_status(status);
716 status = SMB_VFS_NEXT_GET_NT_ACL(handle, mapped_name,
717 security_info, ppdesc);
718 TALLOC_FREE(mapped_name);
724 catia_chmod_acl(vfs_handle_struct *handle,
728 char *mapped_name = NULL;
732 status = catia_string_replace_allocate(handle->conn,
733 path, &mapped_name, vfs_translate_to_unix);
734 if (!NT_STATUS_IS_OK(status)) {
735 errno = map_errno_from_nt_status(status);
739 ret = SMB_VFS_NEXT_CHMOD_ACL(handle, mapped_name, mode);
740 TALLOC_FREE(mapped_name);
745 catia_sys_acl_get_file(vfs_handle_struct *handle,
749 char *mapped_name = NULL;
753 status = catia_string_replace_allocate(handle->conn,
754 path, &mapped_name, vfs_translate_to_unix);
755 if (!NT_STATUS_IS_OK(status)) {
756 errno = map_errno_from_nt_status(status);
760 ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, mapped_name, type);
761 TALLOC_FREE(mapped_name);
767 catia_sys_acl_set_file(vfs_handle_struct *handle,
772 char *mapped_name = NULL;
776 status = catia_string_replace_allocate(handle->conn,
777 path, &mapped_name, vfs_translate_to_unix);
778 if (!NT_STATUS_IS_OK(status)) {
779 errno = map_errno_from_nt_status(status);
783 ret = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, mapped_name, type, theacl);
784 TALLOC_FREE(mapped_name);
790 catia_sys_acl_delete_def_file(vfs_handle_struct *handle,
793 char *mapped_name = NULL;
797 status = catia_string_replace_allocate(handle->conn,
798 path, &mapped_name, vfs_translate_to_unix);
799 if (!NT_STATUS_IS_OK(status)) {
800 errno = map_errno_from_nt_status(status);
804 ret = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, mapped_name);
805 TALLOC_FREE(mapped_name);
811 catia_getxattr(vfs_handle_struct *handle, const char *path,
812 const char *name, void *value, size_t size)
814 char *mapped_name = NULL;
818 status = catia_string_replace_allocate(handle->conn,
819 name, &mapped_name, vfs_translate_to_unix);
820 if (!NT_STATUS_IS_OK(status)) {
821 errno = map_errno_from_nt_status(status);
826 ret = SMB_VFS_NEXT_GETXATTR(handle, path, mapped_name, value, size);
827 TALLOC_FREE(mapped_name);
833 catia_lgetxattr(vfs_handle_struct *handle, const char *path,
834 const char *name, void *value, size_t size)
836 char *mapped_name = NULL;
840 status = catia_string_replace_allocate(handle->conn,
841 name, &mapped_name, vfs_translate_to_unix);
842 if (!NT_STATUS_IS_OK(status)) {
843 errno = map_errno_from_nt_status(status);
848 ret = SMB_VFS_NEXT_LGETXATTR(handle, path, mapped_name, value, size);
849 TALLOC_FREE(mapped_name);
855 catia_listxattr(vfs_handle_struct *handle, const char *path,
856 char *list, size_t size)
858 char *mapped_name = NULL;
862 status = catia_string_replace_allocate(handle->conn,
863 path, &mapped_name, vfs_translate_to_unix);
864 if (!NT_STATUS_IS_OK(status)) {
865 errno = map_errno_from_nt_status(status);
870 ret = SMB_VFS_NEXT_LISTXATTR(handle, mapped_name, list, size);
871 TALLOC_FREE(mapped_name);
877 catia_llistxattr(vfs_handle_struct *handle, const char *path,
878 char *list, size_t size)
880 char *mapped_name = NULL;
884 status = catia_string_replace_allocate(handle->conn,
885 path, &mapped_name, vfs_translate_to_unix);
886 if (!NT_STATUS_IS_OK(status)) {
887 errno = map_errno_from_nt_status(status);
892 ret = SMB_VFS_NEXT_LLISTXATTR(handle, mapped_name, list, size);
893 TALLOC_FREE(mapped_name);
899 catia_removexattr(vfs_handle_struct *handle, const char *path,
902 char *mapped_name = NULL;
906 status = catia_string_replace_allocate(handle->conn,
907 name, &mapped_name, vfs_translate_to_unix);
908 if (!NT_STATUS_IS_OK(status)) {
909 errno = map_errno_from_nt_status(status);
914 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, path, mapped_name);
915 TALLOC_FREE(mapped_name);
921 catia_lremovexattr(vfs_handle_struct *handle, const char *path,
924 char *mapped_name = NULL;
928 status = catia_string_replace_allocate(handle->conn,
929 name, &mapped_name, vfs_translate_to_unix);
930 if (!NT_STATUS_IS_OK(status)) {
931 errno = map_errno_from_nt_status(status);
936 ret = SMB_VFS_NEXT_LREMOVEXATTR(handle, path, mapped_name);
937 TALLOC_FREE(mapped_name);
943 catia_setxattr(vfs_handle_struct *handle, const char *path,
944 const char *name, const void *value, size_t size,
947 char *mapped_name = NULL;
951 status = catia_string_replace_allocate(handle->conn,
952 name, &mapped_name, vfs_translate_to_unix);
953 if (!NT_STATUS_IS_OK(status)) {
954 errno = map_errno_from_nt_status(status);
959 ret = SMB_VFS_NEXT_SETXATTR(handle, path, mapped_name, value, size, flags);
960 TALLOC_FREE(mapped_name);
966 catia_lsetxattr(vfs_handle_struct *handle, const char *path,
967 const char *name, const void *value, size_t size,
970 char *mapped_name = NULL;
974 status = catia_string_replace_allocate(handle->conn,
975 name, &mapped_name, vfs_translate_to_unix);
976 if (!NT_STATUS_IS_OK(status)) {
977 errno = map_errno_from_nt_status(status);
982 ret = SMB_VFS_NEXT_LSETXATTR(handle, path, mapped_name, value, size, flags);
983 TALLOC_FREE(mapped_name);
988 static struct vfs_fn_pointers vfs_catia_fns = {
989 .mkdir = catia_mkdir,
990 .rmdir = catia_rmdir,
991 .opendir = catia_opendir,
993 .rename = catia_rename,
995 .lstat = catia_lstat,
996 .unlink = catia_unlink,
997 .chown = catia_chown,
998 .lchown = catia_lchown,
999 .chdir = catia_chdir,
1000 .ntimes = catia_ntimes,
1001 .realpath = catia_realpath,
1002 .chflags = catia_chflags,
1003 .streaminfo = catia_streaminfo,
1004 .translate_name = catia_translate_name,
1005 .get_nt_acl = catia_get_nt_acl,
1006 .chmod_acl = catia_chmod_acl,
1007 .sys_acl_get_file = catia_sys_acl_get_file,
1008 .sys_acl_set_file = catia_sys_acl_set_file,
1009 .sys_acl_delete_def_file = catia_sys_acl_delete_def_file,
1010 .getxattr = catia_getxattr,
1011 .lgetxattr = catia_lgetxattr,
1012 .listxattr = catia_listxattr,
1013 .llistxattr = catia_llistxattr,
1014 .removexattr = catia_removexattr,
1015 .lremovexattr = catia_lremovexattr,
1016 .setxattr = catia_setxattr,
1017 .lsetxattr = catia_lsetxattr,
1020 NTSTATUS vfs_catia_init(void)
1022 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "catia",