e20b7eb76ed96e3cd13d7e051141c1fe70c63379
[kamenim/samba-autobuild/.git] / source3 / modules / vfs_not_implemented.c
1 /*
2  * VFS module with "not implemented " helper functions for other modules.
3  *
4  * Copyright (C) Tim Potter, 1999-2000
5  * Copyright (C) Alexander Bokovoy, 2002
6  * Copyright (C) Stefan (metze) Metzmacher, 2003,2018
7  * Copyright (C) Jeremy Allison 2009
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
21  */
22
23 #include "includes.h"
24 #include "lib/util/tevent_unix.h"
25 #include "lib/util/tevent_ntstatus.h"
26
27 int vfs_not_implemented_connect(
28                         vfs_handle_struct *handle,
29                         const char *service,
30                         const char *user)
31 {
32         errno = ENOSYS;
33         return -1;
34 }
35
36 void vfs_not_implemented_disconnect(vfs_handle_struct *handle)
37 {
38         ;
39 }
40
41 uint64_t vfs_not_implemented_disk_free(vfs_handle_struct *handle,
42                                 const struct smb_filename *smb_fname,
43                                 uint64_t *bsize,
44                                 uint64_t *dfree,
45                                 uint64_t *dsize)
46 {
47         *bsize = 0;
48         *dfree = 0;
49         *dsize = 0;
50         return 0;
51 }
52
53 int vfs_not_implemented_get_quota(vfs_handle_struct *handle,
54                                 const struct smb_filename *smb_fname,
55                                 enum SMB_QUOTA_TYPE qtype,
56                                 unid_t id,
57                                 SMB_DISK_QUOTA *dq)
58 {
59         errno = ENOSYS;
60         return -1;
61 }
62
63 int vfs_not_implemented_set_quota(vfs_handle_struct *handle,
64                                   enum SMB_QUOTA_TYPE qtype,
65                                   unid_t id, SMB_DISK_QUOTA *dq)
66 {
67         errno = ENOSYS;
68         return -1;
69 }
70
71 int vfs_not_implemented_get_shadow_copy_data(vfs_handle_struct *handle,
72                                 files_struct *fsp,
73                                 struct shadow_copy_data *shadow_copy_data,
74                                 bool labels)
75 {
76         errno = ENOSYS;
77         return -1;
78 }
79
80 int vfs_not_implemented_statvfs(struct vfs_handle_struct *handle,
81                                 const struct smb_filename *smb_fname,
82                                 struct vfs_statvfs_struct *statbuf)
83 {
84         errno = ENOSYS;
85         return -1;
86 }
87
88 uint32_t vfs_not_implemented_fs_capabilities(struct vfs_handle_struct *handle,
89                                 enum timestamp_set_resolution *p_ts_res)
90 {
91         return 0;
92 }
93
94 NTSTATUS vfs_not_implemented_get_dfs_referrals(struct vfs_handle_struct *handle,
95                                                struct dfs_GetDFSReferral *r)
96 {
97         return NT_STATUS_NOT_IMPLEMENTED;
98 }
99
100 DIR *vfs_not_implemented_opendir(vfs_handle_struct *handle,
101                         const struct smb_filename *smb_fname,
102                         const char *mask,
103                         uint32_t attr)
104 {
105         return NULL;
106 }
107
108 NTSTATUS vfs_not_implemented_snap_check_path(struct vfs_handle_struct *handle,
109                                 TALLOC_CTX *mem_ctx,
110                                 const char *service_path,
111                                 char **base_volume)
112 {
113         return NT_STATUS_NOT_SUPPORTED;
114 }
115
116 NTSTATUS vfs_not_implemented_snap_create(struct vfs_handle_struct *handle,
117                                          TALLOC_CTX *mem_ctx,
118                                          const char *base_volume,
119                                          time_t *tstamp,
120                                          bool rw,
121                                          char **base_path,
122                                          char **snap_path)
123 {
124         return NT_STATUS_NOT_SUPPORTED;
125 }
126
127 NTSTATUS vfs_not_implemented_snap_delete(struct vfs_handle_struct *handle,
128                                          TALLOC_CTX *mem_ctx,
129                                          char *base_path,
130                                          char *snap_path)
131 {
132         return NT_STATUS_NOT_SUPPORTED;
133 }
134
135 DIR *vfs_not_implemented_fdopendir(vfs_handle_struct *handle, files_struct *fsp,
136                                    const char *mask, uint32_t attr)
137 {
138         errno = ENOSYS;
139         return NULL;
140 }
141
142 struct dirent *vfs_not_implemented_readdir(vfs_handle_struct *handle,
143                                            DIR *dirp, SMB_STRUCT_STAT *sbuf)
144 {
145         errno = ENOSYS;
146         return NULL;
147 }
148
149 void vfs_not_implemented_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
150 {
151         ;
152 }
153
154 long vfs_not_implemented_telldir(vfs_handle_struct *handle, DIR *dirp)
155 {
156         errno = ENOSYS;
157         return (long)-1;
158 }
159
160 void vfs_not_implemented_rewind_dir(vfs_handle_struct *handle, DIR *dirp)
161 {
162         ;
163 }
164
165 int vfs_not_implemented_mkdir(vfs_handle_struct *handle,
166                 const struct smb_filename *smb_fname,
167                 mode_t mode)
168 {
169         errno = ENOSYS;
170         return -1;
171 }
172
173 int vfs_not_implemented_rmdir(vfs_handle_struct *handle,
174                 const struct smb_filename *smb_fname)
175 {
176         errno = ENOSYS;
177         return -1;
178 }
179
180 int vfs_not_implemented_closedir(vfs_handle_struct *handle, DIR *dir)
181 {
182         errno = ENOSYS;
183         return -1;
184 }
185
186 int vfs_not_implemented_open(vfs_handle_struct *handle,
187                              struct smb_filename *smb_fname,
188                              files_struct *fsp, int flags, mode_t mode)
189 {
190         errno = ENOSYS;
191         return -1;
192 }
193
194 NTSTATUS vfs_not_implemented_create_file(struct vfs_handle_struct *handle,
195                                 struct smb_request *req,
196                                 uint16_t root_dir_fid,
197                                 struct smb_filename *smb_fname,
198                                 uint32_t access_mask,
199                                 uint32_t share_access,
200                                 uint32_t create_disposition,
201                                 uint32_t create_options,
202                                 uint32_t file_attributes,
203                                 uint32_t oplock_request,
204                                 struct smb2_lease *lease,
205                                 uint64_t allocation_size,
206                                 uint32_t private_flags,
207                                 struct security_descriptor *sd,
208                                 struct ea_list *ea_list,
209                                 files_struct **result, int *pinfo,
210                                 const struct smb2_create_blobs *in_context_blobs,
211                                 struct smb2_create_blobs *out_context_blobs)
212 {
213         return NT_STATUS_NOT_IMPLEMENTED;
214 }
215
216 int vfs_not_implemented_close_fn(vfs_handle_struct *handle, files_struct *fsp)
217 {
218         errno = ENOSYS;
219         return -1;
220 }
221
222 ssize_t vfs_not_implemented_pread(vfs_handle_struct *handle, files_struct *fsp,
223                                   void *data, size_t n, off_t offset)
224 {
225         errno = ENOSYS;
226         return -1;
227 }
228
229 struct tevent_req *vfs_not_implemented_pread_send(struct vfs_handle_struct *handle,
230                                                   TALLOC_CTX *mem_ctx,
231                                                   struct tevent_context *ev,
232                                                   struct files_struct *fsp,
233                                                   void *data, size_t n, off_t offset)
234 {
235         return NULL;
236 }
237
238 ssize_t vfs_not_implemented_pread_recv(struct tevent_req *req,
239                                        struct vfs_aio_state *vfs_aio_state)
240 {
241         vfs_aio_state->error = ENOSYS;
242         return -1;
243 }
244
245 ssize_t vfs_not_implemented_pwrite(vfs_handle_struct *handle, files_struct *fsp,
246                                    const void *data, size_t n, off_t offset)
247 {
248         errno = ENOSYS;
249         return -1;
250 }
251
252 struct tevent_req *vfs_not_implemented_pwrite_send(struct vfs_handle_struct *handle,
253                                                    TALLOC_CTX *mem_ctx,
254                                                    struct tevent_context *ev,
255                                                    struct files_struct *fsp,
256                                                    const void *data,
257                                                    size_t n, off_t offset)
258 {
259         return NULL;
260 }
261
262 ssize_t vfs_not_implemented_pwrite_recv(struct tevent_req *req,
263                                 struct vfs_aio_state *vfs_aio_state)
264 {
265         vfs_aio_state->error = ENOSYS;
266         return -1;
267 }
268
269 off_t vfs_not_implemented_lseek(vfs_handle_struct *handle, files_struct *fsp,
270                         off_t offset, int whence)
271 {
272         errno = ENOSYS;
273         return (off_t) - 1;
274 }
275
276 ssize_t vfs_not_implemented_sendfile(vfs_handle_struct *handle, int tofd,
277                                      files_struct *fromfsp, const DATA_BLOB *hdr,
278                                      off_t offset, size_t n)
279 {
280         errno = ENOSYS;
281         return -1;
282 }
283
284 ssize_t vfs_not_implemented_recvfile(vfs_handle_struct *handle, int fromfd,
285                                      files_struct *tofsp, off_t offset, size_t n)
286 {
287         errno = ENOSYS;
288         return -1;
289 }
290
291 int vfs_not_implemented_rename(vfs_handle_struct *handle,
292                                const struct smb_filename *smb_fname_src,
293                                const struct smb_filename *smb_fname_dst)
294 {
295         errno = ENOSYS;
296         return -1;
297 }
298
299 struct tevent_req *vfs_not_implemented_fsync_send(struct vfs_handle_struct *handle,
300                                                   TALLOC_CTX *mem_ctx,
301                                                   struct tevent_context *ev,
302                                                   struct files_struct *fsp)
303 {
304         return NULL;
305 }
306
307 int vfs_not_implemented_fsync_recv(struct tevent_req *req,
308                                    struct vfs_aio_state *vfs_aio_state)
309 {
310         vfs_aio_state->error = ENOSYS;
311         return -1;
312 }
313
314 int vfs_not_implemented_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
315 {
316         errno = ENOSYS;
317         return -1;
318 }
319
320 int vfs_not_implemented_fstat(vfs_handle_struct *handle, files_struct *fsp,
321                         SMB_STRUCT_STAT *sbuf)
322 {
323         errno = ENOSYS;
324         return -1;
325 }
326
327 int vfs_not_implemented_lstat(vfs_handle_struct *handle,
328                               struct smb_filename *smb_fname)
329 {
330         errno = ENOSYS;
331         return -1;
332 }
333
334 uint64_t vfs_not_implemented_get_alloc_size(struct vfs_handle_struct *handle,
335                                             struct files_struct *fsp,
336                                             const SMB_STRUCT_STAT *sbuf)
337 {
338         errno = ENOSYS;
339         return -1;
340 }
341
342 int vfs_not_implemented_unlink(vfs_handle_struct *handle,
343                                const struct smb_filename *smb_fname)
344 {
345         errno = ENOSYS;
346         return -1;
347 }
348
349 int vfs_not_implemented_chmod(vfs_handle_struct *handle,
350                               const struct smb_filename *smb_fname,
351                               mode_t mode)
352 {
353         errno = ENOSYS;
354         return -1;
355 }
356
357 int vfs_not_implemented_fchmod(vfs_handle_struct *handle, files_struct *fsp,
358                                mode_t mode)
359 {
360         errno = ENOSYS;
361         return -1;
362 }
363
364 int vfs_not_implemented_chown(vfs_handle_struct *handle,
365                               const struct smb_filename *smb_fname,
366                               uid_t uid,
367                               gid_t gid)
368 {
369         errno = ENOSYS;
370         return -1;
371 }
372
373 int vfs_not_implemented_fchown(vfs_handle_struct *handle, files_struct *fsp,
374                                uid_t uid, gid_t gid)
375 {
376         errno = ENOSYS;
377         return -1;
378 }
379
380 int vfs_not_implemented_lchown(vfs_handle_struct *handle,
381                                const struct smb_filename *smb_fname,
382                                uid_t uid,
383                                gid_t gid)
384 {
385         errno = ENOSYS;
386         return -1;
387 }
388
389 int vfs_not_implemented_chdir(vfs_handle_struct *handle,
390                               const struct smb_filename *smb_fname)
391 {
392         errno = ENOSYS;
393         return -1;
394 }
395
396 struct smb_filename *vfs_not_implemented_getwd(vfs_handle_struct *handle,
397                                                TALLOC_CTX *ctx)
398 {
399         errno = ENOSYS;
400         return NULL;
401 }
402
403 int vfs_not_implemented_ntimes(vfs_handle_struct *handle,
404                                const struct smb_filename *smb_fname,
405                                struct smb_file_time *ft)
406 {
407         errno = ENOSYS;
408         return -1;
409 }
410
411 int vfs_not_implemented_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
412                                   off_t offset)
413 {
414         errno = ENOSYS;
415         return -1;
416 }
417
418 int vfs_not_implemented_fallocate(vfs_handle_struct *handle, files_struct *fsp,
419                                   uint32_t mode, off_t offset, off_t len)
420 {
421         errno = ENOSYS;
422         return -1;
423 }
424
425 bool vfs_not_implemented_lock(vfs_handle_struct *handle, files_struct *fsp, int op,
426                               off_t offset, off_t count, int type)
427 {
428         errno = ENOSYS;
429         return false;
430 }
431
432 int vfs_not_implemented_kernel_flock(struct vfs_handle_struct *handle,
433                                      struct files_struct *fsp,
434                                      uint32_t share_mode, uint32_t access_mask)
435 {
436         errno = ENOSYS;
437         return -1;
438 }
439
440 int vfs_not_implemented_linux_setlease(struct vfs_handle_struct *handle,
441                                        struct files_struct *fsp, int leasetype)
442 {
443         errno = ENOSYS;
444         return -1;
445 }
446
447 bool vfs_not_implemented_getlock(vfs_handle_struct *handle, files_struct *fsp,
448                                  off_t *poffset, off_t *pcount, int *ptype,
449                                  pid_t *ppid)
450 {
451         errno = ENOSYS;
452         return false;
453 }
454
455 int vfs_not_implemented_symlink(vfs_handle_struct *handle,
456                                 const char *link_contents,
457                                 const struct smb_filename *new_smb_fname)
458 {
459         errno = ENOSYS;
460         return -1;
461 }
462
463 int vfs_not_implemented_vfs_readlink(vfs_handle_struct *handle,
464                                      const struct smb_filename *smb_fname,
465                                      char *buf,
466                                      size_t bufsiz)
467 {
468         errno = ENOSYS;
469         return -1;
470 }
471
472 int vfs_not_implemented_link(vfs_handle_struct *handle,
473                              const struct smb_filename *old_smb_fname,
474                              const struct smb_filename *new_smb_fname)
475 {
476         errno = ENOSYS;
477         return -1;
478 }
479
480 int vfs_not_implemented_mknod(vfs_handle_struct *handle,
481                               const struct smb_filename *smb_fname,
482                               mode_t mode,
483                               SMB_DEV_T dev)
484 {
485         errno = ENOSYS;
486         return -1;
487 }
488
489 struct smb_filename *vfs_not_implemented_realpath(vfs_handle_struct *handle,
490                                                   TALLOC_CTX *ctx,
491                                                   const struct smb_filename *smb_fname)
492 {
493         errno = ENOSYS;
494         return NULL;
495 }
496
497 int vfs_not_implemented_chflags(vfs_handle_struct *handle,
498                                 const struct smb_filename *smb_fname,
499                                 uint flags)
500 {
501         errno = ENOSYS;
502         return -1;
503 }
504
505 struct file_id vfs_not_implemented_file_id_create(vfs_handle_struct *handle,
506                                                   const SMB_STRUCT_STAT *sbuf)
507 {
508         struct file_id id;
509         ZERO_STRUCT(id);
510         errno = ENOSYS;
511         return id;
512 }
513
514 struct vfs_not_implemented_offload_read_state {
515         bool dummy;
516 };
517
518 struct tevent_req *vfs_not_implemented_offload_read_send(
519                         TALLOC_CTX *mem_ctx,
520                         struct tevent_context *ev,
521                         struct vfs_handle_struct *handle,
522                         struct files_struct *fsp,
523                         uint32_t fsctl,
524                         uint32_t ttl,
525                         off_t offset,
526                         size_t to_copy)
527 {
528         struct tevent_req *req = NULL;
529         struct vfs_not_implemented_offload_read_state *state = NULL;
530
531         req = tevent_req_create(mem_ctx, &state,
532                                 struct vfs_not_implemented_offload_read_state);
533         if (req == NULL) {
534                 return NULL;
535         }
536
537         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
538         return tevent_req_post(req, ev);
539 }
540
541 NTSTATUS vfs_not_implemented_offload_read_recv(struct tevent_req *req,
542                                        struct vfs_handle_struct *handle,
543                                        TALLOC_CTX *mem_ctx,
544                                        DATA_BLOB *_token_blob)
545 {
546         NTSTATUS status;
547
548         if (tevent_req_is_nterror(req, &status)) {
549                 tevent_req_received(req);
550                 return status;
551         }
552
553         tevent_req_received(req);
554         return NT_STATUS_OK;
555 }
556
557 struct vfs_not_implemented_offload_write_state {
558         uint64_t unused;
559 };
560
561 struct tevent_req *vfs_not_implemented_offload_write_send(
562                         struct vfs_handle_struct *handle,
563                         TALLOC_CTX *mem_ctx,
564                         struct tevent_context *ev,
565                         uint32_t fsctl,
566                         DATA_BLOB *token,
567                         off_t transfer_offset,
568                         struct files_struct *dest_fsp,
569                         off_t dest_off,
570                         off_t num)
571 {
572         struct tevent_req *req;
573         struct vfs_not_implemented_offload_write_state *state;
574
575         req = tevent_req_create(mem_ctx, &state,
576                                 struct vfs_not_implemented_offload_write_state);
577         if (req == NULL) {
578                 return NULL;
579         }
580
581         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
582         return tevent_req_post(req, ev);
583 }
584
585 NTSTATUS vfs_not_implemented_offload_write_recv(struct vfs_handle_struct *handle,
586                                                 struct tevent_req *req,
587                                                 off_t *copied)
588 {
589         NTSTATUS status;
590
591         if (tevent_req_is_nterror(req, &status)) {
592                 tevent_req_received(req);
593                 return status;
594         }
595
596         tevent_req_received(req);
597         return NT_STATUS_OK;
598 }
599
600 NTSTATUS vfs_not_implemented_get_compression(struct vfs_handle_struct *handle,
601                                              TALLOC_CTX *mem_ctx,
602                                              struct files_struct *fsp,
603                                              struct smb_filename *smb_fname,
604                                              uint16_t *_compression_fmt)
605 {
606         return NT_STATUS_INVALID_DEVICE_REQUEST;
607 }
608
609 NTSTATUS vfs_not_implemented_set_compression(struct vfs_handle_struct *handle,
610                                              TALLOC_CTX *mem_ctx,
611                                              struct files_struct *fsp,
612                                              uint16_t compression_fmt)
613 {
614         return NT_STATUS_INVALID_DEVICE_REQUEST;
615 }
616
617 NTSTATUS vfs_not_implemented_streaminfo(struct vfs_handle_struct *handle,
618                                         struct files_struct *fsp,
619                                         const struct smb_filename *smb_fname,
620                                         TALLOC_CTX *mem_ctx,
621                                         unsigned int *num_streams,
622                                         struct stream_struct **streams)
623 {
624         return NT_STATUS_NOT_IMPLEMENTED;
625 }
626
627 int vfs_not_implemented_get_real_filename(struct vfs_handle_struct *handle,
628                                           const char *path,
629                                           const char *name,
630                                           TALLOC_CTX *mem_ctx,
631                                           char **found_name)
632 {
633         errno = ENOSYS;
634         return -1;
635 }
636
637 const char *vfs_not_implemented_connectpath(struct vfs_handle_struct *handle,
638                                             const struct smb_filename *smb_fname)
639 {
640         errno = ENOSYS;
641         return NULL;
642 }
643
644 NTSTATUS vfs_not_implemented_brl_lock_windows(struct vfs_handle_struct *handle,
645                                               struct byte_range_lock *br_lck,
646                                               struct lock_struct *plock,
647                                               bool blocking_lock)
648 {
649         return NT_STATUS_NOT_IMPLEMENTED;
650 }
651
652 bool vfs_not_implemented_brl_unlock_windows(struct vfs_handle_struct *handle,
653                                             struct messaging_context *msg_ctx,
654                                             struct byte_range_lock *br_lck,
655                                             const struct lock_struct *plock)
656 {
657         errno = ENOSYS;
658         return false;
659 }
660
661 bool vfs_not_implemented_brl_cancel_windows(struct vfs_handle_struct *handle,
662                                             struct byte_range_lock *br_lck,
663                                             struct lock_struct *plock)
664 {
665         errno = ENOSYS;
666         return false;
667 }
668
669 bool vfs_not_implemented_strict_lock_check(struct vfs_handle_struct *handle,
670                                            struct files_struct *fsp,
671                                            struct lock_struct *plock)
672 {
673         errno = ENOSYS;
674         return false;
675 }
676
677 NTSTATUS vfs_not_implemented_translate_name(struct vfs_handle_struct *handle,
678                                             const char *mapped_name,
679                                             enum vfs_translate_direction direction,
680                                             TALLOC_CTX *mem_ctx, char **pmapped_name)
681 {
682         return NT_STATUS_NOT_IMPLEMENTED;
683 }
684
685 NTSTATUS vfs_not_implemented_fsctl(struct vfs_handle_struct *handle,
686                                    struct files_struct *fsp,
687                                    TALLOC_CTX *ctx,
688                                    uint32_t function,
689                                    uint16_t req_flags,  /* Needed for UNICODE ... */
690                                    const uint8_t *_in_data,
691                                    uint32_t in_len,
692                                    uint8_t **_out_data,
693                                    uint32_t max_out_len, uint32_t *out_len)
694 {
695         return NT_STATUS_NOT_IMPLEMENTED;
696 }
697
698 NTSTATUS vfs_not_implemented_readdir_attr(struct vfs_handle_struct *handle,
699                                           const struct smb_filename *fname,
700                                           TALLOC_CTX *mem_ctx,
701                                           struct readdir_attr_data **pattr_data)
702 {
703         return NT_STATUS_NOT_IMPLEMENTED;
704 }
705
706 NTSTATUS vfs_not_implemented_get_dos_attributes(struct vfs_handle_struct *handle,
707                                                 struct smb_filename *smb_fname,
708                                                 uint32_t *dosmode)
709 {
710         return NT_STATUS_NOT_IMPLEMENTED;
711 }
712
713 struct vfs_not_implemented_get_dos_attributes_state {
714         struct vfs_aio_state aio_state;
715         uint32_t dosmode;
716 };
717
718 struct tevent_req *vfs_not_implemented_get_dos_attributes_send(
719                         TALLOC_CTX *mem_ctx,
720                         const struct smb_vfs_ev_glue *evg,
721                         struct vfs_handle_struct *handle,
722                         files_struct *dir_fsp,
723                         struct smb_filename *smb_fname)
724 {
725         struct tevent_context *ev = smb_vfs_ev_glue_ev_ctx(evg);
726         struct tevent_req *req = NULL;
727         struct vfs_not_implemented_get_dos_attributes_state *state = NULL;
728
729         req = tevent_req_create(mem_ctx, &state,
730                         struct vfs_not_implemented_get_dos_attributes_state);
731         if (req == NULL) {
732                 return NULL;
733         }
734
735         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
736         return tevent_req_post(req, ev);
737 }
738
739 NTSTATUS vfs_not_implemented_get_dos_attributes_recv(
740                         struct tevent_req *req,
741                         struct vfs_aio_state *aio_state,
742                         uint32_t *dosmode)
743 {
744         struct vfs_not_implemented_get_dos_attributes_state *state =
745                 tevent_req_data(req,
746                 struct vfs_not_implemented_get_dos_attributes_state);
747         NTSTATUS status;
748
749         if (tevent_req_is_nterror(req, &status)) {
750                 tevent_req_received(req);
751                 return status;
752         }
753
754         *aio_state = state->aio_state;
755         *dosmode = state->dosmode;
756         tevent_req_received(req);
757         return NT_STATUS_OK;
758 }
759
760 NTSTATUS vfs_not_implemented_fget_dos_attributes(struct vfs_handle_struct *handle,
761                                                  struct files_struct *fsp,
762                                                  uint32_t *dosmode)
763 {
764         return NT_STATUS_NOT_IMPLEMENTED;
765 }
766
767 NTSTATUS vfs_not_implemented_set_dos_attributes(struct vfs_handle_struct *handle,
768                                                 const struct smb_filename *smb_fname,
769                                                 uint32_t dosmode)
770 {
771         return NT_STATUS_NOT_IMPLEMENTED;
772 }
773
774 NTSTATUS vfs_not_implemented_fset_dos_attributes(struct vfs_handle_struct *handle,
775                                                  struct files_struct *fsp,
776                                                  uint32_t dosmode)
777 {
778         return NT_STATUS_NOT_IMPLEMENTED;
779 }
780
781 NTSTATUS vfs_not_implemented_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
782                                          uint32_t security_info,
783                                          TALLOC_CTX *mem_ctx,
784                                          struct security_descriptor **ppdesc)
785 {
786         return NT_STATUS_NOT_IMPLEMENTED;
787 }
788
789 NTSTATUS vfs_not_implemented_get_nt_acl(vfs_handle_struct *handle,
790                                         const struct smb_filename *smb_fname,
791                                         uint32_t security_info,
792                                         TALLOC_CTX *mem_ctx,
793                                         struct security_descriptor **ppdesc)
794 {
795         return NT_STATUS_NOT_IMPLEMENTED;
796 }
797
798 NTSTATUS vfs_not_implemented_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
799                                          uint32_t security_info_sent,
800                                          const struct security_descriptor *psd)
801 {
802         return NT_STATUS_NOT_IMPLEMENTED;
803 }
804
805 SMB_ACL_T vfs_not_implemented_sys_acl_get_file(vfs_handle_struct *handle,
806                                                const struct smb_filename *smb_fname,
807                                                SMB_ACL_TYPE_T type,
808                                                TALLOC_CTX *mem_ctx)
809 {
810         errno = ENOSYS;
811         return (SMB_ACL_T) NULL;
812 }
813
814 SMB_ACL_T vfs_not_implemented_sys_acl_get_fd(vfs_handle_struct *handle,
815                                              files_struct *fsp, TALLOC_CTX *mem_ctx)
816 {
817         errno = ENOSYS;
818         return (SMB_ACL_T) NULL;
819 }
820
821 int vfs_not_implemented_sys_acl_blob_get_file(vfs_handle_struct *handle,
822                                 const struct smb_filename *smb_fname,
823                                 TALLOC_CTX *mem_ctx,
824                                 char **blob_description,
825                                 DATA_BLOB *blob)
826 {
827         errno = ENOSYS;
828         return -1;
829 }
830
831 int vfs_not_implemented_sys_acl_blob_get_fd(vfs_handle_struct *handle,
832                                 files_struct *fsp, TALLOC_CTX *mem_ctx,
833                                 char **blob_description, DATA_BLOB *blob)
834 {
835         errno = ENOSYS;
836         return -1;
837 }
838
839 int vfs_not_implemented_sys_acl_set_file(vfs_handle_struct *handle,
840                                 const struct smb_filename *smb_fname,
841                                 SMB_ACL_TYPE_T acltype,
842                                 SMB_ACL_T theacl)
843 {
844         errno = ENOSYS;
845         return -1;
846 }
847
848 int vfs_not_implemented_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
849                                        SMB_ACL_T theacl)
850 {
851         errno = ENOSYS;
852         return -1;
853 }
854
855 int vfs_not_implemented_sys_acl_delete_def_file(vfs_handle_struct *handle,
856                                         const struct smb_filename *smb_fname)
857 {
858         errno = ENOSYS;
859         return -1;
860 }
861
862 ssize_t vfs_not_implemented_getxattr(vfs_handle_struct *handle,
863                                 const struct smb_filename *smb_fname,
864                                 const char *name,
865                                 void *value,
866                                 size_t size)
867 {
868         errno = ENOSYS;
869         return -1;
870 }
871
872 struct vfs_not_implemented_getxattrat_state {
873         struct vfs_aio_state aio_state;
874         ssize_t xattr_size;
875         uint8_t *xattr_value;
876 };
877
878 struct tevent_req *vfs_not_implemented_getxattrat_send(
879                         TALLOC_CTX *mem_ctx,
880                         const struct smb_vfs_ev_glue *evg,
881                         struct vfs_handle_struct *handle,
882                         files_struct *dir_fsp,
883                         const struct smb_filename *smb_fname,
884                         const char *xattr_name,
885                         size_t alloc_hint)
886 {
887         struct tevent_context *ev = smb_vfs_ev_glue_ev_ctx(evg);
888         struct tevent_req *req = NULL;
889         struct vfs_not_implemented_getxattrat_state *state = NULL;
890
891         req = tevent_req_create(mem_ctx, &state,
892                                 struct vfs_not_implemented_getxattrat_state);
893         if (req == NULL) {
894                 return NULL;
895         }
896
897         tevent_req_error(req, ENOSYS);
898         return tevent_req_post(req, ev);
899 }
900
901 ssize_t vfs_not_implemented_getxattrat_recv(struct tevent_req *req,
902                                     struct vfs_aio_state *aio_state,
903                                     TALLOC_CTX *mem_ctx,
904                                     uint8_t **xattr_value)
905 {
906         struct vfs_not_implemented_getxattrat_state *state = tevent_req_data(
907                 req, struct vfs_not_implemented_getxattrat_state);
908         ssize_t xattr_size;
909
910         if (tevent_req_is_unix_error(req, &aio_state->error)) {
911                 tevent_req_received(req);
912                 return -1;
913         }
914
915         *aio_state = state->aio_state;
916         xattr_size = state->xattr_size;
917         if (xattr_value != NULL) {
918                 *xattr_value = talloc_move(mem_ctx, &state->xattr_value);
919         }
920
921         tevent_req_received(req);
922         return xattr_size;
923 }
924
925 ssize_t vfs_not_implemented_fgetxattr(vfs_handle_struct *handle,
926                               struct files_struct *fsp, const char *name,
927                               void *value, size_t size)
928 {
929         errno = ENOSYS;
930         return -1;
931 }
932
933 ssize_t vfs_not_implemented_listxattr(vfs_handle_struct *handle,
934                                       const struct smb_filename *smb_fname,
935                                       char *list,
936                                       size_t size)
937 {
938         errno = ENOSYS;
939         return -1;
940 }
941
942 ssize_t vfs_not_implemented_flistxattr(vfs_handle_struct *handle,
943                                        struct files_struct *fsp, char *list,
944                                        size_t size)
945 {
946         errno = ENOSYS;
947         return -1;
948 }
949
950 int vfs_not_implemented_removexattr(vfs_handle_struct *handle,
951                                     const struct smb_filename *smb_fname,
952                                     const char *name)
953 {
954         errno = ENOSYS;
955         return -1;
956 }
957
958 int vfs_not_implemented_fremovexattr(vfs_handle_struct *handle,
959                                      struct files_struct *fsp, const char *name)
960 {
961         errno = ENOSYS;
962         return -1;
963 }
964
965 int vfs_not_implemented_setxattr(vfs_handle_struct *handle,
966                                  const struct smb_filename *smb_fname,
967                                  const char *name,
968                                  const void *value,
969                                  size_t size,
970                                  int flags)
971 {
972         errno = ENOSYS;
973         return -1;
974 }
975
976 int vfs_not_implemented_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp,
977                                   const char *name, const void *value, size_t size,
978                                   int flags)
979 {
980         errno = ENOSYS;
981         return -1;
982 }
983
984 bool vfs_not_implemented_aio_force(struct vfs_handle_struct *handle,
985                                    struct files_struct *fsp)
986 {
987         errno = ENOSYS;
988         return false;
989 }
990
991 NTSTATUS vfs_not_implemented_audit_file(struct vfs_handle_struct *handle,
992                                         struct smb_filename *file,
993                                         struct security_acl *sacl,
994                                         uint32_t access_requested,
995                                         uint32_t access_denied)
996 {
997         return NT_STATUS_NOT_IMPLEMENTED;
998 }
999
1000 NTSTATUS vfs_not_implemented_durable_cookie(struct vfs_handle_struct *handle,
1001                                             struct files_struct *fsp,
1002                                             TALLOC_CTX *mem_ctx,
1003                                             DATA_BLOB *cookie)
1004 {
1005         return NT_STATUS_NOT_IMPLEMENTED;
1006 }
1007
1008 NTSTATUS vfs_not_implemented_durable_disconnect(struct vfs_handle_struct *handle,
1009                                                 struct files_struct *fsp,
1010                                                 const DATA_BLOB old_cookie,
1011                                                 TALLOC_CTX *mem_ctx,
1012                                                 DATA_BLOB *new_cookie)
1013 {
1014         return NT_STATUS_NOT_IMPLEMENTED;
1015 }
1016
1017 NTSTATUS vfs_not_implemented_durable_reconnect(struct vfs_handle_struct *handle,
1018                                                struct smb_request *smb1req,
1019                                                struct smbXsrv_open *op,
1020                                                const DATA_BLOB old_cookie,
1021                                                TALLOC_CTX *mem_ctx,
1022                                                struct files_struct **fsp,
1023                                                DATA_BLOB *new_cookie)
1024 {
1025         return NT_STATUS_NOT_IMPLEMENTED;
1026 }
1027
1028 /* VFS operations structure */
1029
1030 static struct vfs_fn_pointers vfs_not_implemented_fns = {
1031         /* Disk operations */
1032
1033         .connect_fn = vfs_not_implemented_connect,
1034         .disconnect_fn = vfs_not_implemented_disconnect,
1035         .disk_free_fn = vfs_not_implemented_disk_free,
1036         .get_quota_fn = vfs_not_implemented_get_quota,
1037         .set_quota_fn = vfs_not_implemented_set_quota,
1038         .get_shadow_copy_data_fn = vfs_not_implemented_get_shadow_copy_data,
1039         .statvfs_fn = vfs_not_implemented_statvfs,
1040         .fs_capabilities_fn = vfs_not_implemented_fs_capabilities,
1041         .get_dfs_referrals_fn = vfs_not_implemented_get_dfs_referrals,
1042         .snap_check_path_fn = vfs_not_implemented_snap_check_path,
1043         .snap_create_fn = vfs_not_implemented_snap_create,
1044         .snap_delete_fn = vfs_not_implemented_snap_delete,
1045
1046         /* Directory operations */
1047
1048         .opendir_fn = vfs_not_implemented_opendir,
1049         .fdopendir_fn = vfs_not_implemented_fdopendir,
1050         .readdir_fn = vfs_not_implemented_readdir,
1051         .seekdir_fn = vfs_not_implemented_seekdir,
1052         .telldir_fn = vfs_not_implemented_telldir,
1053         .rewind_dir_fn = vfs_not_implemented_rewind_dir,
1054         .mkdir_fn = vfs_not_implemented_mkdir,
1055         .rmdir_fn = vfs_not_implemented_rmdir,
1056         .closedir_fn = vfs_not_implemented_closedir,
1057
1058         /* File operations */
1059
1060         .open_fn = vfs_not_implemented_open,
1061         .create_file_fn = vfs_not_implemented_create_file,
1062         .close_fn = vfs_not_implemented_close_fn,
1063         .pread_fn = vfs_not_implemented_pread,
1064         .pread_send_fn = vfs_not_implemented_pread_send,
1065         .pread_recv_fn = vfs_not_implemented_pread_recv,
1066         .pwrite_fn = vfs_not_implemented_pwrite,
1067         .pwrite_send_fn = vfs_not_implemented_pwrite_send,
1068         .pwrite_recv_fn = vfs_not_implemented_pwrite_recv,
1069         .lseek_fn = vfs_not_implemented_lseek,
1070         .sendfile_fn = vfs_not_implemented_sendfile,
1071         .recvfile_fn = vfs_not_implemented_recvfile,
1072         .rename_fn = vfs_not_implemented_rename,
1073         .fsync_send_fn = vfs_not_implemented_fsync_send,
1074         .fsync_recv_fn = vfs_not_implemented_fsync_recv,
1075         .stat_fn = vfs_not_implemented_stat,
1076         .fstat_fn = vfs_not_implemented_fstat,
1077         .lstat_fn = vfs_not_implemented_lstat,
1078         .get_alloc_size_fn = vfs_not_implemented_get_alloc_size,
1079         .unlink_fn = vfs_not_implemented_unlink,
1080         .chmod_fn = vfs_not_implemented_chmod,
1081         .fchmod_fn = vfs_not_implemented_fchmod,
1082         .chown_fn = vfs_not_implemented_chown,
1083         .fchown_fn = vfs_not_implemented_fchown,
1084         .lchown_fn = vfs_not_implemented_lchown,
1085         .chdir_fn = vfs_not_implemented_chdir,
1086         .getwd_fn = vfs_not_implemented_getwd,
1087         .ntimes_fn = vfs_not_implemented_ntimes,
1088         .ftruncate_fn = vfs_not_implemented_ftruncate,
1089         .fallocate_fn = vfs_not_implemented_fallocate,
1090         .lock_fn = vfs_not_implemented_lock,
1091         .kernel_flock_fn = vfs_not_implemented_kernel_flock,
1092         .linux_setlease_fn = vfs_not_implemented_linux_setlease,
1093         .getlock_fn = vfs_not_implemented_getlock,
1094         .symlink_fn = vfs_not_implemented_symlink,
1095         .readlink_fn = vfs_not_implemented_vfs_readlink,
1096         .link_fn = vfs_not_implemented_link,
1097         .mknod_fn = vfs_not_implemented_mknod,
1098         .realpath_fn = vfs_not_implemented_realpath,
1099         .chflags_fn = vfs_not_implemented_chflags,
1100         .file_id_create_fn = vfs_not_implemented_file_id_create,
1101         .offload_read_send_fn = vfs_not_implemented_offload_read_send,
1102         .offload_read_recv_fn = vfs_not_implemented_offload_read_recv,
1103         .offload_write_send_fn = vfs_not_implemented_offload_write_send,
1104         .offload_write_recv_fn = vfs_not_implemented_offload_write_recv,
1105         .get_compression_fn = vfs_not_implemented_get_compression,
1106         .set_compression_fn = vfs_not_implemented_set_compression,
1107
1108         .streaminfo_fn = vfs_not_implemented_streaminfo,
1109         .get_real_filename_fn = vfs_not_implemented_get_real_filename,
1110         .connectpath_fn = vfs_not_implemented_connectpath,
1111         .brl_lock_windows_fn = vfs_not_implemented_brl_lock_windows,
1112         .brl_unlock_windows_fn = vfs_not_implemented_brl_unlock_windows,
1113         .brl_cancel_windows_fn = vfs_not_implemented_brl_cancel_windows,
1114         .strict_lock_check_fn = vfs_not_implemented_strict_lock_check,
1115         .translate_name_fn = vfs_not_implemented_translate_name,
1116         .fsctl_fn = vfs_not_implemented_fsctl,
1117         .readdir_attr_fn = vfs_not_implemented_readdir_attr,
1118         .audit_file_fn = vfs_not_implemented_audit_file,
1119
1120         /* DOS attributes. */
1121         .get_dos_attributes_fn = vfs_not_implemented_get_dos_attributes,
1122         .get_dos_attributes_send_fn = vfs_not_implemented_get_dos_attributes_send,
1123         .get_dos_attributes_recv_fn = vfs_not_implemented_get_dos_attributes_recv,
1124         .fget_dos_attributes_fn = vfs_not_implemented_fget_dos_attributes,
1125         .set_dos_attributes_fn = vfs_not_implemented_set_dos_attributes,
1126         .fset_dos_attributes_fn = vfs_not_implemented_fset_dos_attributes,
1127
1128         /* NT ACL operations. */
1129
1130         .fget_nt_acl_fn = vfs_not_implemented_fget_nt_acl,
1131         .get_nt_acl_fn = vfs_not_implemented_get_nt_acl,
1132         .fset_nt_acl_fn = vfs_not_implemented_fset_nt_acl,
1133
1134         /* POSIX ACL operations. */
1135
1136         .sys_acl_get_file_fn = vfs_not_implemented_sys_acl_get_file,
1137         .sys_acl_get_fd_fn = vfs_not_implemented_sys_acl_get_fd,
1138         .sys_acl_blob_get_file_fn = vfs_not_implemented_sys_acl_blob_get_file,
1139         .sys_acl_blob_get_fd_fn = vfs_not_implemented_sys_acl_blob_get_fd,
1140         .sys_acl_set_file_fn = vfs_not_implemented_sys_acl_set_file,
1141         .sys_acl_set_fd_fn = vfs_not_implemented_sys_acl_set_fd,
1142         .sys_acl_delete_def_file_fn = vfs_not_implemented_sys_acl_delete_def_file,
1143
1144         /* EA operations. */
1145         .getxattr_fn = vfs_not_implemented_getxattr,
1146         .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
1147         .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
1148         .fgetxattr_fn = vfs_not_implemented_fgetxattr,
1149         .listxattr_fn = vfs_not_implemented_listxattr,
1150         .flistxattr_fn = vfs_not_implemented_flistxattr,
1151         .removexattr_fn = vfs_not_implemented_removexattr,
1152         .fremovexattr_fn = vfs_not_implemented_fremovexattr,
1153         .setxattr_fn = vfs_not_implemented_setxattr,
1154         .fsetxattr_fn = vfs_not_implemented_fsetxattr,
1155
1156         /* aio operations */
1157         .aio_force_fn = vfs_not_implemented_aio_force,
1158
1159         /* durable handle operations */
1160         .durable_cookie_fn = vfs_not_implemented_durable_cookie,
1161         .durable_disconnect_fn = vfs_not_implemented_durable_disconnect,
1162         .durable_reconnect_fn = vfs_not_implemented_durable_reconnect,
1163 };
1164
1165 static_decl_vfs;
1166 NTSTATUS vfs_not_implemented_init(TALLOC_CTX *ctx)
1167 {
1168         /*
1169          * smb_vfs_assert_all_fns() makes sure every
1170          * call is implemented.
1171          */
1172         smb_vfs_assert_all_fns(&vfs_not_implemented_fns, "vfs_not_implemented");
1173         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "vfs_not_implemented",
1174                                 &vfs_not_implemented_fns);
1175 }