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