?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb: Accept the key in hex format for the pstore command
[Samba.git] / source3 / modules / vfs_default.c
blob69826348d5c92b82d4157970fc87b4bf3b58352d
1 /*
2 Unix SMB/CIFS implementation.
3 Wrap disk only vfs functions to sidestep dodgy compilers.
4 Copyright (C) Tim Potter 1998
5 Copyright (C) Jeremy Allison 2007
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "system/time.h"
23 #include "system/filesys.h"
24 #include "smbd/smbd.h"
25 #include "smbd/globals.h"
26 #include "ntioctl.h"
27 #include "smbprofile.h"
28 #include "../libcli/security/security.h"
29 #include "passdb/lookup_sid.h"
30 #include "source3/include/msdfs.h"
31 #include "librpc/gen_ndr/ndr_dfsblobs.h"
32 #include "lib/util/tevent_unix.h"
33 #include "lib/asys/asys.h"
34 #include "lib/util/tevent_ntstatus.h"
35 #include "lib/sys_rw.h"
36
37 #undef DBGC_CLASS
38 #define DBGC_CLASS DBGC_VFS
39
40 /* Check for NULL pointer parameters in vfswrap_* functions */
41
42 /* We don't want to have NULL function pointers lying around. Someone
43 is sure to try and execute them. These stubs are used to prevent
44 this possibility. */
45
46 static int vfswrap_connect(vfs_handle_struct *handle, const char *service, const char *user)
47 {
48 return 0; /* Return >= 0 for success */
49 }
50
51 static void vfswrap_disconnect(vfs_handle_struct *handle)
52 {
53 }
54
55 /* Disk operations */
56
57 static uint64_t vfswrap_disk_free(vfs_handle_struct *handle, const char *path,
58 uint64_t *bsize, uint64_t *dfree,
59 uint64_t *dsize)
60 {
61 uint64_t result;
62
63 result = sys_disk_free(handle->conn, path, bsize, dfree, dsize);
64 return result;
65 }
66
67 static int vfswrap_get_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
68 {
69 #ifdef HAVE_SYS_QUOTAS
70 int result;
71
72 START_PROFILE(syscall_get_quota);
73 result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
74 END_PROFILE(syscall_get_quota);
75 return result;
76 #else
77 errno = ENOSYS;
78 return -1;
79 #endif
80 }
81
82 static int vfswrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
83 {
84 #ifdef HAVE_SYS_QUOTAS
85 int result;
86
87 START_PROFILE(syscall_set_quota);
88 result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
89 END_PROFILE(syscall_set_quota);
90 return result;
91 #else
92 errno = ENOSYS;
93 return -1;
94 #endif
95 }
96
97 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
98 struct files_struct *fsp,
99 struct shadow_copy_data *shadow_copy_data,
100 bool labels)
101 {
102 errno = ENOSYS;
103 return -1; /* Not implemented. */
104 }
105
106 static int vfswrap_statvfs(struct vfs_handle_struct *handle, const char *path, vfs_statvfs_struct *statbuf)
107 {
108 return sys_statvfs(path, statbuf);
109 }
110
111 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
112 enum timestamp_set_resolution *p_ts_res)
113 {
114 connection_struct *conn = handle->conn;
115 uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
116 struct smb_filename *smb_fname_cpath = NULL;
117 struct vfs_statvfs_struct statbuf;
118 int ret;
119
120 ZERO_STRUCT(statbuf);
121 ret = sys_statvfs(conn->connectpath, &statbuf);
122 if (ret == 0) {
123 caps = statbuf.FsCapabilities;
124 }
125
126 *p_ts_res = TIMESTAMP_SET_SECONDS;
127
128 /* Work out what timestamp resolution we can
129 * use when setting a timestamp. */
130
131 smb_fname_cpath = synthetic_smb_fname(talloc_tos(), conn->connectpath,
132 NULL, NULL);
133 if (smb_fname_cpath == NULL) {
134 return caps;
135 }
136
137 ret = SMB_VFS_STAT(conn, smb_fname_cpath);
138 if (ret == -1) {
139 TALLOC_FREE(smb_fname_cpath);
140 return caps;
141 }
142
143 if (smb_fname_cpath->st.st_ex_mtime.tv_nsec ||
144 smb_fname_cpath->st.st_ex_atime.tv_nsec ||
145 smb_fname_cpath->st.st_ex_ctime.tv_nsec) {
146 /* If any of the normal UNIX directory timestamps
147 * have a non-zero tv_nsec component assume
148 * we might be able to set sub-second timestamps.
149 * See what filetime set primitives we have.
150 */
151 #if defined(HAVE_UTIMENSAT)
152 *p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
153 #elif defined(HAVE_UTIMES)
154 /* utimes allows msec timestamps to be set. */
155 *p_ts_res = TIMESTAMP_SET_MSEC;
156 #elif defined(HAVE_UTIME)
157 /* utime only allows sec timestamps to be set. */
158 *p_ts_res = TIMESTAMP_SET_SECONDS;
159 #endif
160
161 DEBUG(10,("vfswrap_fs_capabilities: timestamp "
162 "resolution of %s "
163 "available on share %s, directory %s\n",
164 *p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
165 lp_servicename(talloc_tos(), conn->params->service),
166 conn->connectpath ));
167 }
168 TALLOC_FREE(smb_fname_cpath);
169 return caps;
170 }
171
172 static NTSTATUS vfswrap_get_dfs_referrals(struct vfs_handle_struct *handle,
173 struct dfs_GetDFSReferral *r)
174 {
175 struct junction_map *junction = NULL;
176 int consumedcnt = 0;
177 bool self_referral = false;
178 char *pathnamep = NULL;
179 char *local_dfs_path = NULL;
180 NTSTATUS status;
181 int i;
182 uint16_t max_referral_level = r->in.req.max_referral_level;
183
184 if (DEBUGLVL(10)) {
185 NDR_PRINT_IN_DEBUG(dfs_GetDFSReferral, r);
186 }
187
188 /* get the junction entry */
189 if (r->in.req.servername == NULL) {
190 return NT_STATUS_NOT_FOUND;
191 }
192
193 /*
194 * Trim pathname sent by client so it begins with only one backslash.
195 * Two backslashes confuse some dfs clients
196 */
197
198 local_dfs_path = talloc_strdup(r, r->in.req.servername);
199 if (local_dfs_path == NULL) {
200 return NT_STATUS_NO_MEMORY;
201 }
202 pathnamep = local_dfs_path;
203 while (IS_DIRECTORY_SEP(pathnamep[0]) &&
204 IS_DIRECTORY_SEP(pathnamep[1])) {
205 pathnamep++;
206 }
207
208 junction = talloc_zero(r, struct junction_map);
209 if (junction == NULL) {
210 return NT_STATUS_NO_MEMORY;
211 }
212
213 /* The following call can change cwd. */
214 status = get_referred_path(r, pathnamep,
215 !handle->conn->sconn->using_smb2,
216 junction, &consumedcnt, &self_referral);
217 if (!NT_STATUS_IS_OK(status)) {
218 vfs_ChDir(handle->conn, handle->conn->connectpath);
219 return status;
220 }
221 vfs_ChDir(handle->conn, handle->conn->connectpath);
222
223 if (!self_referral) {
224 pathnamep[consumedcnt] = '\0';
225
226 if (DEBUGLVL(3)) {
227 dbgtext("Path %s to alternate path(s):",
228 pathnamep);
229 for (i=0; i < junction->referral_count; i++) {
230 dbgtext(" %s",
231 junction->referral_list[i].alternate_path);
232 }
233 dbgtext(".\n");
234 }
235 }
236
237 if (r->in.req.max_referral_level <= 2) {
238 max_referral_level = 2;
239 }
240 if (r->in.req.max_referral_level >= 3) {
241 max_referral_level = 3;
242 }
243
244 r->out.resp = talloc_zero(r, struct dfs_referral_resp);
245 if (r->out.resp == NULL) {
246 return NT_STATUS_NO_MEMORY;
247 }
248
249 r->out.resp->path_consumed = strlen_m(pathnamep) * 2;
250 r->out.resp->nb_referrals = junction->referral_count;
251
252 r->out.resp->header_flags = DFS_HEADER_FLAG_STORAGE_SVR;
253 if (self_referral) {
254 r->out.resp->header_flags |= DFS_HEADER_FLAG_REFERAL_SVR;
255 }
256
257 r->out.resp->referral_entries = talloc_zero_array(r,
258 struct dfs_referral_type,
259 r->out.resp->nb_referrals);
260 if (r->out.resp->referral_entries == NULL) {
261 return NT_STATUS_NO_MEMORY;
262 }
263
264 switch (max_referral_level) {
265 case 2:
266 for(i=0; i < junction->referral_count; i++) {
267 struct referral *ref = &junction->referral_list[i];
268 TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
269 struct dfs_referral_type *t =
270 &r->out.resp->referral_entries[i];
271 struct dfs_referral_v2 *v2 = &t->referral.v2;
272
273 t->version = 2;
274 v2->size = VERSION2_REFERRAL_SIZE;
275 if (self_referral) {
276 v2->server_type = DFS_SERVER_ROOT;
277 } else {
278 v2->server_type = DFS_SERVER_NON_ROOT;
279 }
280 v2->entry_flags = 0;
281 v2->proximity = ref->proximity;
282 v2->ttl = ref->ttl;
283 v2->DFS_path = talloc_strdup(mem_ctx, pathnamep);
284 if (v2->DFS_path == NULL) {
285 return NT_STATUS_NO_MEMORY;
286 }
287 v2->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
288 if (v2->DFS_alt_path == NULL) {
289 return NT_STATUS_NO_MEMORY;
290 }
291 v2->netw_address = talloc_strdup(mem_ctx,
292 ref->alternate_path);
293 if (v2->netw_address == NULL) {
294 return NT_STATUS_NO_MEMORY;
295 }
296 }
297
298 break;
299 case 3:
300 for(i=0; i < junction->referral_count; i++) {
301 struct referral *ref = &junction->referral_list[i];
302 TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
303 struct dfs_referral_type *t =
304 &r->out.resp->referral_entries[i];
305 struct dfs_referral_v3 *v3 = &t->referral.v3;
306 struct dfs_normal_referral *r1 = &v3->referrals.r1;
307
308 t->version = 3;
309 v3->size = VERSION3_REFERRAL_SIZE;
310 if (self_referral) {
311 v3->server_type = DFS_SERVER_ROOT;
312 } else {
313 v3->server_type = DFS_SERVER_NON_ROOT;
314 }
315 v3->entry_flags = 0;
316 v3->ttl = ref->ttl;
317 r1->DFS_path = talloc_strdup(mem_ctx, pathnamep);
318 if (r1->DFS_path == NULL) {
319 return NT_STATUS_NO_MEMORY;
320 }
321 r1->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
322 if (r1->DFS_alt_path == NULL) {
323 return NT_STATUS_NO_MEMORY;
324 }
325 r1->netw_address = talloc_strdup(mem_ctx,
326 ref->alternate_path);
327 if (r1->netw_address == NULL) {
328 return NT_STATUS_NO_MEMORY;
329 }
330 }
331 break;
332 default:
333 DEBUG(0,("Invalid dfs referral version: %d\n",
334 max_referral_level));
335 return NT_STATUS_INVALID_LEVEL;
336 }
337
338 if (DEBUGLVL(10)) {
339 NDR_PRINT_OUT_DEBUG(dfs_GetDFSReferral, r);
340 }
341
342 return NT_STATUS_OK;
343 }
344
345 static NTSTATUS vfswrap_snap_check_path(struct vfs_handle_struct *handle,
346 TALLOC_CTX *mem_ctx,
347 const char *service_path,
348 char **base_volume)
349 {
350 return NT_STATUS_NOT_SUPPORTED;
351 }
352
353 static NTSTATUS vfswrap_snap_create(struct vfs_handle_struct *handle,
354 TALLOC_CTX *mem_ctx,
355 const char *base_volume,
356 time_t *tstamp,
357 bool rw,
358 char **base_path,
359 char **snap_path)
360 {
361 return NT_STATUS_NOT_SUPPORTED;
362 }
363
364 static NTSTATUS vfswrap_snap_delete(struct vfs_handle_struct *handle,
365 TALLOC_CTX *mem_ctx,
366 char *base_path,
367 char *snap_path)
368 {
369 return NT_STATUS_NOT_SUPPORTED;
370 }
371
372 /* Directory operations */
373
374 static DIR *vfswrap_opendir(vfs_handle_struct *handle, const char *fname, const char *mask, uint32_t attr)
375 {
376 DIR *result;
377
378 START_PROFILE(syscall_opendir);
379 result = opendir(fname);
380 END_PROFILE(syscall_opendir);
381 return result;
382 }
383
384 static DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
385 files_struct *fsp,
386 const char *mask,
387 uint32_t attr)
388 {
389 DIR *result;
390
391 START_PROFILE(syscall_fdopendir);
392 result = sys_fdopendir(fsp->fh->fd);
393 END_PROFILE(syscall_fdopendir);
394 return result;
395 }
396
397
398 static struct dirent *vfswrap_readdir(vfs_handle_struct *handle,
399 DIR *dirp,
400 SMB_STRUCT_STAT *sbuf)
401 {
402 struct dirent *result;
403
404 START_PROFILE(syscall_readdir);
405 result = readdir(dirp);
406 END_PROFILE(syscall_readdir);
407 if (sbuf) {
408 /* Default Posix readdir() does not give us stat info.
409 * Set to invalid to indicate we didn't return this info. */
410 SET_STAT_INVALID(*sbuf);
411 #if defined(HAVE_DIRFD) && defined(HAVE_FSTATAT)
412 if (result != NULL) {
413 /* See if we can efficiently return this. */
414 struct stat st;
415 int flags = (lp_posix_pathnames() ?
416 AT_SYMLINK_NOFOLLOW : 0);
417 int ret = fstatat(dirfd(dirp),
418 result->d_name,
419 &st,
420 flags);
421 if (ret == 0) {
422 init_stat_ex_from_stat(sbuf,
423 &st,
424 lp_fake_directory_create_times(
425 SNUM(handle->conn)));
426 }
427 }
428 #endif
429 }
430 return result;
431 }
432
433 static NTSTATUS vfswrap_readdir_attr(struct vfs_handle_struct *handle,
434 const struct smb_filename *fname,
435 TALLOC_CTX *mem_ctx,
436 struct readdir_attr_data **attr_data)
437 {
438 return NT_STATUS_NOT_SUPPORTED;
439 }
440
441 static void vfswrap_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
442 {
443 START_PROFILE(syscall_seekdir);
444 seekdir(dirp, offset);
445 END_PROFILE(syscall_seekdir);
446 }
447
448 static long vfswrap_telldir(vfs_handle_struct *handle, DIR *dirp)
449 {
450 long result;
451 START_PROFILE(syscall_telldir);
452 result = telldir(dirp);
453 END_PROFILE(syscall_telldir);
454 return result;
455 }
456
457 static void vfswrap_rewinddir(vfs_handle_struct *handle, DIR *dirp)
458 {
459 START_PROFILE(syscall_rewinddir);
460 rewinddir(dirp);
461 END_PROFILE(syscall_rewinddir);
462 }
463
464 static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
465 {
466 int result;
467 bool has_dacl = False;
468 char *parent = NULL;
469
470 START_PROFILE(syscall_mkdir);
471
472 if (lp_inherit_acls(SNUM(handle->conn))
473 && parent_dirname(talloc_tos(), path, &parent, NULL)
474 && (has_dacl = directory_has_default_acl(handle->conn, parent)))
475 mode = (0777 & lp_directory_mask(SNUM(handle->conn)));
476
477 TALLOC_FREE(parent);
478
479 result = mkdir(path, mode);
480
481 if (result == 0 && !has_dacl) {
482 /*
483 * We need to do this as the default behavior of POSIX ACLs
484 * is to set the mask to be the requested group permission
485 * bits, not the group permission bits to be the requested
486 * group permission bits. This is not what we want, as it will
487 * mess up any inherited ACL bits that were set. JRA.
488 */
489 int saved_errno = errno; /* We may get ENOSYS */
490 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
491 errno = saved_errno;
492 }
493
494 END_PROFILE(syscall_mkdir);
495 return result;
496 }
497
498 static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
499 {
500 int result;
501
502 START_PROFILE(syscall_rmdir);
503 result = rmdir(path);
504 END_PROFILE(syscall_rmdir);
505 return result;
506 }
507
508 static int vfswrap_closedir(vfs_handle_struct *handle, DIR *dirp)
509 {
510 int result;
511
512 START_PROFILE(syscall_closedir);
513 result = closedir(dirp);
514 END_PROFILE(syscall_closedir);
515 return result;
516 }
517
518 static void vfswrap_init_search_op(vfs_handle_struct *handle,
519 DIR *dirp)
520 {
521 /* Default behavior is a NOOP */
522 }
523
524 /* File operations */
525
526 static int vfswrap_open(vfs_handle_struct *handle,
527 struct smb_filename *smb_fname,
528 files_struct *fsp, int flags, mode_t mode)
529 {
530 int result = -1;
531
532 START_PROFILE(syscall_open);
533
534 if (smb_fname->stream_name) {
535 errno = ENOENT;
536 goto out;
537 }
538
539 result = open(smb_fname->base_name, flags, mode);
540 out:
541 END_PROFILE(syscall_open);
542 return result;
543 }
544
545 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
546 struct smb_request *req,
547 uint16_t root_dir_fid,
548 struct smb_filename *smb_fname,
549 uint32_t access_mask,
550 uint32_t share_access,
551 uint32_t create_disposition,
552 uint32_t create_options,
553 uint32_t file_attributes,
554 uint32_t oplock_request,
555 struct smb2_lease *lease,
556 uint64_t allocation_size,
557 uint32_t private_flags,
558 struct security_descriptor *sd,
559 struct ea_list *ea_list,
560 files_struct **result,
561 int *pinfo,
562 const struct smb2_create_blobs *in_context_blobs,
563 struct smb2_create_blobs *out_context_blobs)
564 {
565 return create_file_default(handle->conn, req, root_dir_fid, smb_fname,
566 access_mask, share_access,
567 create_disposition, create_options,
568 file_attributes, oplock_request, lease,
569 allocation_size, private_flags,
570 sd, ea_list, result,
571 pinfo, in_context_blobs, out_context_blobs);
572 }
573
574 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
575 {
576 int result;
577
578 START_PROFILE(syscall_close);
579 result = fd_close_posix(fsp);
580 END_PROFILE(syscall_close);
581 return result;
582 }
583
584 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
585 {
586 ssize_t result;
587
588 START_PROFILE_BYTES(syscall_read, n);
589 result = sys_read(fsp->fh->fd, data, n);
590 END_PROFILE_BYTES(syscall_read);
591 return result;
592 }
593
594 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
595 size_t n, off_t offset)
596 {
597 ssize_t result;
598
599 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
600 START_PROFILE_BYTES(syscall_pread, n);
601 result = sys_pread(fsp->fh->fd, data, n, offset);
602 END_PROFILE_BYTES(syscall_pread);
603
604 if (result == -1 && errno == ESPIPE) {
605 /* Maintain the fiction that pipes can be seeked (sought?) on. */
606 result = SMB_VFS_READ(fsp, data, n);
607 fsp->fh->pos = 0;
608 }
609
610 #else /* HAVE_PREAD */
611 off_t curr;
612 int lerrno;
613
614 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
615 if (curr == -1 && errno == ESPIPE) {
616 /* Maintain the fiction that pipes can be seeked (sought?) on. */
617 result = SMB_VFS_READ(fsp, data, n);
618 fsp->fh->pos = 0;
619 return result;
620 }
621
622 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
623 return -1;
624 }
625
626 errno = 0;
627 result = SMB_VFS_READ(fsp, data, n);
628 lerrno = errno;
629
630 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
631 errno = lerrno;
632
633 #endif /* HAVE_PREAD */
634
635 return result;
636 }
637
638 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
639 {
640 ssize_t result;
641
642 START_PROFILE_BYTES(syscall_write, n);
643 result = sys_write(fsp->fh->fd, data, n);
644 END_PROFILE_BYTES(syscall_write);
645 return result;
646 }
647
648 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
649 size_t n, off_t offset)
650 {
651 ssize_t result;
652
653 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
654 START_PROFILE_BYTES(syscall_pwrite, n);
655 result = sys_pwrite(fsp->fh->fd, data, n, offset);
656 END_PROFILE_BYTES(syscall_pwrite);
657
658 if (result == -1 && errno == ESPIPE) {
659 /* Maintain the fiction that pipes can be sought on. */
660 result = SMB_VFS_WRITE(fsp, data, n);
661 }
662
663 #else /* HAVE_PWRITE */
664 off_t curr;
665 int lerrno;
666
667 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
668 if (curr == -1) {
669 return -1;
670 }
671
672 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
673 return -1;
674 }
675
676 result = SMB_VFS_WRITE(fsp, data, n);
677 lerrno = errno;
678
679 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
680 errno = lerrno;
681
682 #endif /* HAVE_PWRITE */
683
684 return result;
685 }
686
687 static void vfswrap_asys_finished(struct tevent_context *ev,
688 struct tevent_fd *fde,
689 uint16_t flags, void *p);
690
691 static bool vfswrap_init_asys_ctx(struct smbd_server_connection *conn)
692 {
693 int ret;
694 int fd;
695
696 if (conn->asys_ctx != NULL) {
697 return true;
698 }
699 ret = asys_context_init(&conn->asys_ctx, aio_pending_size);
700 if (ret != 0) {
701 DEBUG(1, ("asys_context_init failed: %s\n", strerror(ret)));
702 return false;
703 }
704
705 fd = asys_signalfd(conn->asys_ctx);
706
707 set_blocking(fd, false);
708
709 conn->asys_fde = tevent_add_fd(conn->ev_ctx, conn, fd,
710 TEVENT_FD_READ,
711 vfswrap_asys_finished,
712 conn->asys_ctx);
713 if (conn->asys_fde == NULL) {
714 DEBUG(1, ("tevent_add_fd failed\n"));
715 asys_context_destroy(conn->asys_ctx);
716 conn->asys_ctx = NULL;
717 return false;
718 }
719 return true;
720 }
721
722 struct vfswrap_asys_state {
723 struct asys_context *asys_ctx;
724 struct tevent_req *req;
725 ssize_t ret;
726 int err;
727 SMBPROFILE_BASIC_ASYNC_STATE(profile_basic);
728 SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
729 };
730
731 static int vfswrap_asys_state_destructor(struct vfswrap_asys_state *s)
732 {
733 asys_cancel(s->asys_ctx, s->req);
734 return 0;
735 }
736
737 static struct tevent_req *vfswrap_pread_send(struct vfs_handle_struct *handle,
738 TALLOC_CTX *mem_ctx,
739 struct tevent_context *ev,
740 struct files_struct *fsp,
741 void *data,
742 size_t n, off_t offset)
743 {
744 struct tevent_req *req;
745 struct vfswrap_asys_state *state;
746 int ret;
747
748 req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
749 if (req == NULL) {
750 return NULL;
751 }
752 if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
753 tevent_req_oom(req);
754 return tevent_req_post(req, ev);
755 }
756 state->asys_ctx = handle->conn->sconn->asys_ctx;
757 state->req = req;
758
759 SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pread, profile_p,
760 state->profile_bytes, n);
761 ret = asys_pread(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
762 if (ret != 0) {
763 tevent_req_error(req, ret);
764 return tevent_req_post(req, ev);
765 }
766 talloc_set_destructor(state, vfswrap_asys_state_destructor);
767
768 return req;
769 }
770
771 static struct tevent_req *vfswrap_pwrite_send(struct vfs_handle_struct *handle,
772 TALLOC_CTX *mem_ctx,
773 struct tevent_context *ev,
774 struct files_struct *fsp,
775 const void *data,
776 size_t n, off_t offset)
777 {
778 struct tevent_req *req;
779 struct vfswrap_asys_state *state;
780 int ret;
781
782 req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
783 if (req == NULL) {
784 return NULL;
785 }
786 if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
787 tevent_req_oom(req);
788 return tevent_req_post(req, ev);
789 }
790 state->asys_ctx = handle->conn->sconn->asys_ctx;
791 state->req = req;
792
793 SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pwrite, profile_p,
794 state->profile_bytes, n);
795 ret = asys_pwrite(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
796 if (ret != 0) {
797 tevent_req_error(req, ret);
798 return tevent_req_post(req, ev);
799 }
800 talloc_set_destructor(state, vfswrap_asys_state_destructor);
801
802 return req;
803 }
804
805 static struct tevent_req *vfswrap_fsync_send(struct vfs_handle_struct *handle,
806 TALLOC_CTX *mem_ctx,
807 struct tevent_context *ev,
808 struct files_struct *fsp)
809 {
810 struct tevent_req *req;
811 struct vfswrap_asys_state *state;
812 int ret;
813
814 req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
815 if (req == NULL) {
816 return NULL;
817 }
818 if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
819 tevent_req_oom(req);
820 return tevent_req_post(req, ev);
821 }
822 state->asys_ctx = handle->conn->sconn->asys_ctx;
823 state->req = req;
824
825 SMBPROFILE_BASIC_ASYNC_START(syscall_asys_fsync, profile_p,
826 state->profile_basic);
827 ret = asys_fsync(state->asys_ctx, fsp->fh->fd, req);
828 if (ret != 0) {
829 tevent_req_error(req, ret);
830 return tevent_req_post(req, ev);
831 }
832 talloc_set_destructor(state, vfswrap_asys_state_destructor);
833
834 return req;
835 }
836
837 static void vfswrap_asys_finished(struct tevent_context *ev,
838 struct tevent_fd *fde,
839 uint16_t flags, void *p)
840 {
841 struct asys_context *asys_ctx = (struct asys_context *)p;
842 struct asys_result results[outstanding_aio_calls];
843 int i, ret;
844
845 if ((flags & TEVENT_FD_READ) == 0) {
846 return;
847 }
848
849 ret = asys_results(asys_ctx, results, outstanding_aio_calls);
850 if (ret < 0) {
851 DEBUG(1, ("asys_results returned %s\n", strerror(-ret)));
852 return;
853 }
854
855 for (i=0; i<ret; i++) {
856 struct asys_result *result = &results[i];
857 struct tevent_req *req;
858 struct vfswrap_asys_state *state;
859
860 if ((result->ret == -1) && (result->err == ECANCELED)) {
861 continue;
862 }
863
864 req = talloc_get_type_abort(result->private_data,
865 struct tevent_req);
866 state = tevent_req_data(req, struct vfswrap_asys_state);
867
868 talloc_set_destructor(state, NULL);
869
870 SMBPROFILE_BASIC_ASYNC_END(state->profile_basic);
871 SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
872 state->ret = result->ret;
873 state->err = result->err;
874 tevent_req_defer_callback(req, ev);
875 tevent_req_done(req);
876 }
877 }
878
879 static ssize_t vfswrap_asys_ssize_t_recv(struct tevent_req *req, int *err)
880 {
881 struct vfswrap_asys_state *state = tevent_req_data(
882 req, struct vfswrap_asys_state);
883
884 if (tevent_req_is_unix_error(req, err)) {
885 return -1;
886 }
887 *err = state->err;
888 return state->ret;
889 }
890
891 static int vfswrap_asys_int_recv(struct tevent_req *req, int *err)
892 {
893 struct vfswrap_asys_state *state = tevent_req_data(
894 req, struct vfswrap_asys_state);
895
896 if (tevent_req_is_unix_error(req, err)) {
897 return -1;
898 }
899 *err = state->err;
900 return state->ret;
901 }
902
903 static off_t vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
904 {
905 off_t result = 0;
906
907 START_PROFILE(syscall_lseek);
908
909 /* Cope with 'stat' file opens. */
910 if (fsp->fh->fd != -1)
911 result = lseek(fsp->fh->fd, offset, whence);
912
913 /*
914 * We want to maintain the fiction that we can seek
915 * on a fifo for file system purposes. This allows
916 * people to set up UNIX fifo's that feed data to Windows
917 * applications. JRA.
918 */
919
920 if((result == -1) && (errno == ESPIPE)) {
921 result = 0;
922 errno = 0;
923 }
924
925 END_PROFILE(syscall_lseek);
926 return result;
927 }
928
929 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
930 off_t offset, size_t n)
931 {
932 ssize_t result;
933
934 START_PROFILE_BYTES(syscall_sendfile, n);
935 result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
936 END_PROFILE_BYTES(syscall_sendfile);
937 return result;
938 }
939
940 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
941 int fromfd,
942 files_struct *tofsp,
943 off_t offset,
944 size_t n)
945 {
946 ssize_t result;
947
948 START_PROFILE_BYTES(syscall_recvfile, n);
949 result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
950 END_PROFILE_BYTES(syscall_recvfile);
951 return result;
952 }
953
954 static int vfswrap_rename(vfs_handle_struct *handle,
955 const struct smb_filename *smb_fname_src,
956 const struct smb_filename *smb_fname_dst)
957 {
958 int result = -1;
959
960 START_PROFILE(syscall_rename);
961
962 if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
963 errno = ENOENT;
964 goto out;
965 }
966
967 result = rename(smb_fname_src->base_name, smb_fname_dst->base_name);
968
969 out:
970 END_PROFILE(syscall_rename);
971 return result;
972 }
973
974 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
975 {
976 #ifdef HAVE_FSYNC
977 int result;
978
979 START_PROFILE(syscall_fsync);
980 result = fsync(fsp->fh->fd);
981 END_PROFILE(syscall_fsync);
982 return result;
983 #else
984 return 0;
985 #endif
986 }
987
988 static int vfswrap_stat(vfs_handle_struct *handle,
989 struct smb_filename *smb_fname)
990 {
991 int result = -1;
992
993 START_PROFILE(syscall_stat);
994
995 if (smb_fname->stream_name) {
996 errno = ENOENT;
997 goto out;
998 }
999
1000 result = sys_stat(smb_fname->base_name, &smb_fname->st,
1001 lp_fake_directory_create_times(SNUM(handle->conn)));
1002 out:
1003 END_PROFILE(syscall_stat);
1004 return result;
1005 }
1006
1007 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1008 {
1009 int result;
1010
1011 START_PROFILE(syscall_fstat);
1012 result = sys_fstat(fsp->fh->fd,
1013 sbuf, lp_fake_directory_create_times(SNUM(handle->conn)));
1014 END_PROFILE(syscall_fstat);
1015 return result;
1016 }
1017
1018 static int vfswrap_lstat(vfs_handle_struct *handle,
1019 struct smb_filename *smb_fname)
1020 {
1021 int result = -1;
1022
1023 START_PROFILE(syscall_lstat);
1024
1025 if (smb_fname->stream_name) {
1026 errno = ENOENT;
1027 goto out;
1028 }
1029
1030 result = sys_lstat(smb_fname->base_name, &smb_fname->st,
1031 lp_fake_directory_create_times(SNUM(handle->conn)));
1032 out:
1033 END_PROFILE(syscall_lstat);
1034 return result;
1035 }
1036
1037 static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
1038 const char *name,
1039 enum vfs_translate_direction direction,
1040 TALLOC_CTX *mem_ctx,
1041 char **mapped_name)
1042 {
1043 return NT_STATUS_NONE_MAPPED;
1044 }
1045
1046 /*
1047 * Implement the default fsctl operation.
1048 */
1049 static bool vfswrap_logged_ioctl_message = false;
1050
1051 static NTSTATUS vfswrap_fsctl(struct vfs_handle_struct *handle,
1052 struct files_struct *fsp,
1053 TALLOC_CTX *ctx,
1054 uint32_t function,
1055 uint16_t req_flags, /* Needed for UNICODE ... */
1056 const uint8_t *_in_data,
1057 uint32_t in_len,
1058 uint8_t **_out_data,
1059 uint32_t max_out_len,
1060 uint32_t *out_len)
1061 {
1062 const char *in_data = (const char *)_in_data;
1063 char **out_data = (char **)_out_data;
1064 NTSTATUS status;
1065
1066 switch (function) {
1067 case FSCTL_SET_SPARSE:
1068 {
1069 bool set_sparse = true;
1070
1071 if (in_len >= 1 && in_data[0] == 0) {
1072 set_sparse = false;
1073 }
1074
1075 status = file_set_sparse(handle->conn, fsp, set_sparse);
1076
1077 DEBUG(NT_STATUS_IS_OK(status) ? 10 : 9,
1078 ("FSCTL_SET_SPARSE: fname[%s] set[%u] - %s\n",
1079 smb_fname_str_dbg(fsp->fsp_name), set_sparse,
1080 nt_errstr(status)));
1081
1082 return status;
1083 }
1084
1085 case FSCTL_CREATE_OR_GET_OBJECT_ID:
1086 {
1087 unsigned char objid[16];
1088 char *return_data = NULL;
1089
1090 /* This should return the object-id on this file.
1091 * I think I'll make this be the inode+dev. JRA.
1092 */
1093
1094 DEBUG(10,("FSCTL_CREATE_OR_GET_OBJECT_ID: called on %s\n",
1095 fsp_fnum_dbg(fsp)));
1096
1097 *out_len = MIN(max_out_len, 64);
1098
1099 /* Hmmm, will this cause problems if less data asked for? */
1100 return_data = talloc_array(ctx, char, 64);
1101 if (return_data == NULL) {
1102 return NT_STATUS_NO_MEMORY;
1103 }
1104
1105 /* For backwards compatibility only store the dev/inode. */
1106 push_file_id_16(return_data, &fsp->file_id);
1107 memcpy(return_data+16,create_volume_objectid(fsp->conn,objid),16);
1108 push_file_id_16(return_data+32, &fsp->file_id);
1109 memset(return_data+48, 0, 16);
1110 *out_data = return_data;
1111 return NT_STATUS_OK;
1112 }
1113
1114 case FSCTL_GET_REPARSE_POINT:
1115 {
1116 /* Fail it with STATUS_NOT_A_REPARSE_POINT */
1117 DEBUG(10, ("FSCTL_GET_REPARSE_POINT: called on %s. "
1118 "Status: NOT_IMPLEMENTED\n", fsp_fnum_dbg(fsp)));
1119 return NT_STATUS_NOT_A_REPARSE_POINT;
1120 }
1121
1122 case FSCTL_SET_REPARSE_POINT:
1123 {
1124 /* Fail it with STATUS_NOT_A_REPARSE_POINT */
1125 DEBUG(10, ("FSCTL_SET_REPARSE_POINT: called on %s. "
1126 "Status: NOT_IMPLEMENTED\n", fsp_fnum_dbg(fsp)));
1127 return NT_STATUS_NOT_A_REPARSE_POINT;
1128 }
1129
1130 case FSCTL_GET_SHADOW_COPY_DATA:
1131 {
1132 /*
1133 * This is called to retrieve the number of Shadow Copies (a.k.a. snapshots)
1134 * and return their volume names. If max_data_count is 16, then it is just
1135 * asking for the number of volumes and length of the combined names.
1136 *
1137 * pdata is the data allocated by our caller, but that uses
1138 * total_data_count (which is 0 in our case) rather than max_data_count.
1139 * Allocate the correct amount and return the pointer to let
1140 * it be deallocated when we return.
1141 */
1142 struct shadow_copy_data *shadow_data = NULL;
1143 bool labels = False;
1144 uint32_t labels_data_count = 0;
1145 uint32_t i;
1146 char *cur_pdata = NULL;
1147
1148 if (max_out_len < 16) {
1149 DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) < 16 is invalid!\n",
1150 max_out_len));
1151 return NT_STATUS_INVALID_PARAMETER;
1152 }
1153
1154 if (max_out_len > 16) {
1155 labels = True;
1156 }
1157
1158 shadow_data = talloc_zero(ctx, struct shadow_copy_data);
1159 if (shadow_data == NULL) {
1160 DEBUG(0,("TALLOC_ZERO() failed!\n"));
1161 return NT_STATUS_NO_MEMORY;
1162 }
1163
1164 /*
1165 * Call the VFS routine to actually do the work.
1166 */
1167 if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
1168 int log_lev = 0;
1169 if (errno == 0) {
1170 /* broken module didn't set errno on error */
1171 status = NT_STATUS_UNSUCCESSFUL;
1172 } else {
1173 status = map_nt_error_from_unix(errno);
1174 if (NT_STATUS_EQUAL(status,
1175 NT_STATUS_NOT_SUPPORTED)) {
1176 log_lev = 5;
1177 }
1178 }
1179 DEBUG(log_lev, ("FSCTL_GET_SHADOW_COPY_DATA: "
1180 "connectpath %s, failed - %s.\n",
1181 fsp->conn->connectpath,
1182 nt_errstr(status)));
1183 TALLOC_FREE(shadow_data);
1184 return status;
1185 }
1186
1187 labels_data_count = (shadow_data->num_volumes * 2 *
1188 sizeof(SHADOW_COPY_LABEL)) + 2;
1189
1190 if (!labels) {
1191 *out_len = 16;
1192 } else {
1193 *out_len = 12 + labels_data_count;
1194 }
1195
1196 if (max_out_len < *out_len) {
1197 DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) too small (%u) bytes needed!\n",
1198 max_out_len, *out_len));
1199 TALLOC_FREE(shadow_data);
1200 return NT_STATUS_BUFFER_TOO_SMALL;
1201 }
1202
1203 cur_pdata = talloc_zero_array(ctx, char, *out_len);
1204 if (cur_pdata == NULL) {
1205 TALLOC_FREE(shadow_data);
1206 return NT_STATUS_NO_MEMORY;
1207 }
1208
1209 *out_data = cur_pdata;
1210
1211 /* num_volumes 4 bytes */
1212 SIVAL(cur_pdata, 0, shadow_data->num_volumes);
1213
1214 if (labels) {
1215 /* num_labels 4 bytes */
1216 SIVAL(cur_pdata, 4, shadow_data->num_volumes);
1217 }
1218
1219 /* needed_data_count 4 bytes */
1220 SIVAL(cur_pdata, 8, labels_data_count);
1221
1222 cur_pdata += 12;
1223
1224 DEBUG(10,("FSCTL_GET_SHADOW_COPY_DATA: %u volumes for path[%s].\n",
1225 shadow_data->num_volumes, fsp_str_dbg(fsp)));
1226 if (labels && shadow_data->labels) {
1227 for (i=0; i<shadow_data->num_volumes; i++) {
1228 size_t len = 0;
1229 status = srvstr_push(cur_pdata, req_flags,
1230 cur_pdata, shadow_data->labels[i],
1231 2 * sizeof(SHADOW_COPY_LABEL),
1232 STR_UNICODE|STR_TERMINATE, &len);
1233 if (!NT_STATUS_IS_OK(status)) {
1234 TALLOC_FREE(*out_data);
1235 TALLOC_FREE(shadow_data);
1236 return status;
1237 }
1238 cur_pdata += 2 * sizeof(SHADOW_COPY_LABEL);
1239 DEBUGADD(10,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
1240 }
1241 }
1242
1243 TALLOC_FREE(shadow_data);
1244
1245 return NT_STATUS_OK;
1246 }
1247
1248 case FSCTL_FIND_FILES_BY_SID:
1249 {
1250 /* pretend this succeeded -
1251 *
1252 * we have to send back a list with all files owned by this SID
1253 *
1254 * but I have to check that --metze
1255 */
1256 struct dom_sid sid;
1257 uid_t uid;
1258 size_t sid_len;
1259
1260 DEBUG(10, ("FSCTL_FIND_FILES_BY_SID: called on %s\n",
1261 fsp_fnum_dbg(fsp)));
1262
1263 if (in_len < 8) {
1264 /* NT_STATUS_BUFFER_TOO_SMALL maybe? */
1265 return NT_STATUS_INVALID_PARAMETER;
1266 }
1267
1268 sid_len = MIN(in_len - 4,SID_MAX_SIZE);
1269
1270 /* unknown 4 bytes: this is not the length of the sid :-( */
1271 /*unknown = IVAL(pdata,0);*/
1272
1273 if (!sid_parse(in_data + 4, sid_len, &sid)) {
1274 return NT_STATUS_INVALID_PARAMETER;
1275 }
1276 DEBUGADD(10, ("for SID: %s\n", sid_string_dbg(&sid)));
1277
1278 if (!sid_to_uid(&sid, &uid)) {
1279 DEBUG(0,("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
1280 sid_string_dbg(&sid),
1281 (unsigned long)sid_len));
1282 uid = (-1);
1283 }
1284
1285 /* we can take a look at the find source :-)
1286 *
1287 * find ./ -uid $uid -name '*' is what we need here
1288 *
1289 *
1290 * and send 4bytes len and then NULL terminated unicode strings
1291 * for each file
1292 *
1293 * but I don't know how to deal with the paged results
1294 * (maybe we can hang the result anywhere in the fsp struct)
1295 *
1296 * but I don't know how to deal with the paged results
1297 * (maybe we can hang the result anywhere in the fsp struct)
1298 *
1299 * we don't send all files at once
1300 * and at the next we should *not* start from the beginning,
1301 * so we have to cache the result
1302 *
1303 * --metze
1304 */
1305
1306 /* this works for now... */
1307 return NT_STATUS_OK;
1308 }
1309
1310 case FSCTL_QUERY_ALLOCATED_RANGES:
1311 {
1312 /* FIXME: This is just a dummy reply, telling that all of the
1313 * file is allocated. MKS cp needs that.
1314 * Adding the real allocated ranges via FIEMAP on Linux
1315 * and SEEK_DATA/SEEK_HOLE on Solaris is needed to make
1316 * this FSCTL correct for sparse files.
1317 */
1318 uint64_t offset, length;
1319 char *out_data_tmp = NULL;
1320
1321 if (in_len != 16) {
1322 DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: data_count(%u) != 16 is invalid!\n",
1323 in_len));
1324 return NT_STATUS_INVALID_PARAMETER;
1325 }
1326
1327 if (max_out_len < 16) {
1328 DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: max_out_len (%u) < 16 is invalid!\n",
1329 max_out_len));
1330 return NT_STATUS_INVALID_PARAMETER;
1331 }
1332
1333 offset = BVAL(in_data,0);
1334 length = BVAL(in_data,8);
1335
1336 if (offset + length < offset) {
1337 /* No 64-bit integer wrap. */
1338 return NT_STATUS_INVALID_PARAMETER;
1339 }
1340
1341 /* Shouldn't this be SMB_VFS_STAT ... ? */
1342 status = vfs_stat_fsp(fsp);
1343 if (!NT_STATUS_IS_OK(status)) {
1344 return status;
1345 }
1346
1347 *out_len = 16;
1348 out_data_tmp = talloc_array(ctx, char, *out_len);
1349 if (out_data_tmp == NULL) {
1350 DEBUG(10, ("unable to allocate memory for response\n"));
1351 return NT_STATUS_NO_MEMORY;
1352 }
1353
1354 if (offset > fsp->fsp_name->st.st_ex_size ||
1355 fsp->fsp_name->st.st_ex_size == 0 ||
1356 length == 0) {
1357 memset(out_data_tmp, 0, *out_len);
1358 } else {
1359 uint64_t end = offset + length;
1360 end = MIN(end, fsp->fsp_name->st.st_ex_size);
1361 SBVAL(out_data_tmp, 0, 0);
1362 SBVAL(out_data_tmp, 8, end);
1363 }
1364
1365 *out_data = out_data_tmp;
1366
1367 return NT_STATUS_OK;
1368 }
1369
1370 case FSCTL_IS_VOLUME_DIRTY:
1371 {
1372 DEBUG(10,("FSCTL_IS_VOLUME_DIRTY: called on %s "
1373 "(but remotely not supported)\n", fsp_fnum_dbg(fsp)));
1374 /*
1375 * http://msdn.microsoft.com/en-us/library/cc232128%28PROT.10%29.aspx
1376 * says we have to respond with NT_STATUS_INVALID_PARAMETER
1377 */
1378 return NT_STATUS_INVALID_PARAMETER;
1379 }
1380
1381 default:
1382 /*
1383 * Only print once ... unfortunately there could be lots of
1384 * different FSCTLs that are called.
1385 */
1386 if (!vfswrap_logged_ioctl_message) {
1387 vfswrap_logged_ioctl_message = true;
1388 DEBUG(2, ("%s (0x%x): Currently not implemented.\n",
1389 __func__, function));
1390 }
1391 }
1392
1393 return NT_STATUS_NOT_SUPPORTED;
1394 }
1395
1396 struct vfs_cc_state {
1397 off_t copied;
1398 uint8_t *buf;
1399 };
1400
1401 static struct tevent_req *vfswrap_copy_chunk_send(struct vfs_handle_struct *handle,
1402 TALLOC_CTX *mem_ctx,
1403 struct tevent_context *ev,
1404 struct files_struct *src_fsp,
1405 off_t src_off,
1406 struct files_struct *dest_fsp,
1407 off_t dest_off,
1408 off_t num)
1409 {
1410 struct tevent_req *req;
1411 struct vfs_cc_state *vfs_cc_state;
1412 NTSTATUS status;
1413
1414 DEBUG(10, ("performing server side copy chunk of length %lu\n",
1415 (unsigned long)num));
1416
1417 req = tevent_req_create(mem_ctx, &vfs_cc_state, struct vfs_cc_state);
1418 if (req == NULL) {
1419 return NULL;
1420 }
1421
1422 vfs_cc_state->buf = talloc_array(vfs_cc_state, uint8_t,
1423 MIN(num, 8*1024*1024));
1424 if (tevent_req_nomem(vfs_cc_state->buf, req)) {
1425 return tevent_req_post(req, ev);
1426 }
1427
1428 status = vfs_stat_fsp(src_fsp);
1429 if (tevent_req_nterror(req, status)) {
1430 return tevent_req_post(req, ev);
1431 }
1432
1433 if (src_fsp->fsp_name->st.st_ex_size < src_off + num) {
1434 /*
1435 * [MS-SMB2] 3.3.5.15.6 Handling a Server-Side Data Copy Request
1436 * If the SourceOffset or SourceOffset + Length extends beyond
1437 * the end of file, the server SHOULD<240> treat this as a
1438 * STATUS_END_OF_FILE error.
1439 * ...
1440 * <240> Section 3.3.5.15.6: Windows servers will return
1441 * STATUS_INVALID_VIEW_SIZE instead of STATUS_END_OF_FILE.
1442 */
1443 tevent_req_nterror(req, NT_STATUS_INVALID_VIEW_SIZE);
1444 return tevent_req_post(req, ev);
1445 }
1446
1447 /* could use 2.6.33+ sendfile here to do this in kernel */
1448 while (vfs_cc_state->copied < num) {
1449 ssize_t ret;
1450 struct lock_struct lck;
1451 int saved_errno;
1452
1453 off_t this_num = MIN(talloc_array_length(vfs_cc_state->buf),
1454 num - vfs_cc_state->copied);
1455
1456 if (src_fsp->op == NULL) {
1457 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1458 return tevent_req_post(req, ev);
1459 }
1460 init_strict_lock_struct(src_fsp,
1461 src_fsp->op->global->open_persistent_id,
1462 src_off,
1463 this_num,
1464 READ_LOCK,
1465 &lck);
1466
1467 if (!SMB_VFS_STRICT_LOCK(src_fsp->conn, src_fsp, &lck)) {
1468 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
1469 return tevent_req_post(req, ev);
1470 }
1471
1472 ret = SMB_VFS_PREAD(src_fsp, vfs_cc_state->buf,
1473 this_num, src_off);
1474 if (ret == -1) {
1475 saved_errno = errno;
1476 }
1477
1478 SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &lck);
1479
1480 if (ret == -1) {
1481 errno = saved_errno;
1482 tevent_req_nterror(req, map_nt_error_from_unix(errno));
1483 return tevent_req_post(req, ev);
1484 }
1485 if (ret != this_num) {
1486 /* zero tolerance for short reads */
1487 tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
1488 return tevent_req_post(req, ev);
1489 }
1490
1491 src_off += ret;
1492
1493 if (dest_fsp->op == NULL) {
1494 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
1495 return tevent_req_post(req, ev);
1496 }
1497
1498 init_strict_lock_struct(dest_fsp,
1499 dest_fsp->op->global->open_persistent_id,
1500 dest_off,
1501 this_num,
1502 WRITE_LOCK,
1503 &lck);
1504
1505 if (!SMB_VFS_STRICT_LOCK(dest_fsp->conn, dest_fsp, &lck)) {
1506 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
1507 return tevent_req_post(req, ev);
1508 }
1509
1510 ret = SMB_VFS_PWRITE(dest_fsp, vfs_cc_state->buf,
1511 this_num, dest_off);
1512 if (ret == -1) {
1513 saved_errno = errno;
1514 }
1515
1516 SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &lck);
1517
1518 if (ret == -1) {
1519 errno = saved_errno;
1520 tevent_req_nterror(req, map_nt_error_from_unix(errno));
1521 return tevent_req_post(req, ev);
1522 }
1523 if (ret != this_num) {
1524 /* zero tolerance for short writes */
1525 tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
1526 return tevent_req_post(req, ev);
1527 }
1528 dest_off += ret;
1529
1530 vfs_cc_state->copied += this_num;
1531 }
1532
1533 tevent_req_done(req);
1534 return tevent_req_post(req, ev);
1535 }
1536
1537 static NTSTATUS vfswrap_copy_chunk_recv(struct vfs_handle_struct *handle,
1538 struct tevent_req *req,
1539 off_t *copied)
1540 {
1541 struct vfs_cc_state *vfs_cc_state = tevent_req_data(req,
1542 struct vfs_cc_state);
1543 NTSTATUS status;
1544
1545 if (tevent_req_is_nterror(req, &status)) {
1546 DEBUG(2, ("server side copy chunk failed: %s\n",
1547 nt_errstr(status)));
1548 *copied = 0;
1549 tevent_req_received(req);
1550 return status;
1551 }
1552
1553 *copied = vfs_cc_state->copied;
1554 DEBUG(10, ("server side copy chunk copied %lu\n",
1555 (unsigned long)*copied));
1556 tevent_req_received(req);
1557
1558 return NT_STATUS_OK;
1559 }
1560
1561 static NTSTATUS vfswrap_get_compression(struct vfs_handle_struct *handle,
1562 TALLOC_CTX *mem_ctx,
1563 struct files_struct *fsp,
1564 struct smb_filename *smb_fname,
1565 uint16_t *_compression_fmt)
1566 {
1567 return NT_STATUS_INVALID_DEVICE_REQUEST;
1568 }
1569
1570 static NTSTATUS vfswrap_set_compression(struct vfs_handle_struct *handle,
1571 TALLOC_CTX *mem_ctx,
1572 struct files_struct *fsp,
1573 uint16_t compression_fmt)
1574 {
1575 return NT_STATUS_INVALID_DEVICE_REQUEST;
1576 }
1577
1578 /********************************************************************
1579 Given a stat buffer return the allocated size on disk, taking into
1580 account sparse files.
1581 ********************************************************************/
1582 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
1583 struct files_struct *fsp,
1584 const SMB_STRUCT_STAT *sbuf)
1585 {
1586 uint64_t result;
1587
1588 START_PROFILE(syscall_get_alloc_size);
1589
1590 if(S_ISDIR(sbuf->st_ex_mode)) {
1591 result = 0;
1592 goto out;
1593 }
1594
1595 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
1596 /* The type of st_blocksize is blkcnt_t which *MUST* be
1597 signed (according to POSIX) and can be less than 64-bits.
1598 Ensure when we're converting to 64 bits wide we don't
1599 sign extend. */
1600 #if defined(SIZEOF_BLKCNT_T_8)
1601 result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
1602 #elif defined(SIZEOF_BLKCNT_T_4)
1603 {
1604 uint64_t bs = ((uint64_t)sbuf->st_ex_blocks) & 0xFFFFFFFFLL;
1605 result = (uint64_t)STAT_ST_BLOCKSIZE * bs;
1606 }
1607 #else
1608 #error SIZEOF_BLKCNT_T_NOT_A_SUPPORTED_VALUE
1609 #endif
1610 if (result == 0) {
1611 /*
1612 * Some file systems do not allocate a block for very
1613 * small files. But for non-empty file should report a
1614 * positive size.
1615 */
1616
1617 uint64_t filesize = get_file_size_stat(sbuf);
1618 if (filesize > 0) {
1619 result = MIN((uint64_t)STAT_ST_BLOCKSIZE, filesize);
1620 }
1621 }
1622 #else
1623 result = get_file_size_stat(sbuf);
1624 #endif
1625
1626 if (fsp && fsp->initial_allocation_size)
1627 result = MAX(result,fsp->initial_allocation_size);
1628
1629 result = smb_roundup(handle->conn, result);
1630
1631 out:
1632 END_PROFILE(syscall_get_alloc_size);
1633 return result;
1634 }
1635
1636 static int vfswrap_unlink(vfs_handle_struct *handle,
1637 const struct smb_filename *smb_fname)
1638 {
1639 int result = -1;
1640
1641 START_PROFILE(syscall_unlink);
1642
1643 if (smb_fname->stream_name) {
1644 errno = ENOENT;
1645 goto out;
1646 }
1647 result = unlink(smb_fname->base_name);
1648
1649 out:
1650 END_PROFILE(syscall_unlink);
1651 return result;
1652 }
1653
1654 static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
1655 {
1656 int result;
1657
1658 START_PROFILE(syscall_chmod);
1659
1660 /*
1661 * We need to do this due to the fact that the default POSIX ACL
1662 * chmod modifies the ACL *mask* for the group owner, not the
1663 * group owner bits directly. JRA.
1664 */
1665
1666
1667 {
1668 int saved_errno = errno; /* We might get ENOSYS */
1669 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
1670 END_PROFILE(syscall_chmod);
1671 return result;
1672 }
1673 /* Error - return the old errno. */
1674 errno = saved_errno;
1675 }
1676
1677 result = chmod(path, mode);
1678 END_PROFILE(syscall_chmod);
1679 return result;
1680 }
1681
1682 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1683 {
1684 int result;
1685
1686 START_PROFILE(syscall_fchmod);
1687
1688 /*
1689 * We need to do this due to the fact that the default POSIX ACL
1690 * chmod modifies the ACL *mask* for the group owner, not the
1691 * group owner bits directly. JRA.
1692 */
1693
1694 {
1695 int saved_errno = errno; /* We might get ENOSYS */
1696 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
1697 END_PROFILE(syscall_fchmod);
1698 return result;
1699 }
1700 /* Error - return the old errno. */
1701 errno = saved_errno;
1702 }
1703
1704 #if defined(HAVE_FCHMOD)
1705 result = fchmod(fsp->fh->fd, mode);
1706 #else
1707 result = -1;
1708 errno = ENOSYS;
1709 #endif
1710
1711 END_PROFILE(syscall_fchmod);
1712 return result;
1713 }
1714
1715 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
1716 {
1717 int result;
1718
1719 START_PROFILE(syscall_chown);
1720 result = chown(path, uid, gid);
1721 END_PROFILE(syscall_chown);
1722 return result;
1723 }
1724
1725 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
1726 {
1727 #ifdef HAVE_FCHOWN
1728 int result;
1729
1730 START_PROFILE(syscall_fchown);
1731 result = fchown(fsp->fh->fd, uid, gid);
1732 END_PROFILE(syscall_fchown);
1733 return result;
1734 #else
1735 errno = ENOSYS;
1736 return -1;
1737 #endif
1738 }
1739
1740 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
1741 {
1742 int result;
1743
1744 START_PROFILE(syscall_lchown);
1745 result = lchown(path, uid, gid);
1746 END_PROFILE(syscall_lchown);
1747 return result;
1748 }
1749
1750 static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
1751 {
1752 int result;
1753
1754 START_PROFILE(syscall_chdir);
1755 result = chdir(path);
1756 END_PROFILE(syscall_chdir);
1757 return result;
1758 }
1759
1760 static char *vfswrap_getwd(vfs_handle_struct *handle)
1761 {
1762 char *result;
1763
1764 START_PROFILE(syscall_getwd);
1765 result = sys_getwd();
1766 END_PROFILE(syscall_getwd);
1767 return result;
1768 }
1769
1770 /*********************************************************************
1771 nsec timestamp resolution call. Convert down to whatever the underlying
1772 system will support.
1773 **********************************************************************/
1774
1775 static int vfswrap_ntimes(vfs_handle_struct *handle,
1776 const struct smb_filename *smb_fname,
1777 struct smb_file_time *ft)
1778 {
1779 int result = -1;
1780
1781 START_PROFILE(syscall_ntimes);
1782
1783 if (smb_fname->stream_name) {
1784 errno = ENOENT;
1785 goto out;
1786 }
1787
1788 if (ft != NULL) {
1789 if (null_timespec(ft->atime)) {
1790 ft->atime= smb_fname->st.st_ex_atime;
1791 }
1792
1793 if (null_timespec(ft->mtime)) {
1794 ft->mtime = smb_fname->st.st_ex_mtime;
1795 }
1796
1797 if (!null_timespec(ft->create_time)) {
1798 set_create_timespec_ea(handle->conn,
1799 smb_fname,
1800 ft->create_time);
1801 }
1802
1803 if ((timespec_compare(&ft->atime,
1804 &smb_fname->st.st_ex_atime) == 0) &&
1805 (timespec_compare(&ft->mtime,
1806 &smb_fname->st.st_ex_mtime) == 0)) {
1807 return 0;
1808 }
1809 }
1810
1811 #if defined(HAVE_UTIMENSAT)
1812 if (ft != NULL) {
1813 struct timespec ts[2];
1814 ts[0] = ft->atime;
1815 ts[1] = ft->mtime;
1816 result = utimensat(AT_FDCWD, smb_fname->base_name, ts, 0);
1817 } else {
1818 result = utimensat(AT_FDCWD, smb_fname->base_name, NULL, 0);
1819 }
1820 if (!((result == -1) && (errno == ENOSYS))) {
1821 goto out;
1822 }
1823 #endif
1824 #if defined(HAVE_UTIMES)
1825 if (ft != NULL) {
1826 struct timeval tv[2];
1827 tv[0] = convert_timespec_to_timeval(ft->atime);
1828 tv[1] = convert_timespec_to_timeval(ft->mtime);
1829 result = utimes(smb_fname->base_name, tv);
1830 } else {
1831 result = utimes(smb_fname->base_name, NULL);
1832 }
1833 if (!((result == -1) && (errno == ENOSYS))) {
1834 goto out;
1835 }
1836 #endif
1837 #if defined(HAVE_UTIME)
1838 if (ft != NULL) {
1839 struct utimbuf times;
1840 times.actime = convert_timespec_to_time_t(ft->atime);
1841 times.modtime = convert_timespec_to_time_t(ft->mtime);
1842 result = utime(smb_fname->base_name, &times);
1843 } else {
1844 result = utime(smb_fname->base_name, NULL);
1845 }
1846 if (!((result == -1) && (errno == ENOSYS))) {
1847 goto out;
1848 }
1849 #endif
1850 errno = ENOSYS;
1851 result = -1;
1852
1853 out:
1854 END_PROFILE(syscall_ntimes);
1855 return result;
1856 }
1857
1858 /*********************************************************************
1859 A version of ftruncate that will write the space on disk if strict
1860 allocate is set.
1861 **********************************************************************/
1862
1863 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
1864 {
1865 off_t space_to_write;
1866 uint64_t space_avail;
1867 uint64_t bsize,dfree,dsize;
1868 int ret;
1869 NTSTATUS status;
1870 SMB_STRUCT_STAT *pst;
1871
1872 status = vfs_stat_fsp(fsp);
1873 if (!NT_STATUS_IS_OK(status)) {
1874 return -1;
1875 }
1876 pst = &fsp->fsp_name->st;
1877
1878 #ifdef S_ISFIFO
1879 if (S_ISFIFO(pst->st_ex_mode))
1880 return 0;
1881 #endif
1882
1883 if (pst->st_ex_size == len)
1884 return 0;
1885
1886 /* Shrink - just ftruncate. */
1887 if (pst->st_ex_size > len)
1888 return ftruncate(fsp->fh->fd, len);
1889
1890 space_to_write = len - pst->st_ex_size;
1891
1892 /* for allocation try fallocate first. This can fail on some
1893 platforms e.g. when the filesystem doesn't support it and no
1894 emulation is being done by the libc (like on AIX with JFS1). In that
1895 case we do our own emulation. fallocate implementations can
1896 return ENOTSUP or EINVAL in cases like that. */
1897 ret = SMB_VFS_FALLOCATE(fsp, 0, pst->st_ex_size, space_to_write);
1898 if (ret == -1 && errno == ENOSPC) {
1899 return -1;
1900 }
1901 if (ret == 0) {
1902 return 0;
1903 }
1904 DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
1905 "error %d. Falling back to slow manual allocation\n", errno));
1906
1907 /* available disk space is enough or not? */
1908 space_avail = get_dfree_info(fsp->conn,
1909 fsp->fsp_name->base_name,
1910 &bsize, &dfree, &dsize);
1911 /* space_avail is 1k blocks */
1912 if (space_avail == (uint64_t)-1 ||
1913 ((uint64_t)space_to_write/1024 > space_avail) ) {
1914 errno = ENOSPC;
1915 return -1;
1916 }
1917
1918 /* Write out the real space on disk. */
1919 ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
1920 if (ret != 0) {
1921 return -1;
1922 }
1923
1924 return 0;
1925 }
1926
1927 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
1928 {
1929 int result = -1;
1930 SMB_STRUCT_STAT *pst;
1931 NTSTATUS status;
1932 char c = 0;
1933
1934 START_PROFILE(syscall_ftruncate);
1935
1936 if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->is_sparse) {
1937 result = strict_allocate_ftruncate(handle, fsp, len);
1938 END_PROFILE(syscall_ftruncate);
1939 return result;
1940 }
1941
1942 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
1943 ftruncate if the system supports it. Then I discovered that
1944 you can have some filesystems that support ftruncate
1945 expansion and some that don't! On Linux fat can't do
1946 ftruncate extend but ext2 can. */
1947
1948 result = ftruncate(fsp->fh->fd, len);
1949
1950 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
1951 extend a file with ftruncate. Provide alternate implementation
1952 for this */
1953
1954 /* Do an fstat to see if the file is longer than the requested
1955 size in which case the ftruncate above should have
1956 succeeded or shorter, in which case seek to len - 1 and
1957 write 1 byte of zero */
1958 status = vfs_stat_fsp(fsp);
1959 if (!NT_STATUS_IS_OK(status)) {
1960 goto done;
1961 }
1962
1963 /* We need to update the files_struct after successful ftruncate */
1964 if (result == 0) {
1965 goto done;
1966 }
1967
1968 pst = &fsp->fsp_name->st;
1969
1970 #ifdef S_ISFIFO
1971 if (S_ISFIFO(pst->st_ex_mode)) {
1972 result = 0;
1973 goto done;
1974 }
1975 #endif
1976
1977 if (pst->st_ex_size == len) {
1978 result = 0;
1979 goto done;
1980 }
1981
1982 if (pst->st_ex_size > len) {
1983 /* the ftruncate should have worked */
1984 goto done;
1985 }
1986
1987 if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
1988 goto done;
1989 }
1990
1991 result = 0;
1992
1993 done:
1994
1995 END_PROFILE(syscall_ftruncate);
1996 return result;
1997 }
1998
1999 static int vfswrap_fallocate(vfs_handle_struct *handle,
2000 files_struct *fsp,
2001 uint32_t mode,
2002 off_t offset,
2003 off_t len)
2004 {
2005 int result;
2006
2007 START_PROFILE(syscall_fallocate);
2008 if (mode == 0) {
2009 result = sys_posix_fallocate(fsp->fh->fd, offset, len);
2010 /*
2011 * posix_fallocate returns 0 on success, errno on error
2012 * and doesn't set errno. Make it behave like fallocate()
2013 * which returns -1, and sets errno on failure.
2014 */
2015 if (result != 0) {
2016 errno = result;
2017 result = -1;
2018 }
2019 } else {
2020 /* sys_fallocate handles filtering of unsupported mode flags */
2021 result = sys_fallocate(fsp->fh->fd, mode, offset, len);
2022 }
2023 END_PROFILE(syscall_fallocate);
2024 return result;
2025 }
2026
2027 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
2028 {
2029 bool result;
2030
2031 START_PROFILE(syscall_fcntl_lock);
2032 result = fcntl_lock(fsp->fh->fd, op, offset, count, type);
2033 END_PROFILE(syscall_fcntl_lock);
2034 return result;
2035 }
2036
2037 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
2038 uint32_t share_mode, uint32_t access_mask)
2039 {
2040 START_PROFILE(syscall_kernel_flock);
2041 kernel_flock(fsp->fh->fd, share_mode, access_mask);
2042 END_PROFILE(syscall_kernel_flock);
2043 return 0;
2044 }
2045
2046 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
2047 {
2048 bool result;
2049
2050 START_PROFILE(syscall_fcntl_getlock);
2051 result = fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
2052 END_PROFILE(syscall_fcntl_getlock);
2053 return result;
2054 }
2055
2056 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
2057 int leasetype)
2058 {
2059 int result = -1;
2060
2061 START_PROFILE(syscall_linux_setlease);
2062
2063 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
2064 result = linux_setlease(fsp->fh->fd, leasetype);
2065 #else
2066 errno = ENOSYS;
2067 #endif
2068 END_PROFILE(syscall_linux_setlease);
2069 return result;
2070 }
2071
2072 static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
2073 {
2074 int result;
2075
2076 START_PROFILE(syscall_symlink);
2077 result = symlink(oldpath, newpath);
2078 END_PROFILE(syscall_symlink);
2079 return result;
2080 }
2081
2082 static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
2083 {
2084 int result;
2085
2086 START_PROFILE(syscall_readlink);
2087 result = readlink(path, buf, bufsiz);
2088 END_PROFILE(syscall_readlink);
2089 return result;
2090 }
2091
2092 static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
2093 {
2094 int result;
2095
2096 START_PROFILE(syscall_link);
2097 result = link(oldpath, newpath);
2098 END_PROFILE(syscall_link);
2099 return result;
2100 }
2101
2102 static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
2103 {
2104 int result;
2105
2106 START_PROFILE(syscall_mknod);
2107 result = sys_mknod(pathname, mode, dev);
2108 END_PROFILE(syscall_mknod);
2109 return result;
2110 }
2111
2112 static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path)
2113 {
2114 char *result;
2115
2116 START_PROFILE(syscall_realpath);
2117 #ifdef REALPATH_TAKES_NULL
2118 result = realpath(path, NULL);
2119 #else
2120 result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
2121 if (result) {
2122 char *resolved_path = realpath(path, result);
2123 if (!resolved_path) {
2124 SAFE_FREE(result);
2125 } else {
2126 /* SMB_ASSERT(result == resolved_path) ? */
2127 result = resolved_path;
2128 }
2129 }
2130 #endif
2131 END_PROFILE(syscall_realpath);
2132 return result;
2133 }
2134
2135 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
2136 struct sys_notify_context *ctx,
2137 const char *path,
2138 uint32_t *filter,
2139 uint32_t *subdir_filter,
2140 void (*callback)(struct sys_notify_context *ctx,
2141 void *private_data,
2142 struct notify_event *ev),
2143 void *private_data, void *handle)
2144 {
2145 /*
2146 * So far inotify is the only supported default notify mechanism. If
2147 * another platform like the the BSD's or a proprietary Unix comes
2148 * along and wants another default, we can play the same trick we
2149 * played with Posix ACLs.
2150 *
2151 * Until that is the case, hard-code inotify here.
2152 */
2153 #ifdef HAVE_INOTIFY
2154 if (lp_kernel_change_notify(vfs_handle->conn->params)) {
2155 int ret;
2156 if (!lp_parm_bool(-1, "notify", "inotify", True)) {
2157 return NT_STATUS_INVALID_SYSTEM_SERVICE;
2158 }
2159 /*
2160 * "ctx->private_data" is not obvious as a talloc context
2161 * here. Without modifying the VFS we don't have a mem_ctx
2162 * available here, and ctx->private_data was used by
2163 * inotify_watch before it got a real talloc parent.
2164 */
2165 ret = inotify_watch(ctx->private_data, ctx,
2166 path, filter, subdir_filter,
2167 callback, private_data, handle);
2168 if (ret != 0) {
2169 return map_nt_error_from_unix(ret);
2170 }
2171 return NT_STATUS_OK;
2172 }
2173 #endif
2174 /*
2175 * Do nothing, leave everything to notify_internal.c
2176 */
2177 return NT_STATUS_OK;
2178 }
2179
2180 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path,
2181 unsigned int flags)
2182 {
2183 #ifdef HAVE_CHFLAGS
2184 return chflags(path, flags);
2185 #else
2186 errno = ENOSYS;
2187 return -1;
2188 #endif
2189 }
2190
2191 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
2192 const SMB_STRUCT_STAT *sbuf)
2193 {
2194 struct file_id key;
2195
2196 /* the ZERO_STRUCT ensures padding doesn't break using the key as a
2197 * blob */
2198 ZERO_STRUCT(key);
2199
2200 key.devid = sbuf->st_ex_dev;
2201 key.inode = sbuf->st_ex_ino;
2202 /* key.extid is unused by default. */
2203
2204 return key;
2205 }
2206
2207 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
2208 struct files_struct *fsp,
2209 const char *fname,
2210 TALLOC_CTX *mem_ctx,
2211 unsigned int *pnum_streams,
2212 struct stream_struct **pstreams)
2213 {
2214 SMB_STRUCT_STAT sbuf;
2215 struct stream_struct *tmp_streams = NULL;
2216 int ret;
2217
2218 if ((fsp != NULL) && (fsp->is_directory)) {
2219 /*
2220 * No default streams on directories
2221 */
2222 goto done;
2223 }
2224
2225 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
2226 ret = SMB_VFS_FSTAT(fsp, &sbuf);
2227 }
2228 else {
2229 struct smb_filename smb_fname;
2230
2231 ZERO_STRUCT(smb_fname);
2232 smb_fname.base_name = discard_const_p(char, fname);
2233
2234 if (lp_posix_pathnames()) {
2235 ret = SMB_VFS_LSTAT(handle->conn, &smb_fname);
2236 } else {
2237 ret = SMB_VFS_STAT(handle->conn, &smb_fname);
2238 }
2239 sbuf = smb_fname.st;
2240 }
2241
2242 if (ret == -1) {
2243 return map_nt_error_from_unix(errno);
2244 }
2245
2246 if (S_ISDIR(sbuf.st_ex_mode)) {
2247 goto done;
2248 }
2249
2250 tmp_streams = talloc_realloc(mem_ctx, *pstreams, struct stream_struct,
2251 (*pnum_streams) + 1);
2252 if (tmp_streams == NULL) {
2253 return NT_STATUS_NO_MEMORY;
2254 }
2255 tmp_streams[*pnum_streams].name = talloc_strdup(tmp_streams, "::$DATA");
2256 if (tmp_streams[*pnum_streams].name == NULL) {
2257 return NT_STATUS_NO_MEMORY;
2258 }
2259 tmp_streams[*pnum_streams].size = sbuf.st_ex_size;
2260 tmp_streams[*pnum_streams].alloc_size = SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp, &sbuf);
2261
2262 *pnum_streams += 1;
2263 *pstreams = tmp_streams;
2264 done:
2265 return NT_STATUS_OK;
2266 }
2267
2268 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
2269 const char *path,
2270 const char *name,
2271 TALLOC_CTX *mem_ctx,
2272 char **found_name)
2273 {
2274 /*
2275 * Don't fall back to get_real_filename so callers can differentiate
2276 * between a full directory scan and an actual case-insensitive stat.
2277 */
2278 errno = EOPNOTSUPP;
2279 return -1;
2280 }
2281
2282 static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
2283 const char *fname)
2284 {
2285 return handle->conn->connectpath;
2286 }
2287
2288 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
2289 struct byte_range_lock *br_lck,
2290 struct lock_struct *plock,
2291 bool blocking_lock)
2292 {
2293 SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2294
2295 /* Note: blr is not used in the default implementation. */
2296 return brl_lock_windows_default(br_lck, plock, blocking_lock);
2297 }
2298
2299 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
2300 struct messaging_context *msg_ctx,
2301 struct byte_range_lock *br_lck,
2302 const struct lock_struct *plock)
2303 {
2304 SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2305
2306 return brl_unlock_windows_default(msg_ctx, br_lck, plock);
2307 }
2308
2309 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
2310 struct byte_range_lock *br_lck,
2311 struct lock_struct *plock)
2312 {
2313 SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2314
2315 /* Note: blr is not used in the default implementation. */
2316 return brl_lock_cancel_default(br_lck, plock);
2317 }
2318
2319 static bool vfswrap_strict_lock(struct vfs_handle_struct *handle,
2320 files_struct *fsp,
2321 struct lock_struct *plock)
2322 {
2323 SMB_ASSERT(plock->lock_type == READ_LOCK ||
2324 plock->lock_type == WRITE_LOCK);
2325
2326 return strict_lock_default(fsp, plock);
2327 }
2328
2329 static void vfswrap_strict_unlock(struct vfs_handle_struct *handle,
2330 files_struct *fsp,
2331 struct lock_struct *plock)
2332 {
2333 SMB_ASSERT(plock->lock_type == READ_LOCK ||
2334 plock->lock_type == WRITE_LOCK);
2335
2336 strict_unlock_default(fsp, plock);
2337 }
2338
2339 /* NT ACL operations. */
2340
2341 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
2342 files_struct *fsp,
2343 uint32_t security_info,
2344 TALLOC_CTX *mem_ctx,
2345 struct security_descriptor **ppdesc)
2346 {
2347 NTSTATUS result;
2348
2349 START_PROFILE(fget_nt_acl);
2350 result = posix_fget_nt_acl(fsp, security_info,
2351 mem_ctx, ppdesc);
2352 END_PROFILE(fget_nt_acl);
2353 return result;
2354 }
2355
2356 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
2357 const char *name,
2358 uint32_t security_info,
2359 TALLOC_CTX *mem_ctx,
2360 struct security_descriptor **ppdesc)
2361 {
2362 NTSTATUS result;
2363
2364 START_PROFILE(get_nt_acl);
2365 result = posix_get_nt_acl(handle->conn, name, security_info,
2366 mem_ctx, ppdesc);
2367 END_PROFILE(get_nt_acl);
2368 return result;
2369 }
2370
2371 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32_t security_info_sent, const struct security_descriptor *psd)
2372 {
2373 NTSTATUS result;
2374
2375 START_PROFILE(fset_nt_acl);
2376 result = set_nt_acl(fsp, security_info_sent, psd);
2377 END_PROFILE(fset_nt_acl);
2378 return result;
2379 }
2380
2381 static NTSTATUS vfswrap_audit_file(struct vfs_handle_struct *handle,
2382 struct smb_filename *file,
2383 struct security_acl *sacl,
2384 uint32_t access_requested,
2385 uint32_t access_denied)
2386 {
2387 return NT_STATUS_OK; /* Nothing to do here ... */
2388 }
2389
2390 static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
2391 {
2392 #ifdef HAVE_NO_ACL
2393 errno = ENOSYS;
2394 return -1;
2395 #else
2396 int result;
2397
2398 START_PROFILE(chmod_acl);
2399 result = chmod_acl(handle->conn, name, mode);
2400 END_PROFILE(chmod_acl);
2401 return result;
2402 #endif
2403 }
2404
2405 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
2406 {
2407 #ifdef HAVE_NO_ACL
2408 errno = ENOSYS;
2409 return -1;
2410 #else
2411 int result;
2412
2413 START_PROFILE(fchmod_acl);
2414 result = fchmod_acl(fsp, mode);
2415 END_PROFILE(fchmod_acl);
2416 return result;
2417 #endif
2418 }
2419
2420 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,
2421 const char *path_p,
2422 SMB_ACL_TYPE_T type,
2423 TALLOC_CTX *mem_ctx)
2424 {
2425 return sys_acl_get_file(handle, path_p, type, mem_ctx);
2426 }
2427
2428 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle,
2429 files_struct *fsp,
2430 TALLOC_CTX *mem_ctx)
2431 {
2432 return sys_acl_get_fd(handle, fsp, mem_ctx);
2433 }
2434
2435 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
2436 {
2437 return sys_acl_set_file(handle, name, acltype, theacl);
2438 }
2439
2440 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
2441 {
2442 return sys_acl_set_fd(handle, fsp, theacl);
2443 }
2444
2445 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
2446 {
2447 return sys_acl_delete_def_file(handle, path);
2448 }
2449
2450 /****************************************************************
2451 Extended attribute operations.
2452 *****************************************************************/
2453
2454 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
2455 {
2456 return getxattr(path, name, value, size);
2457 }
2458
2459 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
2460 {
2461 return fgetxattr(fsp->fh->fd, name, value, size);
2462 }
2463
2464 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
2465 {
2466 return listxattr(path, list, size);
2467 }
2468
2469 static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
2470 {
2471 return flistxattr(fsp->fh->fd, list, size);
2472 }
2473
2474 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
2475 {
2476 return removexattr(path, name);
2477 }
2478
2479 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
2480 {
2481 return fremovexattr(fsp->fh->fd, name);
2482 }
2483
2484 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
2485 {
2486 return setxattr(path, name, value, size, flags);
2487 }
2488
2489 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
2490 {
2491 return fsetxattr(fsp->fh->fd, name, value, size, flags);
2492 }
2493
2494 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
2495 {
2496 return false;
2497 }
2498
2499 static bool vfswrap_is_offline(struct vfs_handle_struct *handle,
2500 const struct smb_filename *fname,
2501 SMB_STRUCT_STAT *sbuf)
2502 {
2503 NTSTATUS status;
2504 char *path;
2505 bool offline = false;
2506
2507 if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
2508 return false;
2509 }
2510
2511 if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
2512 #if defined(ENOTSUP)
2513 errno = ENOTSUP;
2514 #endif
2515 return false;
2516 }
2517
2518 status = get_full_smb_filename(talloc_tos(), fname, &path);
2519 if (!NT_STATUS_IS_OK(status)) {
2520 errno = map_errno_from_nt_status(status);
2521 return false;
2522 }
2523
2524 offline = (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
2525
2526 TALLOC_FREE(path);
2527
2528 return offline;
2529 }
2530
2531 static int vfswrap_set_offline(struct vfs_handle_struct *handle,
2532 const struct smb_filename *fname)
2533 {
2534 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
2535 #if defined(ENOTSUP)
2536 errno = ENOTSUP;
2537 #endif
2538 return -1;
2539 }
2540
2541 static NTSTATUS vfswrap_durable_cookie(struct vfs_handle_struct *handle,
2542 struct files_struct *fsp,
2543 TALLOC_CTX *mem_ctx,
2544 DATA_BLOB *cookie)
2545 {
2546 return vfs_default_durable_cookie(fsp, mem_ctx, cookie);
2547 }
2548
2549 static NTSTATUS vfswrap_durable_disconnect(struct vfs_handle_struct *handle,
2550 struct files_struct *fsp,
2551 const DATA_BLOB old_cookie,
2552 TALLOC_CTX *mem_ctx,
2553 DATA_BLOB *new_cookie)
2554 {
2555 return vfs_default_durable_disconnect(fsp, old_cookie, mem_ctx,
2556 new_cookie);
2557 }
2558
2559 static NTSTATUS vfswrap_durable_reconnect(struct vfs_handle_struct *handle,
2560 struct smb_request *smb1req,
2561 struct smbXsrv_open *op,
2562 const DATA_BLOB old_cookie,
2563 TALLOC_CTX *mem_ctx,
2564 struct files_struct **fsp,
2565 DATA_BLOB *new_cookie)
2566 {
2567 return vfs_default_durable_reconnect(handle->conn, smb1req, op,
2568 old_cookie, mem_ctx,
2569 fsp, new_cookie);
2570 }
2571
2572 static struct vfs_fn_pointers vfs_default_fns = {
2573 /* Disk operations */
2574
2575 .connect_fn = vfswrap_connect,
2576 .disconnect_fn = vfswrap_disconnect,
2577 .disk_free_fn = vfswrap_disk_free,
2578 .get_quota_fn = vfswrap_get_quota,
2579 .set_quota_fn = vfswrap_set_quota,
2580 .get_shadow_copy_data_fn = vfswrap_get_shadow_copy_data,
2581 .statvfs_fn = vfswrap_statvfs,
2582 .fs_capabilities_fn = vfswrap_fs_capabilities,
2583 .get_dfs_referrals_fn = vfswrap_get_dfs_referrals,
2584 .snap_check_path_fn = vfswrap_snap_check_path,
2585 .snap_create_fn = vfswrap_snap_create,
2586 .snap_delete_fn = vfswrap_snap_delete,
2587
2588 /* Directory operations */
2589
2590 .opendir_fn = vfswrap_opendir,
2591 .fdopendir_fn = vfswrap_fdopendir,
2592 .readdir_fn = vfswrap_readdir,
2593 .readdir_attr_fn = vfswrap_readdir_attr,
2594 .seekdir_fn = vfswrap_seekdir,
2595 .telldir_fn = vfswrap_telldir,
2596 .rewind_dir_fn = vfswrap_rewinddir,
2597 .mkdir_fn = vfswrap_mkdir,
2598 .rmdir_fn = vfswrap_rmdir,
2599 .closedir_fn = vfswrap_closedir,
2600 .init_search_op_fn = vfswrap_init_search_op,
2601
2602 /* File operations */
2603
2604 .open_fn = vfswrap_open,
2605 .create_file_fn = vfswrap_create_file,
2606 .close_fn = vfswrap_close,
2607 .read_fn = vfswrap_read,
2608 .pread_fn = vfswrap_pread,
2609 .pread_send_fn = vfswrap_pread_send,
2610 .pread_recv_fn = vfswrap_asys_ssize_t_recv,
2611 .write_fn = vfswrap_write,
2612 .pwrite_fn = vfswrap_pwrite,
2613 .pwrite_send_fn = vfswrap_pwrite_send,
2614 .pwrite_recv_fn = vfswrap_asys_ssize_t_recv,
2615 .lseek_fn = vfswrap_lseek,
2616 .sendfile_fn = vfswrap_sendfile,
2617 .recvfile_fn = vfswrap_recvfile,
2618 .rename_fn = vfswrap_rename,
2619 .fsync_fn = vfswrap_fsync,
2620 .fsync_send_fn = vfswrap_fsync_send,
2621 .fsync_recv_fn = vfswrap_asys_int_recv,
2622 .stat_fn = vfswrap_stat,
2623 .fstat_fn = vfswrap_fstat,
2624 .lstat_fn = vfswrap_lstat,
2625 .get_alloc_size_fn = vfswrap_get_alloc_size,
2626 .unlink_fn = vfswrap_unlink,
2627 .chmod_fn = vfswrap_chmod,
2628 .fchmod_fn = vfswrap_fchmod,
2629 .chown_fn = vfswrap_chown,
2630 .fchown_fn = vfswrap_fchown,
2631 .lchown_fn = vfswrap_lchown,
2632 .chdir_fn = vfswrap_chdir,
2633 .getwd_fn = vfswrap_getwd,
2634 .ntimes_fn = vfswrap_ntimes,
2635 .ftruncate_fn = vfswrap_ftruncate,
2636 .fallocate_fn = vfswrap_fallocate,
2637 .lock_fn = vfswrap_lock,
2638 .kernel_flock_fn = vfswrap_kernel_flock,
2639 .linux_setlease_fn = vfswrap_linux_setlease,
2640 .getlock_fn = vfswrap_getlock,
2641 .symlink_fn = vfswrap_symlink,
2642 .readlink_fn = vfswrap_readlink,
2643 .link_fn = vfswrap_link,
2644 .mknod_fn = vfswrap_mknod,
2645 .realpath_fn = vfswrap_realpath,
2646 .notify_watch_fn = vfswrap_notify_watch,
2647 .chflags_fn = vfswrap_chflags,
2648 .file_id_create_fn = vfswrap_file_id_create,
2649 .streaminfo_fn = vfswrap_streaminfo,
2650 .get_real_filename_fn = vfswrap_get_real_filename,
2651 .connectpath_fn = vfswrap_connectpath,
2652 .brl_lock_windows_fn = vfswrap_brl_lock_windows,
2653 .brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
2654 .brl_cancel_windows_fn = vfswrap_brl_cancel_windows,
2655 .strict_lock_fn = vfswrap_strict_lock,
2656 .strict_unlock_fn = vfswrap_strict_unlock,
2657 .translate_name_fn = vfswrap_translate_name,
2658 .fsctl_fn = vfswrap_fsctl,
2659 .copy_chunk_send_fn = vfswrap_copy_chunk_send,
2660 .copy_chunk_recv_fn = vfswrap_copy_chunk_recv,
2661 .get_compression_fn = vfswrap_get_compression,
2662 .set_compression_fn = vfswrap_set_compression,
2663
2664 /* NT ACL operations. */
2665
2666 .fget_nt_acl_fn = vfswrap_fget_nt_acl,
2667 .get_nt_acl_fn = vfswrap_get_nt_acl,
2668 .fset_nt_acl_fn = vfswrap_fset_nt_acl,
2669 .audit_file_fn = vfswrap_audit_file,
2670
2671 /* POSIX ACL operations. */
2672
2673 .chmod_acl_fn = vfswrap_chmod_acl,
2674 .fchmod_acl_fn = vfswrap_fchmod_acl,
2675
2676 .sys_acl_get_file_fn = vfswrap_sys_acl_get_file,
2677 .sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd,
2678 .sys_acl_blob_get_file_fn = posix_sys_acl_blob_get_file,
2679 .sys_acl_blob_get_fd_fn = posix_sys_acl_blob_get_fd,
2680 .sys_acl_set_file_fn = vfswrap_sys_acl_set_file,
2681 .sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd,
2682 .sys_acl_delete_def_file_fn = vfswrap_sys_acl_delete_def_file,
2683
2684 /* EA operations. */
2685 .getxattr_fn = vfswrap_getxattr,
2686 .fgetxattr_fn = vfswrap_fgetxattr,
2687 .listxattr_fn = vfswrap_listxattr,
2688 .flistxattr_fn = vfswrap_flistxattr,
2689 .removexattr_fn = vfswrap_removexattr,
2690 .fremovexattr_fn = vfswrap_fremovexattr,
2691 .setxattr_fn = vfswrap_setxattr,
2692 .fsetxattr_fn = vfswrap_fsetxattr,
2693
2694 /* aio operations */
2695 .aio_force_fn = vfswrap_aio_force,
2696
2697 /* offline operations */
2698 .is_offline_fn = vfswrap_is_offline,
2699 .set_offline_fn = vfswrap_set_offline,
2700
2701 /* durable handle operations */
2702 .durable_cookie_fn = vfswrap_durable_cookie,
2703 .durable_disconnect_fn = vfswrap_durable_disconnect,
2704 .durable_reconnect_fn = vfswrap_durable_reconnect,
2705 };
2706
2707 NTSTATUS vfs_default_init(void);
2708 NTSTATUS vfs_default_init(void)
2709 {
2710 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2711 DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
2712 }
2713
2714
Samba GIT mirror