?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
selftest:Samba4: report when samba is started and ready
[Samba.git] / source3 / modules / vfs_catia.c
blobc362be764cc5bc41be30957b94a38a6b63e9e037
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 * Catia V4 on AIX uses characters like "<*$ a *lot*, all forbidden under
8 * Windows...
9 *
10 * Copyright (C) Volker Lendecke, 2005
11 * Copyright (C) Aravind Srinivasan, 2009
12 * Copyright (C) Guenter Kukkukk, 2013
13 * Copyright (C) Ralph Boehme, 2017
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 3 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see <http://www.gnu.org/licenses/>.
27 */
28
29
30 #include "includes.h"
31 #include "smbd/smbd.h"
32 #include "lib/util/tevent_unix.h"
33 #include "lib/util/tevent_ntstatus.h"
34 #include "string_replace.h"
35
36 static int vfs_catia_debug_level = DBGC_VFS;
37
38 #undef DBGC_CLASS
39 #define DBGC_CLASS vfs_catia_debug_level
40
41 struct share_mapping_entry {
42 int snum;
43 struct share_mapping_entry *next;
44 struct char_mappings **mappings;
45 };
46
47 struct catia_cache {
48 bool is_fsp_ext;
49 const struct catia_cache * const *busy;
50 char *orig_fname;
51 char *fname;
52 char *orig_base_fname;
53 char *base_fname;
54 };
55
56 static struct share_mapping_entry *srt_head = NULL;
57
58 static struct share_mapping_entry *get_srt(connection_struct *conn,
59 struct share_mapping_entry **global)
60 {
61 struct share_mapping_entry *share;
62
63 for (share = srt_head; share != NULL; share = share->next) {
64 if (share->snum == GLOBAL_SECTION_SNUM)
65 (*global) = share;
66
67 if (share->snum == SNUM(conn))
68 return share;
69 }
70
71 return share;
72 }
73
74 static struct share_mapping_entry *add_srt(int snum, const char **mappings)
75 {
76 struct share_mapping_entry *sme = NULL;
77
78 sme = TALLOC_ZERO(NULL, sizeof(struct share_mapping_entry));
79 if (sme == NULL)
80 return sme;
81
82 sme->snum = snum;
83 sme->next = srt_head;
84 srt_head = sme;
85
86 if (mappings == NULL) {
87 sme->mappings = NULL;
88 return sme;
89 }
90
91 sme->mappings = string_replace_init_map(mappings);
92
93 return sme;
94 }
95
96 static bool init_mappings(connection_struct *conn,
97 struct share_mapping_entry **selected_out)
98 {
99 const char **mappings = NULL;
100 struct share_mapping_entry *share_level = NULL;
101 struct share_mapping_entry *global = NULL;
102
103 /* check srt cache */
104 share_level = get_srt(conn, &global);
105 if (share_level) {
106 *selected_out = share_level;
107 return (share_level->mappings != NULL);
108 }
109
110 /* see if we have a global setting */
111 if (!global) {
112 /* global setting */
113 mappings = lp_parm_string_list(-1, "catia", "mappings", NULL);
114 global = add_srt(GLOBAL_SECTION_SNUM, mappings);
115 }
116
117 /* no global setting - what about share level ? */
118 mappings = lp_parm_string_list(SNUM(conn), "catia", "mappings", NULL);
119 share_level = add_srt(SNUM(conn), mappings);
120
121 if (share_level->mappings) {
122 (*selected_out) = share_level;
123 return True;
124 }
125 if (global->mappings) {
126 share_level->mappings = global->mappings;
127 (*selected_out) = share_level;
128 return True;
129 }
130
131 return False;
132 }
133
134 static NTSTATUS catia_string_replace_allocate(connection_struct *conn,
135 const char *name_in,
136 char **mapped_name,
137 enum vfs_translate_direction direction)
138 {
139 struct share_mapping_entry *selected;
140 NTSTATUS status;
141
142 if (!init_mappings(conn, &selected)) {
143 /* No mappings found. Just use the old name */
144 *mapped_name = talloc_strdup(talloc_tos(), name_in);
145 if (!*mapped_name) {
146 errno = ENOMEM;
147 return NT_STATUS_NO_MEMORY;
148 }
149 return NT_STATUS_OK;
150 }
151
152 status = string_replace_allocate(conn,
153 name_in,
154 selected->mappings,
155 talloc_tos(),
156 mapped_name,
157 direction);
158 return status;
159 }
160
161 static int catia_connect(struct vfs_handle_struct *handle,
162 const char *service,
163 const char *user)
164 {
165 /*
166 * Unless we have an async implementation of get_dos_attributes turn
167 * this off.
168 */
169 lp_do_parameter(SNUM(handle->conn), "smbd:async dosmode", "false");
170
171 return SMB_VFS_NEXT_CONNECT(handle, service, user);
172 }
173
174 static DIR *catia_opendir(vfs_handle_struct *handle,
175 const struct smb_filename *smb_fname,
176 const char *mask,
177 uint32_t attr)
178 {
179 char *name_mapped = NULL;
180 NTSTATUS status;
181 DIR *ret;
182 struct smb_filename *mapped_smb_fname = NULL;
183
184 status = catia_string_replace_allocate(handle->conn,
185 smb_fname->base_name,
186 &name_mapped,
187 vfs_translate_to_unix);
188 if (!NT_STATUS_IS_OK(status)) {
189 errno = map_errno_from_nt_status(status);
190 return NULL;
191 }
192
193 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
194 name_mapped,
195 NULL,
196 NULL,
197 smb_fname->flags);
198 if (mapped_smb_fname == NULL) {
199 TALLOC_FREE(mapped_smb_fname);
200 errno = ENOMEM;
201 return NULL;
202 }
203
204 ret = SMB_VFS_NEXT_OPENDIR(handle, mapped_smb_fname, mask, attr);
205
206 TALLOC_FREE(name_mapped);
207 TALLOC_FREE(mapped_smb_fname);
208
209 return ret;
210 }
211
212 /*
213 * TRANSLATE_NAME call which converts the given name to
214 * "WINDOWS displayable" name
215 */
216 static NTSTATUS catia_translate_name(struct vfs_handle_struct *handle,
217 const char *orig_name,
218 enum vfs_translate_direction direction,
219 TALLOC_CTX *mem_ctx,
220 char **pmapped_name)
221 {
222 char *name = NULL;
223 char *mapped_name;
224 NTSTATUS status, ret;
225
226 /*
227 * Copy the supplied name and free the memory for mapped_name,
228 * already allocated by the caller.
229 * We will be allocating new memory for mapped_name in
230 * catia_string_replace_allocate
231 */
232 name = talloc_strdup(talloc_tos(), orig_name);
233 if (!name) {
234 errno = ENOMEM;
235 return NT_STATUS_NO_MEMORY;
236 }
237 status = catia_string_replace_allocate(handle->conn, name,
238 &mapped_name, direction);
239
240 TALLOC_FREE(name);
241 if (!NT_STATUS_IS_OK(status)) {
242 return status;
243 }
244
245 ret = SMB_VFS_NEXT_TRANSLATE_NAME(handle, mapped_name, direction,
246 mem_ctx, pmapped_name);
247
248 if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
249 *pmapped_name = talloc_move(mem_ctx, &mapped_name);
250 /* we need to return the former translation result here */
251 ret = status;
252 } else {
253 TALLOC_FREE(mapped_name);
254 }
255
256 return ret;
257 }
258
259 #define CATIA_DEBUG_CC(lvl, cc, fsp) \
260 catia_debug_cc((lvl), (cc), (fsp), __location__);
261
262 static void catia_debug_cc(int lvl,
263 struct catia_cache *cc,
264 files_struct *fsp,
265 const char *location)
266 {
267 DEBUG(lvl, ("%s: cc [%p] cc->busy [%p] "
268 "is_fsp_ext [%s] "
269 "fsp [%p] fsp name [%s] "
270 "orig_fname [%s] "
271 "fname [%s] "
272 "orig_base_fname [%s] "
273 "base_fname [%s]\n",
274 location,
275 cc, cc->busy,
276 cc->is_fsp_ext ? "yes" : "no",
277 fsp, fsp_str_dbg(fsp),
278 cc->orig_fname, cc->fname,
279 cc->orig_base_fname, cc->base_fname));
280 }
281
282 static void catia_free_cc(struct catia_cache **_cc,
283 vfs_handle_struct *handle,
284 files_struct *fsp)
285 {
286 struct catia_cache *cc = *_cc;
287
288 if (cc->is_fsp_ext) {
289 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
290 cc = NULL;
291 } else {
292 TALLOC_FREE(cc);
293 }
294
295 *_cc = NULL;
296 }
297
298 static struct catia_cache *catia_validate_and_apply_cc(
299 vfs_handle_struct *handle,
300 files_struct *fsp,
301 const struct catia_cache * const *busy,
302 bool *make_tmp_cache)
303 {
304 struct catia_cache *cc = NULL;
305
306 *make_tmp_cache = false;
307
308 cc = (struct catia_cache *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
309 if (cc == NULL) {
310 return NULL;
311 }
312
313 if (cc->busy != NULL) {
314 if (cc->busy == busy) {
315 /* This should never happen */
316 CATIA_DEBUG_CC(0, cc, fsp);
317 smb_panic(__location__);
318 }
319
320 /*
321 * Recursion. Validate names, the names in the fsp's should be
322 * the translated names we had set.
323 */
324
325 if ((cc->fname != fsp->fsp_name->base_name)
326 ||
327 ((fsp->base_fsp != NULL) &&
328 (cc->base_fname != fsp->base_fsp->fsp_name->base_name)))
329 {
330 CATIA_DEBUG_CC(10, cc, fsp);
331
332 /*
333 * Names changed. Setting don't expose the cache on the
334 * fsp and ask the caller to create a temporary cache.
335 */
336 *make_tmp_cache = true;
337 return NULL;
338 }
339
340 /*
341 * Ok, a validated cache while in a recursion, just let the
342 * caller detect that cc->busy is != busy and there's
343 * nothing else to do.
344 */
345 CATIA_DEBUG_CC(10, cc, fsp);
346 return cc;
347 }
348
349 /* Not in a recursion */
350
351 if ((cc->orig_fname != fsp->fsp_name->base_name)
352 ||
353 ((fsp->base_fsp != NULL) &&
354 (cc->orig_base_fname != fsp->base_fsp->fsp_name->base_name)))
355 {
356 /*
357 * fsp names changed, this can happen in an rename op.
358 * Trigger recreation as a full fledged fsp extension.
359 */
360
361 CATIA_DEBUG_CC(10, cc, fsp);
362 catia_free_cc(&cc, handle, fsp);
363 return NULL;
364 }
365
366
367 /*
368 * Ok, we found a valid cache entry, no recursion. Just set translated
369 * names from the cache and mark the cc as busy.
370 */
371 fsp->fsp_name->base_name = cc->fname;
372 if (fsp->base_fsp != NULL) {
373 fsp->base_fsp->fsp_name->base_name = cc->base_fname;
374 }
375
376 cc->busy = busy;
377 CATIA_DEBUG_CC(10, cc, fsp);
378 return cc;
379 }
380
381 #define CATIA_FETCH_FSP_PRE_NEXT(mem_ctx, handle, fsp, _cc) \
382 catia_fetch_fsp_pre_next((mem_ctx), (handle), (fsp), (_cc), __func__);
383
384 static int catia_fetch_fsp_pre_next(TALLOC_CTX *mem_ctx,
385 vfs_handle_struct *handle,
386 files_struct *fsp,
387 struct catia_cache **_cc,
388 const char *function)
389 {
390 const struct catia_cache * const *busy =
391 (const struct catia_cache * const *)_cc;
392 struct catia_cache *cc = NULL;
393 NTSTATUS status;
394 bool make_tmp_cache = false;
395
396 *_cc = NULL;
397
398 DBG_DEBUG("Called from [%s]\n", function);
399
400 cc = catia_validate_and_apply_cc(handle,
401 fsp,
402 busy,
403 &make_tmp_cache);
404 if (cc != NULL) {
405 if (cc->busy != busy) {
406 return 0;
407 }
408 *_cc = cc;
409 return 0;
410 }
411
412 if (!make_tmp_cache) {
413 cc = VFS_ADD_FSP_EXTENSION(
414 handle, fsp, struct catia_cache, NULL);
415 if (cc == NULL) {
416 return -1;
417 }
418 *cc = (struct catia_cache) {
419 .is_fsp_ext = true,
420 };
421
422 mem_ctx = VFS_MEMCTX_FSP_EXTENSION(handle, fsp);
423 if (mem_ctx == NULL) {
424 DBG_ERR("VFS_MEMCTX_FSP_EXTENSION failed\n");
425 catia_free_cc(&cc, handle, fsp);
426 return -1;
427 }
428 } else {
429 cc = talloc_zero(mem_ctx, struct catia_cache);
430 if (cc == NULL) {
431 return -1;
432 }
433 mem_ctx = cc;
434 }
435
436
437 status = catia_string_replace_allocate(handle->conn,
438 fsp->fsp_name->base_name,
439 &cc->fname,
440 vfs_translate_to_unix);
441 if (!NT_STATUS_IS_OK(status)) {
442 catia_free_cc(&cc, handle, fsp);
443 errno = map_errno_from_nt_status(status);
444 return -1;
445 }
446 talloc_steal(mem_ctx, cc->fname);
447
448 if (fsp->base_fsp != NULL) {
449 status = catia_string_replace_allocate(
450 handle->conn,
451 fsp->base_fsp->fsp_name->base_name,
452 &cc->base_fname,
453 vfs_translate_to_unix);
454 if (!NT_STATUS_IS_OK(status)) {
455 catia_free_cc(&cc, handle, fsp);
456 errno = map_errno_from_nt_status(status);
457 return -1;
458 }
459 talloc_steal(mem_ctx, cc->base_fname);
460 }
461
462 cc->orig_fname = fsp->fsp_name->base_name;
463 fsp->fsp_name->base_name = cc->fname;
464
465 if (fsp->base_fsp != NULL) {
466 cc->orig_base_fname = fsp->base_fsp->fsp_name->base_name;
467 fsp->base_fsp->fsp_name->base_name = cc->base_fname;
468 }
469
470 cc->busy = busy;
471 CATIA_DEBUG_CC(10, cc, fsp);
472
473 *_cc = cc;
474
475 return 0;
476 }
477
478 #define CATIA_FETCH_FSP_POST_NEXT(_cc, fsp) do { \
479 int saved_errno = errno; \
480 catia_fetch_fsp_post_next((_cc), (fsp), __func__); \
481 errno = saved_errno; \
482 } while(0)
483
484 static void catia_fetch_fsp_post_next(struct catia_cache **_cc,
485 files_struct *fsp,
486 const char *function)
487 {
488 const struct catia_cache * const *busy =
489 (const struct catia_cache * const *)_cc;
490 struct catia_cache *cc = *_cc;
491
492 DBG_DEBUG("Called from [%s]\n", function);
493
494 if (cc == NULL) {
495 /*
496 * This can happen when recursing in the VFS on the fsp when the
497 * pre_next func noticed the recursion and set out cc pointer to
498 * NULL.
499 */
500 return;
501 }
502
503 if (cc->busy != busy) {
504 CATIA_DEBUG_CC(0, cc, fsp);
505 smb_panic(__location__);
506 return;
507 }
508
509 cc->busy = NULL;
510 *_cc = NULL;
511
512 fsp->fsp_name->base_name = cc->orig_fname;
513 if (fsp->base_fsp != NULL) {
514 fsp->base_fsp->fsp_name->base_name = cc->orig_base_fname;
515 }
516
517 CATIA_DEBUG_CC(10, cc, fsp);
518
519 if (!cc->is_fsp_ext) {
520 TALLOC_FREE(cc);
521 }
522
523 return;
524 }
525
526 static int catia_open(vfs_handle_struct *handle,
527 struct smb_filename *smb_fname,
528 files_struct *fsp,
529 int flags,
530 mode_t mode)
531 {
532 struct catia_cache *cc = NULL;
533 char *orig_smb_fname = smb_fname->base_name;
534 char *mapped_smb_fname = NULL;
535 NTSTATUS status;
536 int ret;
537
538 status = catia_string_replace_allocate(handle->conn,
539 smb_fname->base_name,
540 &mapped_smb_fname,
541 vfs_translate_to_unix);
542 if (!NT_STATUS_IS_OK(status)) {
543 return -1;
544 }
545
546 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
547 if (ret != 0) {
548 TALLOC_FREE(mapped_smb_fname);
549 return ret;
550 }
551
552 smb_fname->base_name = mapped_smb_fname;
553 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
554 smb_fname->base_name = orig_smb_fname;
555
556 TALLOC_FREE(mapped_smb_fname);
557 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
558
559 return ret;
560 }
561
562 static int catia_rename(vfs_handle_struct *handle,
563 const struct smb_filename *smb_fname_src,
564 const struct smb_filename *smb_fname_dst)
565 {
566 TALLOC_CTX *ctx = talloc_tos();
567 struct smb_filename *smb_fname_src_tmp = NULL;
568 struct smb_filename *smb_fname_dst_tmp = NULL;
569 char *src_name_mapped = NULL;
570 char *dst_name_mapped = NULL;
571 NTSTATUS status;
572 int ret = -1;
573
574 status = catia_string_replace_allocate(handle->conn,
575 smb_fname_src->base_name,
576 &src_name_mapped, vfs_translate_to_unix);
577 if (!NT_STATUS_IS_OK(status)) {
578 errno = map_errno_from_nt_status(status);
579 return -1;
580 }
581
582 status = catia_string_replace_allocate(handle->conn,
583 smb_fname_dst->base_name,
584 &dst_name_mapped, vfs_translate_to_unix);
585 if (!NT_STATUS_IS_OK(status)) {
586 errno = map_errno_from_nt_status(status);
587 return -1;
588 }
589
590 /* Setup temporary smb_filename structs. */
591 smb_fname_src_tmp = cp_smb_filename(ctx, smb_fname_src);
592 if (smb_fname_src_tmp == NULL) {
593 errno = ENOMEM;
594 goto out;
595 }
596
597 smb_fname_dst_tmp = cp_smb_filename(ctx, smb_fname_dst);
598 if (smb_fname_dst_tmp == NULL) {
599 errno = ENOMEM;
600 goto out;
601 }
602
603 smb_fname_src_tmp->base_name = src_name_mapped;
604 smb_fname_dst_tmp->base_name = dst_name_mapped;
605 DEBUG(10, ("converted old name: %s\n",
606 smb_fname_str_dbg(smb_fname_src_tmp)));
607 DEBUG(10, ("converted new name: %s\n",
608 smb_fname_str_dbg(smb_fname_dst_tmp)));
609
610 ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
611 smb_fname_dst_tmp);
612 out:
613 TALLOC_FREE(src_name_mapped);
614 TALLOC_FREE(dst_name_mapped);
615 TALLOC_FREE(smb_fname_src_tmp);
616 TALLOC_FREE(smb_fname_dst_tmp);
617 return ret;
618 }
619
620 static int catia_stat(vfs_handle_struct *handle,
621 struct smb_filename *smb_fname)
622 {
623 char *name = NULL;
624 char *tmp_base_name;
625 int ret;
626 NTSTATUS status;
627
628 status = catia_string_replace_allocate(handle->conn,
629 smb_fname->base_name,
630 &name, vfs_translate_to_unix);
631 if (!NT_STATUS_IS_OK(status)) {
632 errno = map_errno_from_nt_status(status);
633 return -1;
634 }
635
636 tmp_base_name = smb_fname->base_name;
637 smb_fname->base_name = name;
638
639 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
640 smb_fname->base_name = tmp_base_name;
641
642 TALLOC_FREE(name);
643 return ret;
644 }
645
646 static int catia_lstat(vfs_handle_struct *handle,
647 struct smb_filename *smb_fname)
648 {
649 char *name = NULL;
650 char *tmp_base_name;
651 int ret;
652 NTSTATUS status;
653
654 status = catia_string_replace_allocate(handle->conn,
655 smb_fname->base_name,
656 &name, vfs_translate_to_unix);
657 if (!NT_STATUS_IS_OK(status)) {
658 errno = map_errno_from_nt_status(status);
659 return -1;
660 }
661
662 tmp_base_name = smb_fname->base_name;
663 smb_fname->base_name = name;
664
665 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
666 smb_fname->base_name = tmp_base_name;
667 TALLOC_FREE(name);
668
669 return ret;
670 }
671
672 static int catia_unlink(vfs_handle_struct *handle,
673 const struct smb_filename *smb_fname)
674 {
675 struct smb_filename *smb_fname_tmp = NULL;
676 char *name = NULL;
677 NTSTATUS status;
678 int ret;
679
680 status = catia_string_replace_allocate(handle->conn,
681 smb_fname->base_name,
682 &name, vfs_translate_to_unix);
683 if (!NT_STATUS_IS_OK(status)) {
684 errno = map_errno_from_nt_status(status);
685 return -1;
686 }
687
688 /* Setup temporary smb_filename structs. */
689 smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
690 if (smb_fname_tmp == NULL) {
691 errno = ENOMEM;
692 return -1;
693 }
694
695 smb_fname_tmp->base_name = name;
696 ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
697 TALLOC_FREE(smb_fname_tmp);
698 TALLOC_FREE(name);
699
700 return ret;
701 }
702
703 static int catia_chown(vfs_handle_struct *handle,
704 const struct smb_filename *smb_fname,
705 uid_t uid,
706 gid_t gid)
707 {
708 char *name = NULL;
709 NTSTATUS status;
710 int ret;
711 int saved_errno;
712 struct smb_filename *catia_smb_fname = NULL;
713
714 status = catia_string_replace_allocate(handle->conn,
715 smb_fname->base_name,
716 &name,
717 vfs_translate_to_unix);
718 if (!NT_STATUS_IS_OK(status)) {
719 errno = map_errno_from_nt_status(status);
720 return -1;
721 }
722 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
723 name,
724 NULL,
725 NULL,
726 smb_fname->flags);
727 if (catia_smb_fname == NULL) {
728 TALLOC_FREE(name);
729 errno = ENOMEM;
730 return -1;
731 }
732
733 ret = SMB_VFS_NEXT_CHOWN(handle, catia_smb_fname, uid, gid);
734 saved_errno = errno;
735 TALLOC_FREE(name);
736 TALLOC_FREE(catia_smb_fname);
737 errno = saved_errno;
738 return ret;
739 }
740
741 static int catia_lchown(vfs_handle_struct *handle,
742 const struct smb_filename *smb_fname,
743 uid_t uid,
744 gid_t gid)
745 {
746 char *name = NULL;
747 NTSTATUS status;
748 int ret;
749 int saved_errno;
750 struct smb_filename *catia_smb_fname = NULL;
751
752 status = catia_string_replace_allocate(handle->conn,
753 smb_fname->base_name,
754 &name,
755 vfs_translate_to_unix);
756 if (!NT_STATUS_IS_OK(status)) {
757 errno = map_errno_from_nt_status(status);
758 return -1;
759 }
760 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
761 name,
762 NULL,
763 NULL,
764 smb_fname->flags);
765 if (catia_smb_fname == NULL) {
766 TALLOC_FREE(name);
767 errno = ENOMEM;
768 return -1;
769 }
770
771 ret = SMB_VFS_NEXT_LCHOWN(handle, catia_smb_fname, uid, gid);
772 saved_errno = errno;
773 TALLOC_FREE(name);
774 TALLOC_FREE(catia_smb_fname);
775 errno = saved_errno;
776 return ret;
777 }
778
779 static int catia_chmod(vfs_handle_struct *handle,
780 const struct smb_filename *smb_fname,
781 mode_t mode)
782 {
783 char *name = NULL;
784 NTSTATUS status;
785 int ret;
786 int saved_errno;
787 struct smb_filename *catia_smb_fname = NULL;
788
789 status = catia_string_replace_allocate(handle->conn,
790 smb_fname->base_name,
791 &name,
792 vfs_translate_to_unix);
793 if (!NT_STATUS_IS_OK(status)) {
794 errno = map_errno_from_nt_status(status);
795 return -1;
796 }
797 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
798 name,
799 NULL,
800 NULL,
801 smb_fname->flags);
802 if (catia_smb_fname == NULL) {
803 TALLOC_FREE(name);
804 errno = ENOMEM;
805 return -1;
806 }
807
808 ret = SMB_VFS_NEXT_CHMOD(handle, catia_smb_fname, mode);
809 saved_errno = errno;
810 TALLOC_FREE(name);
811 TALLOC_FREE(catia_smb_fname);
812 errno = saved_errno;
813 return ret;
814 }
815
816 static int catia_rmdir(vfs_handle_struct *handle,
817 const struct smb_filename *smb_fname)
818 {
819 char *name = NULL;
820 NTSTATUS status;
821 int ret;
822 struct smb_filename *catia_smb_fname = NULL;
823
824 status = catia_string_replace_allocate(handle->conn,
825 smb_fname->base_name,
826 &name,
827 vfs_translate_to_unix);
828 if (!NT_STATUS_IS_OK(status)) {
829 errno = map_errno_from_nt_status(status);
830 return -1;
831 }
832 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
833 name,
834 NULL,
835 NULL,
836 smb_fname->flags);
837 if (catia_smb_fname == NULL) {
838 TALLOC_FREE(name);
839 errno = ENOMEM;
840 return -1;
841 }
842
843 ret = SMB_VFS_NEXT_RMDIR(handle, catia_smb_fname);
844 TALLOC_FREE(name);
845 TALLOC_FREE(catia_smb_fname);
846
847 return ret;
848 }
849
850 static int catia_mkdir(vfs_handle_struct *handle,
851 const struct smb_filename *smb_fname,
852 mode_t mode)
853 {
854 char *name = NULL;
855 NTSTATUS status;
856 int ret;
857 struct smb_filename *catia_smb_fname = NULL;
858
859 status = catia_string_replace_allocate(handle->conn,
860 smb_fname->base_name,
861 &name,
862 vfs_translate_to_unix);
863 if (!NT_STATUS_IS_OK(status)) {
864 errno = map_errno_from_nt_status(status);
865 return -1;
866 }
867 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
868 name,
869 NULL,
870 NULL,
871 smb_fname->flags);
872 if (catia_smb_fname == NULL) {
873 TALLOC_FREE(name);
874 errno = ENOMEM;
875 return -1;
876 }
877
878 ret = SMB_VFS_NEXT_MKDIR(handle, catia_smb_fname, mode);
879 TALLOC_FREE(name);
880 TALLOC_FREE(catia_smb_fname);
881
882 return ret;
883 }
884
885 static int catia_chdir(vfs_handle_struct *handle,
886 const struct smb_filename *smb_fname)
887 {
888 char *name = NULL;
889 struct smb_filename *catia_smb_fname = NULL;
890 NTSTATUS status;
891 int ret;
892
893 status = catia_string_replace_allocate(handle->conn,
894 smb_fname->base_name,
895 &name,
896 vfs_translate_to_unix);
897 if (!NT_STATUS_IS_OK(status)) {
898 errno = map_errno_from_nt_status(status);
899 return -1;
900 }
901
902 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
903 name,
904 NULL,
905 NULL,
906 smb_fname->flags);
907 if (catia_smb_fname == NULL) {
908 TALLOC_FREE(name);
909 errno = ENOMEM;
910 return -1;
911 }
912 ret = SMB_VFS_NEXT_CHDIR(handle, catia_smb_fname);
913 TALLOC_FREE(name);
914 TALLOC_FREE(catia_smb_fname);
915
916 return ret;
917 }
918
919 static int catia_ntimes(vfs_handle_struct *handle,
920 const struct smb_filename *smb_fname,
921 struct smb_file_time *ft)
922 {
923 struct smb_filename *smb_fname_tmp = NULL;
924 char *name = NULL;
925 NTSTATUS status;
926 int ret;
927
928 status = catia_string_replace_allocate(handle->conn,
929 smb_fname->base_name,
930 &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 smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
937 if (smb_fname_tmp == NULL) {
938 errno = ENOMEM;
939 return -1;
940 }
941
942 smb_fname_tmp->base_name = name;
943 ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname_tmp, ft);
944 TALLOC_FREE(name);
945 TALLOC_FREE(smb_fname_tmp);
946
947 return ret;
948 }
949
950 static struct smb_filename *
951 catia_realpath(vfs_handle_struct *handle,
952 TALLOC_CTX *ctx,
953 const struct smb_filename *smb_fname)
954 {
955 char *mapped_name = NULL;
956 struct smb_filename *catia_smb_fname = NULL;
957 struct smb_filename *return_fname = NULL;
958 NTSTATUS status;
959
960 status = catia_string_replace_allocate(handle->conn,
961 smb_fname->base_name,
962 &mapped_name, vfs_translate_to_unix);
963 if (!NT_STATUS_IS_OK(status)) {
964 errno = map_errno_from_nt_status(status);
965 return NULL;
966 }
967
968 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
969 mapped_name,
970 NULL,
971 NULL,
972 smb_fname->flags);
973 if (catia_smb_fname == NULL) {
974 TALLOC_FREE(mapped_name);
975 errno = ENOMEM;
976 return NULL;
977 }
978 return_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, catia_smb_fname);
979 TALLOC_FREE(mapped_name);
980 TALLOC_FREE(catia_smb_fname);
981 return return_fname;
982 }
983
984 static int catia_chflags(struct vfs_handle_struct *handle,
985 const struct smb_filename *smb_fname,
986 unsigned int flags)
987 {
988 char *name = NULL;
989 struct smb_filename *catia_smb_fname = NULL;
990 NTSTATUS status;
991 int ret;
992
993 status = catia_string_replace_allocate(handle->conn,
994 smb_fname->base_name,
995 &name,
996 vfs_translate_to_unix);
997 if (!NT_STATUS_IS_OK(status)) {
998 errno = map_errno_from_nt_status(status);
999 return -1;
1000 }
1001 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
1002 name,
1003 NULL,
1004 NULL,
1005 smb_fname->flags);
1006 if (catia_smb_fname == NULL) {
1007 TALLOC_FREE(name);
1008 errno = ENOMEM;
1009 return -1;
1010 }
1011
1012 ret = SMB_VFS_NEXT_CHFLAGS(handle, catia_smb_fname, flags);
1013 TALLOC_FREE(name);
1014 TALLOC_FREE(catia_smb_fname);
1015
1016 return ret;
1017 }
1018
1019 static NTSTATUS
1020 catia_streaminfo(struct vfs_handle_struct *handle,
1021 struct files_struct *fsp,
1022 const struct smb_filename *smb_fname,
1023 TALLOC_CTX *mem_ctx,
1024 unsigned int *_num_streams,
1025 struct stream_struct **_streams)
1026 {
1027 char *mapped_name = NULL;
1028 NTSTATUS status;
1029 unsigned int i;
1030 struct smb_filename *catia_smb_fname = NULL;
1031 unsigned int num_streams = 0;
1032 struct stream_struct *streams = NULL;
1033
1034 *_num_streams = 0;
1035 *_streams = NULL;
1036
1037 status = catia_string_replace_allocate(handle->conn,
1038 smb_fname->base_name,
1039 &mapped_name,
1040 vfs_translate_to_unix);
1041 if (!NT_STATUS_IS_OK(status)) {
1042 errno = map_errno_from_nt_status(status);
1043 return status;
1044 }
1045
1046 catia_smb_fname = synthetic_smb_fname(talloc_tos(),
1047 mapped_name,
1048 NULL,
1049 NULL,
1050 smb_fname->flags);
1051 if (catia_smb_fname == NULL) {
1052 TALLOC_FREE(mapped_name);
1053 return NT_STATUS_NO_MEMORY;
1054 }
1055
1056 status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, catia_smb_fname,
1057 mem_ctx, &num_streams, &streams);
1058 TALLOC_FREE(mapped_name);
1059 TALLOC_FREE(catia_smb_fname);
1060 if (!NT_STATUS_IS_OK(status)) {
1061 return status;
1062 }
1063
1064 /*
1065 * Translate stream names just like the base names
1066 */
1067 for (i = 0; i < num_streams; i++) {
1068 /*
1069 * Strip ":" prefix and ":$DATA" suffix to get a
1070 * "pure" stream name and only translate that.
1071 */
1072 void *old_ptr = streams[i].name;
1073 char *stream_name = streams[i].name + 1;
1074 char *stream_type = strrchr_m(stream_name, ':');
1075
1076 if (stream_type != NULL) {
1077 *stream_type = '\0';
1078 stream_type += 1;
1079 }
1080
1081 status = catia_string_replace_allocate(handle->conn, stream_name,
1082 &mapped_name, vfs_translate_to_windows);
1083 if (!NT_STATUS_IS_OK(status)) {
1084 TALLOC_FREE(streams);
1085 return status;
1086 }
1087
1088 if (stream_type != NULL) {
1089 streams[i].name = talloc_asprintf(streams, ":%s:%s",
1090 mapped_name, stream_type);
1091 } else {
1092 streams[i].name = talloc_asprintf(streams, ":%s",
1093 mapped_name);
1094 }
1095 TALLOC_FREE(mapped_name);
1096 TALLOC_FREE(old_ptr);
1097 if (streams[i].name == NULL) {
1098 TALLOC_FREE(streams);
1099 return NT_STATUS_NO_MEMORY;
1100 }
1101 }
1102
1103 *_num_streams = num_streams;
1104 *_streams = streams;
1105 return NT_STATUS_OK;
1106 }
1107
1108 static NTSTATUS
1109 catia_get_nt_acl(struct vfs_handle_struct *handle,
1110 const struct smb_filename *smb_fname,
1111 uint32_t security_info,
1112 TALLOC_CTX *mem_ctx,
1113 struct security_descriptor **ppdesc)
1114 {
1115 char *mapped_name = NULL;
1116 const char *path = smb_fname->base_name;
1117 struct smb_filename *mapped_smb_fname = NULL;
1118 NTSTATUS status;
1119
1120 status = catia_string_replace_allocate(handle->conn,
1121 path, &mapped_name, vfs_translate_to_unix);
1122 if (!NT_STATUS_IS_OK(status)) {
1123 errno = map_errno_from_nt_status(status);
1124 return status;
1125 }
1126 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1127 mapped_name,
1128 NULL,
1129 NULL,
1130 smb_fname->flags);
1131 if (mapped_smb_fname == NULL) {
1132 TALLOC_FREE(mapped_name);
1133 return NT_STATUS_NO_MEMORY;
1134 }
1135
1136 status = SMB_VFS_NEXT_GET_NT_ACL(handle, mapped_smb_fname,
1137 security_info, mem_ctx, ppdesc);
1138 TALLOC_FREE(mapped_name);
1139 TALLOC_FREE(mapped_smb_fname);
1140
1141 return status;
1142 }
1143
1144 static SMB_ACL_T
1145 catia_sys_acl_get_file(vfs_handle_struct *handle,
1146 const struct smb_filename *smb_fname,
1147 SMB_ACL_TYPE_T type,
1148 TALLOC_CTX *mem_ctx)
1149 {
1150 char *mapped_name = NULL;
1151 struct smb_filename *mapped_smb_fname = NULL;
1152 NTSTATUS status;
1153 SMB_ACL_T ret;
1154 int saved_errno = 0;
1155
1156 status = catia_string_replace_allocate(handle->conn,
1157 smb_fname->base_name,
1158 &mapped_name,
1159 vfs_translate_to_unix);
1160 if (!NT_STATUS_IS_OK(status)) {
1161 errno = map_errno_from_nt_status(status);
1162 return (SMB_ACL_T)NULL;
1163 }
1164
1165 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1166 mapped_name,
1167 NULL,
1168 NULL,
1169 smb_fname->flags);
1170 if (mapped_smb_fname == NULL) {
1171 TALLOC_FREE(mapped_name);
1172 errno = ENOMEM;
1173 return (SMB_ACL_T)NULL;
1174 }
1175
1176 ret = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, mapped_smb_fname,
1177 type, mem_ctx);
1178 if (ret == (SMB_ACL_T)NULL) {
1179 saved_errno = errno;
1180 }
1181 TALLOC_FREE(mapped_smb_fname);
1182 TALLOC_FREE(mapped_name);
1183 if (saved_errno != 0) {
1184 errno = saved_errno;
1185 }
1186 return ret;
1187 }
1188
1189 static int
1190 catia_sys_acl_set_file(vfs_handle_struct *handle,
1191 const struct smb_filename *smb_fname,
1192 SMB_ACL_TYPE_T type,
1193 SMB_ACL_T theacl)
1194 {
1195 struct smb_filename *mapped_smb_fname = NULL;
1196 int saved_errno = 0;
1197 char *mapped_name = NULL;
1198 NTSTATUS status;
1199 int ret;
1200
1201 status = catia_string_replace_allocate(handle->conn,
1202 smb_fname->base_name,
1203 &mapped_name,
1204 vfs_translate_to_unix);
1205 if (!NT_STATUS_IS_OK(status)) {
1206 errno = map_errno_from_nt_status(status);
1207 return -1;
1208 }
1209
1210 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1211 mapped_name,
1212 NULL,
1213 NULL,
1214 smb_fname->flags);
1215 if (mapped_smb_fname == NULL) {
1216 TALLOC_FREE(mapped_name);
1217 errno = ENOMEM;
1218 return -1;
1219 }
1220
1221 ret = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, mapped_smb_fname,
1222 type, theacl);
1223 if (ret == -1) {
1224 saved_errno = errno;
1225 }
1226 TALLOC_FREE(mapped_smb_fname);
1227 TALLOC_FREE(mapped_name);
1228 if (saved_errno != 0) {
1229 errno = saved_errno;
1230 }
1231 return ret;
1232 }
1233
1234 static int
1235 catia_sys_acl_delete_def_file(vfs_handle_struct *handle,
1236 const struct smb_filename *smb_fname)
1237 {
1238 struct smb_filename *mapped_smb_fname = NULL;
1239 int saved_errno = 0;
1240 char *mapped_name = NULL;
1241 NTSTATUS status;
1242 int ret;
1243
1244 status = catia_string_replace_allocate(handle->conn,
1245 smb_fname->base_name,
1246 &mapped_name,
1247 vfs_translate_to_unix);
1248 if (!NT_STATUS_IS_OK(status)) {
1249 errno = map_errno_from_nt_status(status);
1250 return -1;
1251 }
1252
1253 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1254 mapped_name,
1255 NULL,
1256 NULL,
1257 smb_fname->flags);
1258 if (mapped_smb_fname == NULL) {
1259 TALLOC_FREE(mapped_name);
1260 errno = ENOMEM;
1261 return -1;
1262 }
1263 ret = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, mapped_smb_fname);
1264 if (ret == -1) {
1265 saved_errno = errno;
1266 }
1267 TALLOC_FREE(mapped_smb_fname);
1268 TALLOC_FREE(mapped_name);
1269 if (saved_errno != 0) {
1270 errno = saved_errno;
1271 }
1272 return ret;
1273 }
1274
1275 static ssize_t
1276 catia_getxattr(vfs_handle_struct *handle,
1277 const struct smb_filename *smb_fname,
1278 const char *name,
1279 void *value,
1280 size_t size)
1281 {
1282 struct smb_filename *mapped_smb_fname = NULL;
1283 char *mapped_name = NULL;
1284 char *mapped_ea_name = NULL;
1285 NTSTATUS status;
1286 ssize_t ret;
1287 int saved_errno = 0;
1288
1289 status = catia_string_replace_allocate(handle->conn,
1290 smb_fname->base_name,
1291 &mapped_name,
1292 vfs_translate_to_unix);
1293 if (!NT_STATUS_IS_OK(status)) {
1294 errno = map_errno_from_nt_status(status);
1295 return -1;
1296 }
1297
1298 status = catia_string_replace_allocate(handle->conn,
1299 name, &mapped_ea_name, vfs_translate_to_unix);
1300 if (!NT_STATUS_IS_OK(status)) {
1301 TALLOC_FREE(mapped_name);
1302 errno = map_errno_from_nt_status(status);
1303 return -1;
1304 }
1305
1306 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1307 mapped_name,
1308 NULL,
1309 NULL,
1310 smb_fname->flags);
1311 if (mapped_smb_fname == NULL) {
1312 TALLOC_FREE(mapped_name);
1313 TALLOC_FREE(mapped_ea_name);
1314 errno = ENOMEM;
1315 return -1;
1316 }
1317
1318 ret = SMB_VFS_NEXT_GETXATTR(handle, mapped_smb_fname,
1319 mapped_ea_name, value, size);
1320 if (ret == -1) {
1321 saved_errno = errno;
1322 }
1323 TALLOC_FREE(mapped_name);
1324 TALLOC_FREE(mapped_ea_name);
1325 TALLOC_FREE(mapped_smb_fname);
1326 if (saved_errno != 0) {
1327 errno = saved_errno;
1328 }
1329
1330 return ret;
1331 }
1332
1333 static ssize_t
1334 catia_listxattr(vfs_handle_struct *handle,
1335 const struct smb_filename *smb_fname,
1336 char *list, size_t size)
1337 {
1338 struct smb_filename *mapped_smb_fname = NULL;
1339 char *mapped_name = NULL;
1340 NTSTATUS status;
1341 ssize_t ret;
1342 int saved_errno = 0;
1343
1344 status = catia_string_replace_allocate(handle->conn,
1345 smb_fname->base_name,
1346 &mapped_name,
1347 vfs_translate_to_unix);
1348 if (!NT_STATUS_IS_OK(status)) {
1349 errno = map_errno_from_nt_status(status);
1350 return -1;
1351 }
1352
1353 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1354 mapped_name,
1355 NULL,
1356 NULL,
1357 smb_fname->flags);
1358 if (mapped_smb_fname == NULL) {
1359 TALLOC_FREE(mapped_name);
1360 errno = ENOMEM;
1361 return -1;
1362 }
1363
1364 ret = SMB_VFS_NEXT_LISTXATTR(handle, mapped_smb_fname, list, size);
1365 if (ret == -1) {
1366 saved_errno = errno;
1367 }
1368 TALLOC_FREE(mapped_name);
1369 TALLOC_FREE(mapped_smb_fname);
1370 if (saved_errno != 0) {
1371 errno = saved_errno;
1372 }
1373
1374 return ret;
1375 }
1376
1377 static int
1378 catia_removexattr(vfs_handle_struct *handle,
1379 const struct smb_filename *smb_fname,
1380 const char *name)
1381 {
1382 struct smb_filename *mapped_smb_fname = NULL;
1383 char *mapped_name = NULL;
1384 char *mapped_ea_name = NULL;
1385 NTSTATUS status;
1386 ssize_t ret;
1387 int saved_errno = 0;
1388
1389 status = catia_string_replace_allocate(handle->conn,
1390 smb_fname->base_name,
1391 &mapped_name,
1392 vfs_translate_to_unix);
1393 if (!NT_STATUS_IS_OK(status)) {
1394 errno = map_errno_from_nt_status(status);
1395 return -1;
1396 }
1397
1398 status = catia_string_replace_allocate(handle->conn,
1399 name, &mapped_ea_name, vfs_translate_to_unix);
1400 if (!NT_STATUS_IS_OK(status)) {
1401 TALLOC_FREE(mapped_name);
1402 errno = map_errno_from_nt_status(status);
1403 return -1;
1404 }
1405
1406 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1407 mapped_name,
1408 NULL,
1409 NULL,
1410 smb_fname->flags);
1411 if (mapped_smb_fname == NULL) {
1412 TALLOC_FREE(mapped_name);
1413 TALLOC_FREE(mapped_ea_name);
1414 errno = ENOMEM;
1415 return -1;
1416 }
1417
1418 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, mapped_smb_fname,
1419 mapped_ea_name);
1420 if (ret == -1) {
1421 saved_errno = errno;
1422 }
1423 TALLOC_FREE(mapped_name);
1424 TALLOC_FREE(mapped_ea_name);
1425 TALLOC_FREE(mapped_smb_fname);
1426 if (saved_errno != 0) {
1427 errno = saved_errno;
1428 }
1429
1430 return ret;
1431 }
1432
1433 static int
1434 catia_setxattr(vfs_handle_struct *handle,
1435 const struct smb_filename *smb_fname,
1436 const char *name,
1437 const void *value,
1438 size_t size,
1439 int flags)
1440 {
1441 struct smb_filename *mapped_smb_fname = NULL;
1442 char *mapped_name = NULL;
1443 char *mapped_ea_name = NULL;
1444 NTSTATUS status;
1445 ssize_t ret;
1446 int saved_errno = 0;
1447
1448 status = catia_string_replace_allocate(handle->conn,
1449 smb_fname->base_name,
1450 &mapped_name,
1451 vfs_translate_to_unix);
1452 if (!NT_STATUS_IS_OK(status)) {
1453 errno = map_errno_from_nt_status(status);
1454 return -1;
1455 }
1456
1457 status = catia_string_replace_allocate(handle->conn,
1458 name, &mapped_ea_name, vfs_translate_to_unix);
1459 if (!NT_STATUS_IS_OK(status)) {
1460 TALLOC_FREE(mapped_name);
1461 errno = map_errno_from_nt_status(status);
1462 return -1;
1463 }
1464
1465 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
1466 mapped_name,
1467 NULL,
1468 NULL,
1469 smb_fname->flags);
1470 if (mapped_smb_fname == NULL) {
1471 TALLOC_FREE(mapped_name);
1472 TALLOC_FREE(mapped_ea_name);
1473 errno = ENOMEM;
1474 return -1;
1475 }
1476
1477 ret = SMB_VFS_NEXT_SETXATTR(handle, mapped_smb_fname, mapped_ea_name,
1478 value, size, flags);
1479 if (ret == -1) {
1480 saved_errno = errno;
1481 }
1482 TALLOC_FREE(mapped_name);
1483 TALLOC_FREE(mapped_ea_name);
1484 TALLOC_FREE(mapped_smb_fname);
1485 if (saved_errno != 0) {
1486 errno = saved_errno;
1487 }
1488
1489 return ret;
1490 }
1491
1492 static int catia_fstat(vfs_handle_struct *handle,
1493 files_struct *fsp,
1494 SMB_STRUCT_STAT *sbuf)
1495 {
1496 struct catia_cache *cc = NULL;
1497 int ret;
1498
1499 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1500 if (ret != 0) {
1501 return ret;
1502 }
1503
1504 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
1505
1506 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1507
1508 return ret;
1509 }
1510
1511 static ssize_t catia_pread(vfs_handle_struct *handle,
1512 files_struct *fsp, void *data,
1513 size_t n, off_t offset)
1514 {
1515 struct catia_cache *cc = NULL;
1516 ssize_t result;
1517 int ret;
1518
1519 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1520 if (ret != 0) {
1521 return ret;
1522 }
1523
1524 result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
1525
1526 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1527
1528 return result;
1529 }
1530
1531 static ssize_t catia_pwrite(vfs_handle_struct *handle,
1532 files_struct *fsp, const void *data,
1533 size_t n, off_t offset)
1534 {
1535 struct catia_cache *cc = NULL;
1536 ssize_t result;
1537 int ret;
1538
1539 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1540 if (ret != 0) {
1541 return ret;
1542 }
1543
1544 result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
1545
1546 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1547
1548 return result;
1549 }
1550
1551 static int catia_ftruncate(struct vfs_handle_struct *handle,
1552 struct files_struct *fsp,
1553 off_t offset)
1554 {
1555 struct catia_cache *cc = NULL;
1556 int ret;
1557
1558 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1559 if (ret != 0) {
1560 return ret;
1561 }
1562
1563 ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
1564
1565 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1566
1567 return ret;
1568 }
1569
1570 static int catia_fallocate(struct vfs_handle_struct *handle,
1571 struct files_struct *fsp,
1572 uint32_t mode,
1573 off_t offset,
1574 off_t len)
1575 {
1576 struct catia_cache *cc = NULL;
1577 int ret;
1578
1579 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1580 if (ret != 0) {
1581 return ret;
1582 }
1583
1584 ret = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
1585
1586 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1587
1588 return ret;
1589 }
1590
1591 static ssize_t catia_fgetxattr(struct vfs_handle_struct *handle,
1592 struct files_struct *fsp,
1593 const char *name,
1594 void *value,
1595 size_t size)
1596 {
1597 char *mapped_xattr_name = NULL;
1598 NTSTATUS status;
1599 ssize_t result;
1600
1601 status = catia_string_replace_allocate(handle->conn,
1602 name, &mapped_xattr_name,
1603 vfs_translate_to_unix);
1604 if (!NT_STATUS_IS_OK(status)) {
1605 errno = map_errno_from_nt_status(status);
1606 return -1;
1607 }
1608
1609 result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, mapped_xattr_name,
1610 value, size);
1611
1612 TALLOC_FREE(mapped_xattr_name);
1613
1614 return result;
1615 }
1616
1617 static ssize_t catia_flistxattr(struct vfs_handle_struct *handle,
1618 struct files_struct *fsp,
1619 char *list,
1620 size_t size)
1621 {
1622 struct catia_cache *cc = NULL;
1623 ssize_t result;
1624 int ret;
1625
1626 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1627 if (ret != 0) {
1628 return ret;
1629 }
1630
1631 result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
1632
1633 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1634
1635 return result;
1636 }
1637
1638 static int catia_fremovexattr(struct vfs_handle_struct *handle,
1639 struct files_struct *fsp,
1640 const char *name)
1641 {
1642 char *mapped_name = NULL;
1643 NTSTATUS status;
1644 int ret;
1645
1646 status = catia_string_replace_allocate(handle->conn,
1647 name, &mapped_name, vfs_translate_to_unix);
1648 if (!NT_STATUS_IS_OK(status)) {
1649 errno = map_errno_from_nt_status(status);
1650 return -1;
1651 }
1652
1653 ret = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, mapped_name);
1654
1655 TALLOC_FREE(mapped_name);
1656
1657 return ret;
1658 }
1659
1660 static int catia_fsetxattr(struct vfs_handle_struct *handle,
1661 struct files_struct *fsp,
1662 const char *name,
1663 const void *value,
1664 size_t size,
1665 int flags)
1666 {
1667 char *mapped_xattr_name = NULL;
1668 NTSTATUS status;
1669 int ret;
1670
1671 status = catia_string_replace_allocate(
1672 handle->conn, name, &mapped_xattr_name, vfs_translate_to_unix);
1673 if (!NT_STATUS_IS_OK(status)) {
1674 errno = map_errno_from_nt_status(status);
1675 return -1;
1676 }
1677
1678 ret = SMB_VFS_NEXT_FSETXATTR(handle, fsp, mapped_xattr_name,
1679 value, size, flags);
1680
1681 TALLOC_FREE(mapped_xattr_name);
1682
1683 return ret;
1684 }
1685
1686 static SMB_ACL_T catia_sys_acl_get_fd(vfs_handle_struct *handle,
1687 files_struct *fsp,
1688 TALLOC_CTX *mem_ctx)
1689 {
1690 struct catia_cache *cc = NULL;
1691 struct smb_acl_t *result = NULL;
1692 int ret;
1693
1694 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1695 if (ret != 0) {
1696 return NULL;
1697 }
1698
1699 result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, mem_ctx);
1700
1701 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1702
1703 return result;
1704 }
1705
1706 static int catia_sys_acl_blob_get_fd(vfs_handle_struct *handle,
1707 files_struct *fsp,
1708 TALLOC_CTX *mem_ctx,
1709 char **blob_description,
1710 DATA_BLOB *blob)
1711 {
1712 struct catia_cache *cc = NULL;
1713 int ret;
1714
1715 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1716 if (ret != 0) {
1717 return ret;
1718 }
1719
1720 ret = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx,
1721 blob_description, blob);
1722
1723 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1724
1725 return ret;
1726 }
1727
1728 static int catia_sys_acl_set_fd(vfs_handle_struct *handle,
1729 files_struct *fsp,
1730 SMB_ACL_T theacl)
1731 {
1732 struct catia_cache *cc = NULL;
1733 int ret;
1734
1735 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1736 if (ret != 0) {
1737 return ret;
1738 }
1739
1740 ret = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
1741
1742 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1743
1744 return ret;
1745 }
1746
1747 static NTSTATUS catia_fget_nt_acl(vfs_handle_struct *handle,
1748 files_struct *fsp,
1749 uint32_t security_info,
1750 TALLOC_CTX *mem_ctx,
1751 struct security_descriptor **ppdesc)
1752 {
1753 struct catia_cache *cc = NULL;
1754 NTSTATUS status;
1755 int ret;
1756
1757 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1758 if (ret != 0) {
1759 return map_nt_error_from_unix(errno);
1760 }
1761
1762 status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1763 mem_ctx, ppdesc);
1764
1765 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1766
1767 return status;
1768 }
1769
1770 static NTSTATUS catia_fset_nt_acl(vfs_handle_struct *handle,
1771 files_struct *fsp,
1772 uint32_t security_info_sent,
1773 const struct security_descriptor *psd)
1774 {
1775 struct catia_cache *cc = NULL;
1776 NTSTATUS status;
1777 int ret;
1778
1779 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1780 if (ret != 0) {
1781 return map_nt_error_from_unix(errno);
1782 }
1783
1784 status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
1785
1786 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1787
1788 return status;
1789 }
1790
1791 static NTSTATUS catia_fset_dos_attributes(struct vfs_handle_struct *handle,
1792 struct files_struct *fsp,
1793 uint32_t dosmode)
1794 {
1795 struct catia_cache *cc = NULL;
1796 NTSTATUS status;
1797 int ret;
1798
1799 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1800 if (ret != 0) {
1801 return map_nt_error_from_unix(errno);
1802 }
1803
1804 status = SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle, fsp, dosmode);
1805
1806 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1807
1808 return status;
1809 }
1810
1811 static NTSTATUS catia_fget_dos_attributes(struct vfs_handle_struct *handle,
1812 struct files_struct *fsp,
1813 uint32_t *dosmode)
1814 {
1815 struct catia_cache *cc = NULL;
1816 NTSTATUS status;
1817 int ret;
1818
1819 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1820 if (ret != 0) {
1821 return map_nt_error_from_unix(errno);
1822 }
1823
1824 status = SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle, fsp, dosmode);
1825
1826 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1827
1828 return status;
1829 }
1830
1831 static int catia_fchown(vfs_handle_struct *handle,
1832 files_struct *fsp,
1833 uid_t uid,
1834 gid_t gid)
1835 {
1836 struct catia_cache *cc = NULL;
1837 int ret;
1838
1839 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1840 if (ret != 0) {
1841 return ret;
1842 }
1843
1844 ret = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
1845
1846 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1847
1848 return ret;
1849 }
1850
1851 static int catia_fchmod(vfs_handle_struct *handle,
1852 files_struct *fsp,
1853 mode_t mode)
1854 {
1855 struct catia_cache *cc = NULL;
1856 int ret;
1857
1858 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
1859 if (ret != 0) {
1860 return ret;
1861 }
1862
1863 ret = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
1864
1865 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
1866
1867 return ret;
1868 }
1869
1870 struct catia_pread_state {
1871 ssize_t ret;
1872 struct vfs_aio_state vfs_aio_state;
1873 struct files_struct *fsp;
1874 struct catia_cache *cc;
1875 };
1876
1877 static void catia_pread_done(struct tevent_req *subreq);
1878
1879 static struct tevent_req *catia_pread_send(struct vfs_handle_struct *handle,
1880 TALLOC_CTX *mem_ctx,
1881 struct tevent_context *ev,
1882 struct files_struct *fsp,
1883 void *data,
1884 size_t n,
1885 off_t offset)
1886 {
1887 struct tevent_req *req = NULL, *subreq = NULL;
1888 struct catia_pread_state *state = NULL;
1889 int ret;
1890
1891 req = tevent_req_create(mem_ctx, &state,
1892 struct catia_pread_state);
1893 if (req == NULL) {
1894 return NULL;
1895 }
1896 state->fsp = fsp;
1897
1898 ret = CATIA_FETCH_FSP_PRE_NEXT(state, handle, fsp, &state->cc);
1899 if (ret != 0) {
1900 tevent_req_error(req, errno);
1901 return tevent_req_post(req, ev);
1902 }
1903
1904 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp, data,
1905 n, offset);
1906 if (tevent_req_nomem(subreq, req)) {
1907 return tevent_req_post(req, ev);
1908 }
1909 tevent_req_set_callback(subreq, catia_pread_done, req);
1910
1911 return req;
1912 }
1913
1914 static void catia_pread_done(struct tevent_req *subreq)
1915 {
1916 struct tevent_req *req = tevent_req_callback_data(
1917 subreq, struct tevent_req);
1918 struct catia_pread_state *state = tevent_req_data(
1919 req, struct catia_pread_state);
1920
1921 state->ret = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
1922 TALLOC_FREE(subreq);
1923
1924 CATIA_FETCH_FSP_POST_NEXT(&state->cc, state->fsp);
1925
1926 tevent_req_done(req);
1927 }
1928
1929 static ssize_t catia_pread_recv(struct tevent_req *req,
1930 struct vfs_aio_state *vfs_aio_state)
1931 {
1932 struct catia_pread_state *state = tevent_req_data(
1933 req, struct catia_pread_state);
1934
1935 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1936 return -1;
1937 }
1938
1939 *vfs_aio_state = state->vfs_aio_state;
1940 return state->ret;
1941 }
1942
1943 struct catia_pwrite_state {
1944 ssize_t ret;
1945 struct vfs_aio_state vfs_aio_state;
1946 struct files_struct *fsp;
1947 struct catia_cache *cc;
1948 };
1949
1950 static void catia_pwrite_done(struct tevent_req *subreq);
1951
1952 static struct tevent_req *catia_pwrite_send(struct vfs_handle_struct *handle,
1953 TALLOC_CTX *mem_ctx,
1954 struct tevent_context *ev,
1955 struct files_struct *fsp,
1956 const void *data,
1957 size_t n,
1958 off_t offset)
1959 {
1960 struct tevent_req *req = NULL, *subreq = NULL;
1961 struct catia_pwrite_state *state = NULL;
1962 int ret;
1963
1964 req = tevent_req_create(mem_ctx, &state,
1965 struct catia_pwrite_state);
1966 if (req == NULL) {
1967 return NULL;
1968 }
1969 state->fsp = fsp;
1970
1971 ret = CATIA_FETCH_FSP_PRE_NEXT(state, handle, fsp, &state->cc);
1972 if (ret != 0) {
1973 tevent_req_error(req, errno);
1974 return tevent_req_post(req, ev);
1975 }
1976
1977 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp, data,
1978 n, offset);
1979 if (tevent_req_nomem(subreq, req)) {
1980 return tevent_req_post(req, ev);
1981 }
1982 tevent_req_set_callback(subreq, catia_pwrite_done, req);
1983
1984 return req;
1985 }
1986
1987 static void catia_pwrite_done(struct tevent_req *subreq)
1988 {
1989 struct tevent_req *req = tevent_req_callback_data(
1990 subreq, struct tevent_req);
1991 struct catia_pwrite_state *state = tevent_req_data(
1992 req, struct catia_pwrite_state);
1993
1994 state->ret = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
1995 TALLOC_FREE(subreq);
1996
1997 CATIA_FETCH_FSP_POST_NEXT(&state->cc, state->fsp);
1998
1999 tevent_req_done(req);
2000 }
2001
2002 static ssize_t catia_pwrite_recv(struct tevent_req *req,
2003 struct vfs_aio_state *vfs_aio_state)
2004 {
2005 struct catia_pwrite_state *state = tevent_req_data(
2006 req, struct catia_pwrite_state);
2007
2008 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
2009 return -1;
2010 }
2011
2012 *vfs_aio_state = state->vfs_aio_state;
2013 return state->ret;
2014 }
2015
2016 static off_t catia_lseek(vfs_handle_struct *handle,
2017 files_struct *fsp,
2018 off_t offset,
2019 int whence)
2020 {
2021 struct catia_cache *cc = NULL;
2022 ssize_t result;
2023 int ret;
2024
2025 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2026 if (ret != 0) {
2027 return -1;
2028 }
2029
2030 result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
2031
2032 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2033
2034 return result;
2035 }
2036
2037 struct catia_fsync_state {
2038 int ret;
2039 struct vfs_aio_state vfs_aio_state;
2040 struct files_struct *fsp;
2041 struct catia_cache *cc;
2042 };
2043
2044 static void catia_fsync_done(struct tevent_req *subreq);
2045
2046 static struct tevent_req *catia_fsync_send(struct vfs_handle_struct *handle,
2047 TALLOC_CTX *mem_ctx,
2048 struct tevent_context *ev,
2049 struct files_struct *fsp)
2050 {
2051 struct tevent_req *req = NULL, *subreq = NULL;
2052 struct catia_fsync_state *state = NULL;
2053 int ret;
2054
2055 req = tevent_req_create(mem_ctx, &state,
2056 struct catia_fsync_state);
2057 if (req == NULL) {
2058 return NULL;
2059 }
2060 state->fsp = fsp;
2061
2062 ret = CATIA_FETCH_FSP_PRE_NEXT(state, handle, fsp, &state->cc);
2063 if (ret != 0) {
2064 tevent_req_error(req, errno);
2065 return tevent_req_post(req, ev);
2066 }
2067
2068 subreq = SMB_VFS_NEXT_FSYNC_SEND(state, ev, handle, fsp);
2069 if (tevent_req_nomem(subreq, req)) {
2070 return tevent_req_post(req, ev);
2071 }
2072 tevent_req_set_callback(subreq, catia_fsync_done, req);
2073
2074 return req;
2075 }
2076
2077 static void catia_fsync_done(struct tevent_req *subreq)
2078 {
2079 struct tevent_req *req = tevent_req_callback_data(
2080 subreq, struct tevent_req);
2081 struct catia_fsync_state *state = tevent_req_data(
2082 req, struct catia_fsync_state);
2083
2084 state->ret = SMB_VFS_FSYNC_RECV(subreq, &state->vfs_aio_state);
2085 TALLOC_FREE(subreq);
2086
2087 CATIA_FETCH_FSP_POST_NEXT(&state->cc, state->fsp);
2088
2089 tevent_req_done(req);
2090 }
2091
2092 static int catia_fsync_recv(struct tevent_req *req,
2093 struct vfs_aio_state *vfs_aio_state)
2094 {
2095 struct catia_fsync_state *state = tevent_req_data(
2096 req, struct catia_fsync_state);
2097
2098 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
2099 return -1;
2100 }
2101
2102 *vfs_aio_state = state->vfs_aio_state;
2103 return state->ret;
2104 }
2105
2106 static bool catia_lock(vfs_handle_struct *handle,
2107 files_struct *fsp,
2108 int op,
2109 off_t offset,
2110 off_t count,
2111 int type)
2112 {
2113 struct catia_cache *cc = NULL;
2114 bool ok;
2115 int ret;
2116
2117 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2118 if (ret != 0) {
2119 return -1;
2120 }
2121
2122 ok = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
2123
2124 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2125
2126 return ok;
2127 }
2128
2129 static int catia_kernel_flock(struct vfs_handle_struct *handle,
2130 struct files_struct *fsp,
2131 uint32_t share_mode,
2132 uint32_t access_mask)
2133 {
2134 struct catia_cache *cc = NULL;
2135 int ret;
2136
2137 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2138 if (ret != 0) {
2139 return -1;
2140 }
2141
2142 ret = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask);
2143
2144 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2145
2146 return ret;
2147 }
2148
2149 static int catia_linux_setlease(vfs_handle_struct *handle,
2150 files_struct *fsp,
2151 int leasetype)
2152 {
2153 struct catia_cache *cc = NULL;
2154 int ret;
2155
2156 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2157 if (ret != 0) {
2158 return -1;
2159 }
2160
2161 ret = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
2162
2163 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2164
2165 return ret;
2166 }
2167
2168 static bool catia_getlock(vfs_handle_struct *handle,
2169 files_struct *fsp,
2170 off_t *poffset,
2171 off_t *pcount,
2172 int *ptype,
2173 pid_t *ppid)
2174 {
2175 struct catia_cache *cc = NULL;
2176 int ret;
2177 bool ok;
2178
2179 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2180 if (ret != 0) {
2181 return -1;
2182 }
2183
2184 ok = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid);
2185
2186 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2187
2188 return ok;
2189 }
2190
2191 static bool catia_strict_lock_check(struct vfs_handle_struct *handle,
2192 struct files_struct *fsp,
2193 struct lock_struct *plock)
2194 {
2195 struct catia_cache *cc = NULL;
2196 int ret;
2197 bool ok;
2198
2199 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2200 if (ret != 0) {
2201 return -1;
2202 }
2203
2204 ok = SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle, fsp, plock);
2205
2206 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2207
2208 return ok;
2209 }
2210
2211 static NTSTATUS catia_fsctl(struct vfs_handle_struct *handle,
2212 struct files_struct *fsp,
2213 TALLOC_CTX *ctx,
2214 uint32_t function,
2215 uint16_t req_flags,
2216 const uint8_t *_in_data,
2217 uint32_t in_len,
2218 uint8_t **_out_data,
2219 uint32_t max_out_len,
2220 uint32_t *out_len)
2221 {
2222 NTSTATUS result;
2223 struct catia_cache *cc = NULL;
2224 int ret;
2225
2226 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2227 if (ret != 0) {
2228 return map_nt_error_from_unix(errno);
2229 }
2230
2231 result = SMB_VFS_NEXT_FSCTL(handle,
2232 fsp,
2233 ctx,
2234 function,
2235 req_flags,
2236 _in_data,
2237 in_len,
2238 _out_data,
2239 max_out_len,
2240 out_len);
2241
2242 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2243
2244 return result;
2245 }
2246
2247 static NTSTATUS catia_get_compression(vfs_handle_struct *handle,
2248 TALLOC_CTX *mem_ctx,
2249 struct files_struct *fsp,
2250 struct smb_filename *smb_fname,
2251 uint16_t *_compression_fmt)
2252 {
2253 NTSTATUS result;
2254 struct catia_cache *cc = NULL;
2255 int ret;
2256 struct smb_filename *mapped_smb_fname = NULL;
2257 char *mapped_name = NULL;
2258
2259 if (fsp != NULL) {
2260 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2261 if (ret != 0) {
2262 return map_nt_error_from_unix(errno);
2263 }
2264 mapped_smb_fname = fsp->fsp_name;
2265 } else {
2266 result = catia_string_replace_allocate(handle->conn,
2267 smb_fname->base_name,
2268 &mapped_name,
2269 vfs_translate_to_unix);
2270 if (!NT_STATUS_IS_OK(result)) {
2271 return result;
2272 }
2273
2274 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
2275 mapped_name,
2276 NULL,
2277 NULL,
2278 smb_fname->flags);
2279 if (mapped_smb_fname == NULL) {
2280 TALLOC_FREE(mapped_name);
2281 return NT_STATUS_NO_MEMORY;
2282 }
2283
2284 TALLOC_FREE(mapped_name);
2285 }
2286
2287 result = SMB_VFS_NEXT_GET_COMPRESSION(handle,
2288 mem_ctx,
2289 fsp,
2290 mapped_smb_fname,
2291 _compression_fmt);
2292
2293 if (fsp != NULL) {
2294 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2295 } else {
2296 TALLOC_FREE(mapped_smb_fname);
2297 }
2298
2299 return result;
2300 }
2301
2302 static NTSTATUS catia_set_compression(vfs_handle_struct *handle,
2303 TALLOC_CTX *mem_ctx,
2304 struct files_struct *fsp,
2305 uint16_t compression_fmt)
2306 {
2307 NTSTATUS result;
2308 struct catia_cache *cc = NULL;
2309 int ret;
2310
2311 ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
2312 if (ret != 0) {
2313 return map_nt_error_from_unix(errno);
2314 }
2315
2316 result = SMB_VFS_NEXT_SET_COMPRESSION(handle, mem_ctx, fsp,
2317 compression_fmt);
2318
2319 CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
2320
2321 return result;
2322 }
2323
2324 static NTSTATUS catia_readdir_attr(struct vfs_handle_struct *handle,
2325 const struct smb_filename *smb_fname_in,
2326 TALLOC_CTX *mem_ctx,
2327 struct readdir_attr_data **pattr_data)
2328 {
2329 struct smb_filename *smb_fname;
2330 char *fname = NULL;
2331 NTSTATUS status;
2332
2333 status = catia_string_replace_allocate(handle->conn,
2334 smb_fname_in->base_name,
2335 &fname,
2336 vfs_translate_to_unix);
2337 if (!NT_STATUS_IS_OK(status)) {
2338 errno = map_errno_from_nt_status(status);
2339 return status;
2340 }
2341
2342 smb_fname = synthetic_smb_fname(talloc_tos(), fname, NULL,
2343 &smb_fname_in->st, 0);
2344
2345 status = SMB_VFS_NEXT_READDIR_ATTR(handle, smb_fname, mem_ctx, pattr_data);
2346
2347 TALLOC_FREE(smb_fname);
2348 TALLOC_FREE(fname);
2349 return status;
2350 }
2351
2352 static NTSTATUS catia_get_dos_attributes(struct vfs_handle_struct *handle,
2353 struct smb_filename *smb_fname,
2354 uint32_t *dosmode)
2355 {
2356 char *mapped_name = NULL;
2357 const char *path = smb_fname->base_name;
2358 struct smb_filename *mapped_smb_fname = NULL;
2359 NTSTATUS status;
2360
2361 status = catia_string_replace_allocate(handle->conn,
2362 path, &mapped_name, vfs_translate_to_unix);
2363 if (!NT_STATUS_IS_OK(status)) {
2364 errno = map_errno_from_nt_status(status);
2365 return status;
2366 }
2367 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
2368 mapped_name,
2369 NULL,
2370 NULL,
2371 smb_fname->flags);
2372 if (mapped_smb_fname == NULL) {
2373 TALLOC_FREE(mapped_name);
2374 return NT_STATUS_NO_MEMORY;
2375 }
2376
2377 status = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES(handle,
2378 mapped_smb_fname,
2379 dosmode);
2380 TALLOC_FREE(mapped_name);
2381 TALLOC_FREE(mapped_smb_fname);
2382
2383 return status;
2384 }
2385
2386 static NTSTATUS catia_set_dos_attributes(struct vfs_handle_struct *handle,
2387 const struct smb_filename *smb_fname,
2388 uint32_t dosmode)
2389 {
2390 char *mapped_name = NULL;
2391 const char *path = smb_fname->base_name;
2392 struct smb_filename *mapped_smb_fname = NULL;
2393 NTSTATUS status;
2394
2395 status = catia_string_replace_allocate(handle->conn,
2396 path, &mapped_name, vfs_translate_to_unix);
2397 if (!NT_STATUS_IS_OK(status)) {
2398 errno = map_errno_from_nt_status(status);
2399 return status;
2400 }
2401 mapped_smb_fname = synthetic_smb_fname(talloc_tos(),
2402 mapped_name,
2403 NULL,
2404 NULL,
2405 smb_fname->flags);
2406 if (mapped_smb_fname == NULL) {
2407 TALLOC_FREE(mapped_name);
2408 return NT_STATUS_NO_MEMORY;
2409 }
2410
2411 status = SMB_VFS_NEXT_SET_DOS_ATTRIBUTES(handle,
2412 mapped_smb_fname,
2413 dosmode);
2414 TALLOC_FREE(mapped_name);
2415 TALLOC_FREE(mapped_smb_fname);
2416
2417 return status;
2418 }
2419
2420 static struct vfs_fn_pointers vfs_catia_fns = {
2421 .connect_fn = catia_connect,
2422
2423 /* Directory operations */
2424 .mkdir_fn = catia_mkdir,
2425 .rmdir_fn = catia_rmdir,
2426 .opendir_fn = catia_opendir,
2427 .readdir_attr_fn = catia_readdir_attr,
2428
2429 /* File operations */
2430 .open_fn = catia_open,
2431 .pread_fn = catia_pread,
2432 .pread_send_fn = catia_pread_send,
2433 .pread_recv_fn = catia_pread_recv,
2434 .pwrite_fn = catia_pwrite,
2435 .pwrite_send_fn = catia_pwrite_send,
2436 .pwrite_recv_fn = catia_pwrite_recv,
2437 .lseek_fn = catia_lseek,
2438 .rename_fn = catia_rename,
2439 .fsync_send_fn = catia_fsync_send,
2440 .fsync_recv_fn = catia_fsync_recv,
2441 .stat_fn = catia_stat,
2442 .fstat_fn = catia_fstat,
2443 .lstat_fn = catia_lstat,
2444 .unlink_fn = catia_unlink,
2445 .chmod_fn = catia_chmod,
2446 .fchmod_fn = catia_fchmod,
2447 .chown_fn = catia_chown,
2448 .fchown_fn = catia_fchown,
2449 .lchown_fn = catia_lchown,
2450 .chdir_fn = catia_chdir,
2451 .ntimes_fn = catia_ntimes,
2452 .ftruncate_fn = catia_ftruncate,
2453 .fallocate_fn = catia_fallocate,
2454 .lock_fn = catia_lock,
2455 .kernel_flock_fn = catia_kernel_flock,
2456 .linux_setlease_fn = catia_linux_setlease,
2457 .getlock_fn = catia_getlock,
2458 .realpath_fn = catia_realpath,
2459 .chflags_fn = catia_chflags,
2460 .streaminfo_fn = catia_streaminfo,
2461 .strict_lock_check_fn = catia_strict_lock_check,
2462 .translate_name_fn = catia_translate_name,
2463 .fsctl_fn = catia_fsctl,
2464 .get_dos_attributes_fn = catia_get_dos_attributes,
2465 .get_dos_attributes_send_fn = vfs_not_implemented_get_dos_attributes_send,
2466 .get_dos_attributes_recv_fn = vfs_not_implemented_get_dos_attributes_recv,
2467 .set_dos_attributes_fn = catia_set_dos_attributes,
2468 .fset_dos_attributes_fn = catia_fset_dos_attributes,
2469 .fget_dos_attributes_fn = catia_fget_dos_attributes,
2470 .get_compression_fn = catia_get_compression,
2471 .set_compression_fn = catia_set_compression,
2472
2473 /* NT ACL operations. */
2474 .get_nt_acl_fn = catia_get_nt_acl,
2475 .fget_nt_acl_fn = catia_fget_nt_acl,
2476 .fset_nt_acl_fn = catia_fset_nt_acl,
2477
2478 /* POSIX ACL operations. */
2479 .sys_acl_get_file_fn = catia_sys_acl_get_file,
2480 .sys_acl_get_fd_fn = catia_sys_acl_get_fd,
2481 .sys_acl_blob_get_fd_fn = catia_sys_acl_blob_get_fd,
2482 .sys_acl_set_file_fn = catia_sys_acl_set_file,
2483 .sys_acl_set_fd_fn = catia_sys_acl_set_fd,
2484 .sys_acl_delete_def_file_fn = catia_sys_acl_delete_def_file,
2485
2486 /* EA operations. */
2487 .getxattr_fn = catia_getxattr,
2488 .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
2489 .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
2490 .listxattr_fn = catia_listxattr,
2491 .removexattr_fn = catia_removexattr,
2492 .setxattr_fn = catia_setxattr,
2493 .fgetxattr_fn = catia_fgetxattr,
2494 .flistxattr_fn = catia_flistxattr,
2495 .fremovexattr_fn = catia_fremovexattr,
2496 .fsetxattr_fn = catia_fsetxattr,
2497 };
2498
2499 static_decl_vfs;
2500 NTSTATUS vfs_catia_init(TALLOC_CTX *ctx)
2501 {
2502 NTSTATUS ret;
2503
2504 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "catia",
2505 &vfs_catia_fns);
2506 if (!NT_STATUS_IS_OK(ret))
2507 return ret;
2508
2509 vfs_catia_debug_level = debug_add_class("catia");
2510 if (vfs_catia_debug_level == -1) {
2511 vfs_catia_debug_level = DBGC_VFS;
2512 DEBUG(0, ("vfs_catia: Couldn't register custom debugging "
2513 "class!\n"));
2514 } else {
2515 DEBUG(10, ("vfs_catia: Debug class number of "
2516 "'catia': %d\n", vfs_catia_debug_level));
2517 }
2518
2519 return ret;
2520
2521 }
Samba GIT mirror