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