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