s4-torture: allow host-only in unc lists in smbtorture
[ira/wip.git] / source3 / modules / vfs_catia.c
1 /*
2  * Catia VFS module
3  *
4  * Implement a fixed mapping of forbidden NT characters in filenames that are
5  * used a lot by the CAD package Catia.
6  *
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
9  * under Windows...
10  *
11  * Copyright (C) Volker Lendecke, 2005
12  * Copyright (C) Aravind Srinivasan, 2009
13  *
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.
18  *
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.
23  *
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/>.
26  */
27
28
29 #include "includes.h"
30
31 #define GLOBAL_SNUM     0xFFFFFFF
32 #define MAP_SIZE        0xFF
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))
37
38 struct char_mappings {
39         smb_ucs2_t entry[MAP_SIZE][2];
40 };
41
42 struct share_mapping_entry {
43         int snum;
44         struct share_mapping_entry *next;
45         struct char_mappings **mappings;
46 };
47
48 struct share_mapping_entry *srt_head = NULL;
49
50 static bool build_table(struct char_mappings **cmaps, int value)
51 {
52         int i;
53         int start = T_START(value);
54
55         (*cmaps) = talloc_zero(NULL, struct char_mappings);
56
57         if (!*cmaps)
58                 return False;
59
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;
63         }
64
65         return True;
66 }
67
68 static void set_tables(struct char_mappings **cmaps,
69                        long unix_map,
70                        long windows_map)
71 {
72         int i;
73
74         /* set unix -> windows */
75         i = T_OFFSET(unix_map);
76         cmaps[T_PICK(unix_map)]->entry[i][vfs_translate_to_windows] = windows_map;
77
78         /* set windows -> unix */
79         i = T_OFFSET(windows_map);
80         cmaps[T_PICK(windows_map)]->entry[i][vfs_translate_to_unix] = unix_map;
81 }
82
83 static bool build_ranges(struct char_mappings **cmaps,
84                          long unix_map,
85                          long windows_map)
86 {
87
88         if (!cmaps[T_PICK(unix_map)]) {
89                 if (!build_table(&cmaps[T_PICK(unix_map)], unix_map))
90                         return False;
91         }
92
93         if (!cmaps[T_PICK(windows_map)]) {
94                 if (!build_table(&cmaps[T_PICK(windows_map)], windows_map))
95                         return False;
96         }
97
98         set_tables(cmaps, unix_map, windows_map);
99
100         return True;
101 }
102
103 static struct share_mapping_entry *get_srt(connection_struct *conn,
104                                            struct share_mapping_entry **global)
105 {
106         struct share_mapping_entry *share;
107
108         for (share = srt_head; share != NULL; share = share->next) {
109                 if (share->snum == GLOBAL_SNUM)
110                         (*global) = share;
111
112                 if (share->snum == SNUM(conn))
113                         return share;
114         }
115
116         return share;
117 }
118
119 static struct share_mapping_entry *add_srt(int snum, const char **mappings)
120 {
121
122         char *tmp;
123         fstring mapping;
124         int i;
125         long unix_map, windows_map;
126         struct share_mapping_entry *ret = NULL;
127
128         ret = (struct share_mapping_entry *)
129                 TALLOC_ZERO(NULL, sizeof(struct share_mapping_entry) +
130                 (mappings ? (MAP_NUM * sizeof(struct char_mappings *)) : 0));
131
132         if (!ret)
133                 return ret;
134
135         ret->snum = snum;
136
137         if (mappings) {
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 *));
142         } else {
143                 ret->mappings = NULL;
144                 return ret;
145         }
146
147         /*
148          * catia mappings are of the form :
149          * UNIX char (in 0xnn hex) : WINDOWS char (in 0xnn hex)
150          *
151          * multiple mappings are comma seperated in smb.conf
152          */
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));
158                         continue;
159                 }
160                 windows_map = strtol(++tmp, NULL, 16);
161                 if (windows_map == 0 && errno == EINVAL) {
162                         DEBUG(0, ("INVALID CATIA MAPPINGS - %s\n", mapping));
163                         continue;
164                 }
165
166                 if (!build_ranges(ret->mappings, unix_map, windows_map)) {
167                         DEBUG(0, ("TABLE ERROR - CATIA MAPPINGS - %s\n", mapping));
168                         continue;
169                 }
170         }
171
172         ret->next = srt_head;
173         srt_head = ret;
174
175         return ret;
176 }
177
178 static bool init_mappings(connection_struct *conn,
179                           struct share_mapping_entry **selected_out)
180 {
181         const char **mappings = NULL;
182         struct share_mapping_entry *share_level = NULL;
183         struct share_mapping_entry *global = NULL;
184
185         /* check srt cache */
186         share_level = get_srt(conn, &global);
187         if (share_level) {
188                 *selected_out = share_level;
189                 return (share_level->mappings != NULL);
190         }
191
192         /* see if we have a global setting */
193         if (!global) {
194                 /* global setting */
195                 mappings = lp_parm_string_list(-1, "catia", "mappings", NULL);
196                 global = add_srt(GLOBAL_SNUM, mappings);
197         }
198
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);
202
203         if (share_level->mappings) {
204                 (*selected_out) = share_level;
205                 return True;
206         } else if (global->mappings) {
207                 share_level->mappings = global->mappings;
208                 (*selected_out) = share_level;
209                 return True;
210         }
211
212         return False;
213 }
214
215 static NTSTATUS catia_string_replace_allocate(connection_struct *conn,
216                                               const char *name_in,
217                                               char **mapped_name,
218                                               int direction)
219 {
220         static smb_ucs2_t *tmpbuf = NULL;
221         smb_ucs2_t *ptr;
222         struct share_mapping_entry *selected;
223         struct char_mappings *map = NULL;
224         size_t converted_size;
225         TALLOC_CTX *ctx = talloc_tos();
226
227         if (!init_mappings(conn, &selected)) {
228                 /* No mappings found. Just use the old name */
229                 *mapped_name = talloc_strdup(NULL, name_in);
230                 if (!*mapped_name) {
231                         errno = ENOMEM;
232                         return NT_STATUS_NO_MEMORY;
233                 }
234                 return NT_STATUS_OK;
235         }
236
237         if ((push_ucs2_talloc(ctx, &tmpbuf, name_in,
238                               &converted_size)) == -1) {
239                 return map_nt_error_from_unix(errno);
240         }
241         ptr = tmpbuf;
242         for(;*ptr;ptr++) {
243                 if (*ptr == 0)
244                         break;
245                 map = selected->mappings[T_PICK((*ptr))];
246
247                 /* nothing to do */
248                 if (!map)
249                         continue;
250
251                 *ptr = map->entry[T_OFFSET((*ptr))][direction];
252         }
253
254         if ((pull_ucs2_talloc(ctx, mapped_name, tmpbuf,
255                               &converted_size)) == -1) {
256                 TALLOC_FREE(tmpbuf);
257                 return map_nt_error_from_unix(errno);
258         }
259         TALLOC_FREE(tmpbuf);
260         return NT_STATUS_OK;
261 }
262
263 static SMB_STRUCT_DIR *catia_opendir(vfs_handle_struct *handle,
264                                      const char *fname,
265                                      const char *mask,
266                                      uint32 attr)
267 {
268         char *name_mapped = NULL;
269         NTSTATUS status;
270         SMB_STRUCT_DIR *ret;
271
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);
276                 return NULL;
277         }
278
279         ret = SMB_VFS_NEXT_OPENDIR(handle, name_mapped, mask, attr);
280         TALLOC_FREE(name_mapped);
281
282         return ret;
283 }
284
285 /*
286  * TRANSLATE_NAME call which converts the given name to
287  * "WINDOWS displayable" name
288  */
289 static NTSTATUS catia_translate_name(struct vfs_handle_struct *handle,
290                                      const char *orig_name,
291                                      enum vfs_translate_direction direction,
292                                      TALLOC_CTX *mem_ctx,
293                                      char **pmapped_name)
294 {
295         char *name = NULL;
296         char *mapped_name;
297         NTSTATUS ret;
298
299         /*
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
304          */
305         name = talloc_strdup(talloc_tos(), orig_name);
306         if (!name) {
307                 errno = ENOMEM;
308                 return NT_STATUS_NO_MEMORY;
309         }
310         ret = catia_string_replace_allocate(handle->conn, name,
311                         &mapped_name, direction);
312
313         TALLOC_FREE(name);
314         if (!NT_STATUS_IS_OK(ret)) {
315                 return ret;
316         }
317
318         ret = SMB_VFS_NEXT_TRANSLATE_NAME(handle, mapped_name, direction,
319                                           mem_ctx, pmapped_name);
320
321         if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
322                 *pmapped_name = talloc_move(mem_ctx, &mapped_name);
323         } else {
324                 TALLOC_FREE(mapped_name);
325         }
326
327         return ret;
328 }
329
330 static int catia_open(vfs_handle_struct *handle,
331                       struct smb_filename *smb_fname,
332                       files_struct *fsp,
333                       int flags,
334                       mode_t mode)
335 {
336         char *name_mapped = NULL;
337         char *tmp_base_name;
338         int ret;
339         NTSTATUS status;
340
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);
347                 return -1;
348         }
349
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);
354
355         return ret;
356 }
357
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)
361 {
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;
367         NTSTATUS status;
368         int ret = -1;
369
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);
375                 return -1;
376         }
377
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);
383                 return -1;
384         }
385
386         /* Setup temporary smb_filename structs. */
387         status = copy_smb_filename(ctx, smb_fname_src, &smb_fname_src_tmp);
388
389         if (!NT_STATUS_IS_OK(status)) {
390                 errno = map_errno_from_nt_status(status);
391                 goto out;
392         }
393
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);
397                 goto out;
398         }
399
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)));
406
407         ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
408                         smb_fname_dst_tmp);
409 out:
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);
414         return ret;
415 }
416
417 static int catia_stat(vfs_handle_struct *handle,
418                       struct smb_filename *smb_fname)
419 {
420         char *name = NULL;
421         char *tmp_base_name;
422         int ret;
423         NTSTATUS status;
424
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);
430                 return -1;
431         }
432
433         tmp_base_name = smb_fname->base_name;
434         smb_fname->base_name = name;
435
436         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
437         smb_fname->base_name = tmp_base_name;
438
439         TALLOC_FREE(name);
440         return ret;
441 }
442
443 static int catia_lstat(vfs_handle_struct *handle,
444                        struct smb_filename *smb_fname)
445 {
446         char *name = NULL;
447         char *tmp_base_name;
448         int ret;
449         NTSTATUS status;
450
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);
456                 return -1;
457         }
458
459         tmp_base_name = smb_fname->base_name;
460         smb_fname->base_name = name;
461
462         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
463         smb_fname->base_name = tmp_base_name;
464         TALLOC_FREE(name);
465
466         return ret;
467 }
468
469 static int catia_unlink(vfs_handle_struct *handle,
470                         const struct smb_filename *smb_fname)
471 {
472         struct smb_filename *smb_fname_tmp = NULL;
473         char *name = NULL;
474         NTSTATUS status;
475         int ret;
476
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);
482                 return -1;
483         }
484
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);
489                 return -1;
490         }
491
492         smb_fname_tmp->base_name = name;
493         ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
494         TALLOC_FREE(smb_fname_tmp);
495         TALLOC_FREE(name);
496
497         return ret;
498 }
499
500 static int catia_chown(vfs_handle_struct *handle,
501                        const char *path,
502                        uid_t uid,
503                        gid_t gid)
504 {
505         char *name = NULL;
506         NTSTATUS status;
507         int ret;
508
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);
513                 return -1;
514         }
515
516         ret = SMB_VFS_NEXT_CHOWN(handle, name, uid, gid);
517         TALLOC_FREE(name);
518
519         return ret;
520 }
521
522 static int catia_lchown(vfs_handle_struct *handle,
523                         const char *path,
524                         uid_t uid,
525                         gid_t gid)
526 {
527         char *name = NULL;
528         NTSTATUS status;
529         int ret;
530
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);
535                 return -1;
536         }
537
538         ret = SMB_VFS_NEXT_LCHOWN(handle, name, uid, gid);
539         TALLOC_FREE(name);
540
541         return ret;
542 }
543
544 static int catia_rmdir(vfs_handle_struct *handle,
545                        const char *path)
546 {
547         char *name = NULL;
548         NTSTATUS status;
549         int ret;
550
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);
555                 return -1;
556         }
557
558         ret = SMB_VFS_NEXT_RMDIR(handle, name);
559         TALLOC_FREE(name);
560
561         return ret;
562 }
563
564 static int catia_mkdir(vfs_handle_struct *handle,
565                        const char *path,
566                        mode_t mode)
567 {
568         char *name = NULL;
569         NTSTATUS status;
570         int ret;
571
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);
576                 return -1;
577         }
578
579         ret = SMB_VFS_NEXT_MKDIR(handle, name, mode);
580         TALLOC_FREE(name);
581
582         return ret;
583 }
584
585 static int catia_chdir(vfs_handle_struct *handle,
586                        const char *path)
587 {
588         char *name = NULL;
589         NTSTATUS status;
590         int ret;
591
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);
596                 return -1;
597         }
598
599         ret = SMB_VFS_NEXT_CHDIR(handle, name);
600         TALLOC_FREE(name);
601
602         return ret;
603 }
604
605 static int catia_ntimes(vfs_handle_struct *handle,
606                         const struct smb_filename *smb_fname,
607                         struct smb_file_time *ft)
608 {
609         struct smb_filename *smb_fname_tmp = NULL;
610         char *name = NULL;
611         NTSTATUS status;
612         int ret;
613
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);
619                 return -1;
620         }
621
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);
625                 return -1;
626         }
627
628         smb_fname_tmp->base_name = name;
629         ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname_tmp, ft);
630         TALLOC_FREE(name);
631         TALLOC_FREE(smb_fname_tmp);
632
633         return ret;
634 }
635
636 static char *
637 catia_realpath(vfs_handle_struct *handle, const char *path,
638                char *resolved_path)
639 {
640         char *mapped_name = NULL;
641         NTSTATUS status;
642         char *ret = NULL;
643
644         status = catia_string_replace_allocate(handle->conn, path,
645                                         &mapped_name, vfs_translate_to_unix);
646         if (!NT_STATUS_IS_OK(status)) {
647                 errno = map_errno_from_nt_status(status);
648                 return NULL;
649         }
650
651         ret = SMB_VFS_NEXT_REALPATH(handle, mapped_name, resolved_path);
652         TALLOC_FREE(mapped_name);
653
654         return ret;
655 }
656
657 static int catia_chflags(struct vfs_handle_struct *handle,
658                          const char *path, unsigned int flags)
659 {
660         char *mapped_name = NULL;
661         NTSTATUS status;
662         int ret;
663
664         status = catia_string_replace_allocate(handle->conn, path,
665                                         &mapped_name, vfs_translate_to_unix);
666         if (!NT_STATUS_IS_OK(status)) {
667                 errno = map_errno_from_nt_status(status);
668                 return -1;
669         }
670
671         ret = SMB_VFS_NEXT_CHFLAGS(handle, mapped_name, flags);
672         TALLOC_FREE(mapped_name);
673
674         return ret;
675 }
676
677 static NTSTATUS
678 catia_streaminfo(struct vfs_handle_struct *handle,
679                  struct files_struct *fsp,
680                  const char *path,
681                  TALLOC_CTX *mem_ctx,
682                  unsigned int *num_streams,
683                  struct stream_struct **streams)
684 {
685         char *mapped_name = NULL;
686         NTSTATUS status;
687
688         status = catia_string_replace_allocate(handle->conn, path,
689                                         &mapped_name, vfs_translate_to_unix);
690         if (!NT_STATUS_IS_OK(status)) {
691                 errno = map_errno_from_nt_status(status);
692                 return status;
693         }
694
695         status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, mapped_name,
696                                          mem_ctx, num_streams,streams);
697         TALLOC_FREE(mapped_name);
698
699         return status;
700 }
701
702 static NTSTATUS
703 catia_get_nt_acl(struct vfs_handle_struct *handle,
704                  const char *path,
705                  uint32 security_info,
706                  struct security_descriptor **ppdesc)
707 {
708         char *mapped_name = NULL;
709         NTSTATUS status;
710
711         status = catia_string_replace_allocate(handle->conn,
712                                 path, &mapped_name, vfs_translate_to_unix);
713         if (!NT_STATUS_IS_OK(status)) {
714                 errno = map_errno_from_nt_status(status);
715                 return status;
716         }
717         status = SMB_VFS_NEXT_GET_NT_ACL(handle, mapped_name,
718                                          security_info, ppdesc);
719         TALLOC_FREE(mapped_name);
720
721         return status;
722 }
723
724 static int
725 catia_chmod_acl(vfs_handle_struct *handle,
726                 const char *path,
727                 mode_t mode)
728 {
729         char *mapped_name = NULL;
730         NTSTATUS status;
731         int ret;
732
733         status = catia_string_replace_allocate(handle->conn,
734                                 path, &mapped_name, vfs_translate_to_unix);
735         if (!NT_STATUS_IS_OK(status)) {
736                 errno = map_errno_from_nt_status(status);
737                 return -1;
738         }
739
740         ret = SMB_VFS_NEXT_CHMOD_ACL(handle, mapped_name, mode);
741         TALLOC_FREE(mapped_name);
742         return ret;
743 }
744
745 static SMB_ACL_T
746 catia_sys_acl_get_file(vfs_handle_struct *handle,
747                        const char *path,
748                        SMB_ACL_TYPE_T type)
749 {
750         char *mapped_name = NULL;
751         NTSTATUS status;
752         SMB_ACL_T ret;
753
754         status = catia_string_replace_allocate(handle->conn,
755                                 path, &mapped_name, vfs_translate_to_unix);
756         if (!NT_STATUS_IS_OK(status)) {
757                 errno = map_errno_from_nt_status(status);
758                 return NULL;
759         }
760
761         ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, mapped_name, type);
762         TALLOC_FREE(mapped_name);
763
764         return ret;
765 }
766
767 static int
768 catia_sys_acl_set_file(vfs_handle_struct *handle,
769                        const char *path,
770                        SMB_ACL_TYPE_T type,
771                        SMB_ACL_T theacl)
772 {
773         char *mapped_name = NULL;
774         NTSTATUS status;
775         int ret;
776
777         status = catia_string_replace_allocate(handle->conn,
778                                 path, &mapped_name, vfs_translate_to_unix);
779         if (!NT_STATUS_IS_OK(status)) {
780                 errno = map_errno_from_nt_status(status);
781                 return -1;
782         }
783
784         ret = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, mapped_name, type, theacl);
785         TALLOC_FREE(mapped_name);
786
787         return ret;
788 }
789
790 static int
791 catia_sys_acl_delete_def_file(vfs_handle_struct *handle,
792                               const char *path)
793 {
794         char *mapped_name = NULL;
795         NTSTATUS status;
796         int ret;
797
798         status = catia_string_replace_allocate(handle->conn,
799                                 path, &mapped_name, vfs_translate_to_unix);
800         if (!NT_STATUS_IS_OK(status)) {
801                 errno = map_errno_from_nt_status(status);
802                 return -1;
803         }
804
805         ret = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, mapped_name);
806         TALLOC_FREE(mapped_name);
807
808         return ret;
809 }
810
811 static ssize_t
812 catia_getxattr(vfs_handle_struct *handle, const char *path,
813                const char *name, void *value, size_t size)
814 {
815         char *mapped_name = NULL;
816         NTSTATUS status;
817         ssize_t ret;
818
819         status = catia_string_replace_allocate(handle->conn,
820                                 name, &mapped_name, vfs_translate_to_unix);
821         if (!NT_STATUS_IS_OK(status)) {
822                 errno = map_errno_from_nt_status(status);
823                 return -1;
824         }
825
826
827         ret = SMB_VFS_NEXT_GETXATTR(handle, path, mapped_name, value, size);
828         TALLOC_FREE(mapped_name);
829
830         return ret;
831 }
832
833 static ssize_t
834 catia_lgetxattr(vfs_handle_struct *handle, const char *path,
835                 const char *name, void *value, size_t size)
836 {
837         char *mapped_name = NULL;
838         NTSTATUS status;
839         ssize_t ret;
840
841         status = catia_string_replace_allocate(handle->conn,
842                                 name, &mapped_name, vfs_translate_to_unix);
843         if (!NT_STATUS_IS_OK(status)) {
844                 errno = map_errno_from_nt_status(status);
845                 return -1;
846         }
847
848
849         ret = SMB_VFS_NEXT_LGETXATTR(handle, path, mapped_name, value, size);
850         TALLOC_FREE(mapped_name);
851
852         return ret;
853 }
854
855 static ssize_t
856 catia_listxattr(vfs_handle_struct *handle, const char *path,
857                 char *list, size_t size)
858 {
859         char *mapped_name = NULL;
860         NTSTATUS status;
861         ssize_t ret;
862
863         status = catia_string_replace_allocate(handle->conn,
864                                 path, &mapped_name, vfs_translate_to_unix);
865         if (!NT_STATUS_IS_OK(status)) {
866                 errno = map_errno_from_nt_status(status);
867                 return -1;
868         }
869
870
871         ret = SMB_VFS_NEXT_LISTXATTR(handle, mapped_name, list, size);
872         TALLOC_FREE(mapped_name);
873
874         return ret;
875 }
876
877 static ssize_t
878 catia_llistxattr(vfs_handle_struct *handle, const char *path,
879                  char *list, size_t size)
880 {
881         char *mapped_name = NULL;
882         NTSTATUS status;
883         ssize_t ret;
884
885         status = catia_string_replace_allocate(handle->conn,
886                                 path, &mapped_name, vfs_translate_to_unix);
887         if (!NT_STATUS_IS_OK(status)) {
888                 errno = map_errno_from_nt_status(status);
889                 return -1;
890         }
891
892
893         ret = SMB_VFS_NEXT_LLISTXATTR(handle, mapped_name, list, size);
894         TALLOC_FREE(mapped_name);
895
896         return ret;
897 }
898
899 static int
900 catia_removexattr(vfs_handle_struct *handle, const char *path,
901                   const char *name)
902 {
903         char *mapped_name = NULL;
904         NTSTATUS status;
905         ssize_t ret;
906
907         status = catia_string_replace_allocate(handle->conn,
908                                 name, &mapped_name, vfs_translate_to_unix);
909         if (!NT_STATUS_IS_OK(status)) {
910                 errno = map_errno_from_nt_status(status);
911                 return -1;
912         }
913
914
915         ret = SMB_VFS_NEXT_REMOVEXATTR(handle, path, mapped_name);
916         TALLOC_FREE(mapped_name);
917
918         return ret;
919 }
920
921 static int
922 catia_lremovexattr(vfs_handle_struct *handle, const char *path,
923                    const char *name)
924 {
925         char *mapped_name = NULL;
926         NTSTATUS status;
927         ssize_t ret;
928
929         status = catia_string_replace_allocate(handle->conn,
930                                 name, &mapped_name, vfs_translate_to_unix);
931         if (!NT_STATUS_IS_OK(status)) {
932                 errno = map_errno_from_nt_status(status);
933                 return -1;
934         }
935
936
937         ret = SMB_VFS_NEXT_LREMOVEXATTR(handle, path, mapped_name);
938         TALLOC_FREE(mapped_name);
939
940         return ret;
941 }
942
943 static int
944 catia_setxattr(vfs_handle_struct *handle, const char *path,
945                const char *name, const void *value, size_t size,
946                int flags)
947 {
948         char *mapped_name = NULL;
949         NTSTATUS status;
950         ssize_t ret;
951
952         status = catia_string_replace_allocate(handle->conn,
953                                 name, &mapped_name, vfs_translate_to_unix);
954         if (!NT_STATUS_IS_OK(status)) {
955                 errno = map_errno_from_nt_status(status);
956                 return -1;
957         }
958
959
960         ret = SMB_VFS_NEXT_SETXATTR(handle, path, mapped_name, value, size, flags);
961         TALLOC_FREE(mapped_name);
962
963         return ret;
964 }
965
966 static int
967 catia_lsetxattr(vfs_handle_struct *handle, const char *path,
968                 const char *name, const void *value, size_t size,
969                 int flags)
970 {
971         char *mapped_name = NULL;
972         NTSTATUS status;
973         ssize_t ret;
974
975         status = catia_string_replace_allocate(handle->conn,
976                                 name, &mapped_name, vfs_translate_to_unix);
977         if (!NT_STATUS_IS_OK(status)) {
978                 errno = map_errno_from_nt_status(status);
979                 return -1;
980         }
981
982
983         ret = SMB_VFS_NEXT_LSETXATTR(handle, path, mapped_name, value, size, flags);
984         TALLOC_FREE(mapped_name);
985
986         return ret;
987 }
988
989 static struct vfs_fn_pointers vfs_catia_fns = {
990         .mkdir = catia_mkdir,
991         .rmdir = catia_rmdir,
992         .opendir = catia_opendir,
993         .open = catia_open,
994         .rename = catia_rename,
995         .stat = catia_stat,
996         .lstat = catia_lstat,
997         .unlink = catia_unlink,
998         .chown = catia_chown,
999         .lchown = catia_lchown,
1000         .chdir = catia_chdir,
1001         .ntimes = catia_ntimes,
1002         .realpath = catia_realpath,
1003         .chflags = catia_chflags,
1004         .streaminfo = catia_streaminfo,
1005         .translate_name = catia_translate_name,
1006         .get_nt_acl = catia_get_nt_acl,
1007         .chmod_acl = catia_chmod_acl,
1008         .sys_acl_get_file = catia_sys_acl_get_file,
1009         .sys_acl_set_file = catia_sys_acl_set_file,
1010         .sys_acl_delete_def_file = catia_sys_acl_delete_def_file,
1011         .getxattr = catia_getxattr,
1012         .lgetxattr = catia_lgetxattr,
1013         .listxattr = catia_listxattr,
1014         .llistxattr = catia_llistxattr,
1015         .removexattr = catia_removexattr,
1016         .lremovexattr = catia_lremovexattr,
1017         .setxattr = catia_setxattr,
1018         .lsetxattr = catia_lsetxattr,
1019 };
1020
1021 NTSTATUS vfs_catia_init(void)
1022 {
1023         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "catia",
1024                                 &vfs_catia_fns);
1025 }