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