2 * Unix SMB/CIFS implementation.
4 * Support for OneFS Alternate Data Streams
6 * Copyright (C) Tim Prouty, 2008
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include "onefs_config.h"
26 #include <sys/isi_enc.h>
28 NTSTATUS onefs_stream_prep_smb_fname(TALLOC_CTX *ctx,
29 const struct smb_filename *smb_fname_in,
30 struct smb_filename **smb_fname_out)
32 char *stream_name = NULL;
36 * Only attempt to strip off the trailing :$DATA if there is an actual
37 * stream there. If it is the default stream, the smb_fname_out will
38 * just have a NULL stream so the base file is opened.
40 if (smb_fname_in->stream_name &&
41 !is_ntfs_default_stream_smb_fname(smb_fname_in)) {
42 char *str_tmp = smb_fname_in->stream_name;
44 /* First strip off the leading ':' */
45 if (str_tmp[0] == ':') {
49 /* Create a new copy of the stream_name. */
50 stream_name = talloc_strdup(ctx, str_tmp);
51 if (stream_name == NULL) {
52 return NT_STATUS_NO_MEMORY;
55 /* Strip off the :$DATA if one exists. */
56 str_tmp = strrchr_m(stream_name, ':');
58 if (StrCaseCmp(str_tmp, ":$DATA") != 0) {
59 return NT_STATUS_INVALID_PARAMETER;
66 * If there was a stream that wasn't the default stream the leading
67 * colon and trailing :$DATA has now been stripped off. Create a new
68 * smb_filename to pass back.
70 status = create_synthetic_smb_fname(ctx, smb_fname_in->base_name,
71 stream_name, &smb_fname_in->st,
73 TALLOC_FREE(stream_name);
77 int onefs_close(vfs_handle_struct *handle, struct files_struct *fsp)
82 ret = SMB_VFS_NEXT_CLOSE(handle, fsp->base_fsp);
84 ret2 = SMB_VFS_NEXT_CLOSE(handle, fsp);
86 return ret ? ret : ret2;
90 * Get the ADS directory fd for a file.
92 static int get_stream_dir_fd(connection_struct *conn, const char *base,
99 /* If a valid base_fdp was given, use it. */
100 if (base_fdp && *base_fdp >= 0) {
103 base_fd = onefs_sys_create_file(conn,
122 /* Open the ADS directory. */
123 dir_fd = onefs_sys_create_file(conn,
138 /* Close base_fd if it's not need or on error. */
139 if (!base_fdp || dir_fd < 0) {
145 /* Set the out base_fdp if successful and it was requested. */
146 if (base_fdp && dir_fd >= 0) {
153 int onefs_rename(vfs_handle_struct *handle,
154 const struct smb_filename *smb_fname_src,
155 const struct smb_filename *smb_fname_dst)
157 struct smb_filename *smb_fname_src_onefs = NULL;
158 struct smb_filename *smb_fname_dst_onefs = NULL;
164 START_PROFILE(syscall_rename_at);
166 if (!is_ntfs_stream_smb_fname(smb_fname_src) &&
167 !is_ntfs_stream_smb_fname(smb_fname_dst)) {
168 ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src,
173 /* For now don't allow renames from or to the default stream. */
174 if (is_ntfs_default_stream_smb_fname(smb_fname_src) ||
175 is_ntfs_default_stream_smb_fname(smb_fname_dst)) {
180 /* prep stream smb_filename structs. */
181 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname_src,
182 &smb_fname_src_onefs);
183 if (!NT_STATUS_IS_OK(status)) {
184 errno = map_errno_from_nt_status(status);
187 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname_dst,
188 &smb_fname_dst_onefs);
189 if (!NT_STATUS_IS_OK(status)) {
190 errno = map_errno_from_nt_status(status);
194 dir_fd = get_stream_dir_fd(handle->conn, smb_fname_src->base_name,
200 DEBUG(8, ("onefs_rename called for %s => %s\n",
201 smb_fname_str_dbg(smb_fname_src_onefs),
202 smb_fname_str_dbg(smb_fname_dst_onefs)));
204 /* Handle rename of stream to default stream specially. */
205 if (smb_fname_dst_onefs->stream_name == NULL) {
206 ret = enc_renameat(dir_fd, smb_fname_src_onefs->stream_name,
207 ENC_DEFAULT, AT_FDCWD,
208 smb_fname_dst_onefs->base_name,
211 ret = enc_renameat(dir_fd, smb_fname_src_onefs->stream_name,
213 smb_fname_dst_onefs->stream_name,
218 END_PROFILE(syscall_rename_at);
219 TALLOC_FREE(smb_fname_src_onefs);
220 TALLOC_FREE(smb_fname_dst_onefs);
231 * Merge a base file's sbuf into the a streams's sbuf.
233 static void merge_stat(SMB_STRUCT_STAT *stream_sbuf,
234 const SMB_STRUCT_STAT *base_sbuf)
236 int dos_flags = (UF_DOS_NOINDEX | UF_DOS_ARCHIVE |
237 UF_DOS_HIDDEN | UF_DOS_RO | UF_DOS_SYSTEM);
238 stream_sbuf->st_ex_mtime = base_sbuf->st_ex_mtime;
239 stream_sbuf->st_ex_ctime = base_sbuf->st_ex_ctime;
240 stream_sbuf->st_ex_atime = base_sbuf->st_ex_atime;
241 stream_sbuf->st_ex_flags &= ~dos_flags;
242 stream_sbuf->st_ex_flags |= base_sbuf->st_ex_flags & dos_flags;
245 /* fake timestamps */
246 static void onefs_adjust_stat_time(struct connection_struct *conn,
247 const char *fname, SMB_STRUCT_STAT *sbuf)
249 struct onefs_vfs_share_config cfg;
250 struct timeval tv_now = {0, 0};
251 bool static_mtime = False;
252 bool static_atime = False;
254 if (!onefs_get_config(SNUM(conn),
255 ONEFS_VFS_CONFIG_FAKETIMESTAMPS, &cfg)) {
259 if (IS_MTIME_STATIC_PATH(conn, &cfg, fname)) {
260 sbuf->st_ex_mtime = sbuf->st_ex_btime;
263 if (IS_ATIME_STATIC_PATH(conn, &cfg, fname)) {
264 sbuf->st_ex_atime = sbuf->st_ex_btime;
268 if (IS_CTIME_NOW_PATH(conn, &cfg, fname)) {
269 if (cfg.ctime_slop < 0) {
270 sbuf->st_ex_btime.tv_sec = INT_MAX - 1;
272 GetTimeOfDay(&tv_now);
273 sbuf->st_ex_btime.tv_sec = tv_now.tv_sec +
278 if (!static_mtime && IS_MTIME_NOW_PATH(conn,&cfg,fname)) {
279 if (cfg.mtime_slop < 0) {
280 sbuf->st_ex_mtime.tv_sec = INT_MAX - 1;
282 if (tv_now.tv_sec == 0)
283 GetTimeOfDay(&tv_now);
284 sbuf->st_ex_mtime.tv_sec = tv_now.tv_sec +
288 if (!static_atime && IS_ATIME_NOW_PATH(conn,&cfg,fname)) {
289 if (cfg.atime_slop < 0) {
290 sbuf->st_ex_atime.tv_sec = INT_MAX - 1;
292 if (tv_now.tv_sec == 0)
293 GetTimeOfDay(&tv_now);
294 sbuf->st_ex_atime.tv_sec = tv_now.tv_sec +
300 static int stat_stream(struct connection_struct *conn, const char *base,
301 const char *stream, SMB_STRUCT_STAT *sbuf, int flags)
303 SMB_STRUCT_STAT base_sbuf;
304 int base_fd = -1, dir_fd, ret, saved_errno;
306 dir_fd = get_stream_dir_fd(conn, base, &base_fd);
311 /* Stat the stream. */
312 ret = onefs_sys_fstat_at(dir_fd, stream, sbuf, flags);
314 /* Now stat the base file and merge the results. */
315 ret = onefs_sys_fstat(base_fd, &base_sbuf);
317 merge_stat(sbuf, &base_sbuf);
328 int onefs_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
330 struct smb_filename *smb_fname_onefs = NULL;
334 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname,
336 if (!NT_STATUS_IS_OK(status)) {
337 errno = map_errno_from_nt_status(status);
342 * If the smb_fname has no stream or is :$DATA, then just stat the
343 * base stream. Otherwise stat the stream.
345 if (!is_ntfs_stream_smb_fname(smb_fname_onefs)) {
346 ret = onefs_sys_stat(smb_fname_onefs->base_name,
349 ret = stat_stream(handle->conn, smb_fname_onefs->base_name,
350 smb_fname_onefs->stream_name, &smb_fname->st,
354 onefs_adjust_stat_time(handle->conn, smb_fname->base_name,
357 TALLOC_FREE(smb_fname_onefs);
362 int onefs_fstat(vfs_handle_struct *handle, struct files_struct *fsp,
363 SMB_STRUCT_STAT *sbuf)
365 SMB_STRUCT_STAT base_sbuf;
368 /* Stat the stream, by calling next_fstat on the stream's fd. */
369 ret = onefs_sys_fstat(fsp->fh->fd, sbuf);
374 /* Stat the base file and merge the results. */
375 if (fsp != NULL && fsp->base_fsp != NULL) {
376 ret = onefs_sys_fstat(fsp->base_fsp->fh->fd, &base_sbuf);
378 merge_stat(sbuf, &base_sbuf);
382 onefs_adjust_stat_time(handle->conn, fsp->fsp_name->base_name, sbuf);
386 int onefs_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
388 struct smb_filename *smb_fname_onefs = NULL;
392 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname,
394 if (!NT_STATUS_IS_OK(status)) {
395 errno = map_errno_from_nt_status(status);
400 * If the smb_fname has no stream or is :$DATA, then just stat the
401 * base stream. Otherwise stat the stream.
403 if (!is_ntfs_stream_smb_fname(smb_fname_onefs)) {
404 ret = onefs_sys_lstat(smb_fname_onefs->base_name,
407 ret = stat_stream(handle->conn, smb_fname_onefs->base_name,
408 smb_fname_onefs->stream_name, &smb_fname->st,
409 AT_SYMLINK_NOFOLLOW);
412 onefs_adjust_stat_time(handle->conn, smb_fname->base_name,
415 TALLOC_FREE(smb_fname_onefs);
420 int onefs_unlink(vfs_handle_struct *handle,
421 const struct smb_filename *smb_fname)
423 struct smb_filename *smb_fname_onefs = NULL;
425 int dir_fd, saved_errno;
429 if (!is_ntfs_stream_smb_fname(smb_fname)) {
430 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
433 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname,
435 if (!NT_STATUS_IS_OK(status)) {
436 errno = map_errno_from_nt_status(status);
440 /* Default stream (the ::$DATA was just stripped off). */
441 if (!is_ntfs_stream_smb_fname(smb_fname_onefs)) {
442 ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_onefs);
446 dir_fd = get_stream_dir_fd(handle->conn, smb_fname_onefs->base_name,
453 ret = enc_unlinkat(dir_fd, smb_fname_onefs->stream_name, ENC_DEFAULT,
460 TALLOC_FREE(smb_fname_onefs);
464 int onefs_vtimes_streams(vfs_handle_struct *handle,
465 const struct smb_filename *smb_fname,
466 int flags, struct timespec times[3])
468 struct smb_filename *smb_fname_onefs = NULL;
474 START_PROFILE(syscall_ntimes);
476 if (!is_ntfs_stream_smb_fname(smb_fname)) {
477 ret = vtimes(smb_fname->base_name, times, flags);
481 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname,
483 if (!NT_STATUS_IS_OK(status)) {
484 errno = map_errno_from_nt_status(status);
488 /* Default stream (the ::$DATA was just stripped off). */
489 if (!is_ntfs_stream_smb_fname(smb_fname_onefs)) {
490 ret = vtimes(smb_fname_onefs->base_name, times, flags);
494 dirfd = get_stream_dir_fd(handle->conn, smb_fname->base_name, NULL);
500 ret = enc_vtimesat(dirfd, smb_fname_onefs->stream_name, ENC_DEFAULT,
508 END_PROFILE(syscall_ntimes);
509 TALLOC_FREE(smb_fname_onefs);
514 * Streaminfo enumeration functionality
516 struct streaminfo_state {
518 vfs_handle_struct *handle;
519 unsigned int num_streams;
520 struct stream_struct *streams;
524 static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
525 struct stream_struct **streams,
526 const char *name, SMB_OFF_T size,
527 SMB_OFF_T alloc_size)
529 struct stream_struct *tmp;
531 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, *streams, struct stream_struct,
537 tmp[*num_streams].name = talloc_asprintf(mem_ctx, ":%s:%s", name,
539 if (tmp[*num_streams].name == NULL) {
543 tmp[*num_streams].size = size;
544 tmp[*num_streams].alloc_size = alloc_size;
551 static NTSTATUS walk_onefs_streams(connection_struct *conn, files_struct *fsp,
553 struct streaminfo_state *state,
554 SMB_STRUCT_STAT *base_sbuf)
556 NTSTATUS status = NT_STATUS_OK;
557 bool opened_base_fd = false;
562 SMB_STRUCT_DIR *dirp = NULL;
563 SMB_STRUCT_DIRENT *dp = NULL;
564 files_struct fake_fs;
565 struct fd_handle fake_fh;
566 SMB_STRUCT_STAT stream_sbuf;
568 ZERO_STRUCT(fake_fh);
569 ZERO_STRUCT(fake_fs);
571 /* If the base file is already open, use its fd. */
572 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
573 base_fd = fsp->fh->fd;
575 opened_base_fd = true;
578 dir_fd = get_stream_dir_fd(conn, fname, &base_fd);
580 return map_nt_error_from_unix(errno);
583 /* Open the ADS directory. */
584 if ((dirp = fdopendir(dir_fd)) == NULL) {
585 DEBUG(0, ("Error on opendir %s. errno=%d (%s)\n",
586 fname, errno, strerror(errno)));
587 status = map_nt_error_from_unix(errno);
591 /* Initialize the dir state struct and add it to the list.
592 * This is a layer violation, and really should be handled by a
593 * VFS_FDOPENDIR() call which would properly setup the dir state.
594 * But since this is all within the onefs.so module, we cheat for
595 * now and call directly into the readdirplus code.
596 * NOTE: This state MUST be freed by a proper VFS_CLOSEDIR() call. */
597 ret = onefs_rdp_add_dir_state(conn, dirp);
599 DEBUG(0, ("Error adding dir_state to the list\n"));
600 status = map_nt_error_from_unix(errno);
605 fake_fs.fh = &fake_fh;
606 status = create_synthetic_smb_fname(talloc_tos(), fname, NULL, NULL,
608 if (!NT_STATUS_IS_OK(status)) {
612 /* Iterate over the streams in the ADS directory. */
613 while ((dp = SMB_VFS_READDIR(conn, dirp, NULL)) != NULL) {
614 /* Skip the "." and ".." entries */
615 if ((strcmp(dp->d_name, ".") == 0) ||
616 (strcmp(dp->d_name, "..") == 0))
619 /* Open actual stream */
620 if ((stream_fd = onefs_sys_create_file(conn,
634 DEBUG(0, ("Error opening stream %s:%s. "
635 "errno=%d (%s)\n", fname, dp->d_name, errno,
640 /* Figure out the stat info. */
641 fake_fh.fd = stream_fd;
642 ret = SMB_VFS_FSTAT(&fake_fs, &stream_sbuf);
646 DEBUG(0, ("Error fstating stream %s:%s. "
647 "errno=%d (%s)\n", fname, dp->d_name, errno,
652 merge_stat(&stream_sbuf, base_sbuf);
654 if (!add_one_stream(state->mem_ctx,
655 &state->num_streams, &state->streams,
656 dp->d_name, stream_sbuf.st_ex_size,
657 SMB_VFS_GET_ALLOC_SIZE(conn, NULL,
659 state->status = NT_STATUS_NO_MEMORY;
665 /* Cleanup everything that was opened. */
667 SMB_VFS_CLOSEDIR(conn, dirp);
672 if (opened_base_fd) {
673 SMB_ASSERT(base_fd >= 0);
677 TALLOC_FREE(fake_fs.fsp_name);
681 NTSTATUS onefs_streaminfo(vfs_handle_struct *handle,
682 struct files_struct *fsp,
685 unsigned int *num_streams,
686 struct stream_struct **streams)
688 SMB_STRUCT_STAT sbuf;
691 struct streaminfo_state state;
693 /* Get a valid stat. */
694 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
695 ret = SMB_VFS_FSTAT(fsp, &sbuf);
697 struct smb_filename *smb_fname = NULL;
699 status = create_synthetic_smb_fname(talloc_tos(), fname, NULL,
701 if (!NT_STATUS_IS_OK(status)) {
704 ret = SMB_VFS_STAT(handle->conn, smb_fname);
706 sbuf = smb_fname->st;
708 TALLOC_FREE(smb_fname);
712 return map_nt_error_from_unix(errno);
715 state.streams = NULL;
716 state.num_streams = 0;
718 if (lp_parm_bool(SNUM(handle->conn), PARM_ONEFS_TYPE,
719 PARM_IGNORE_STREAMS, PARM_IGNORE_STREAMS_DEFAULT)) {
723 /* Add the default stream. */
724 if (S_ISREG(sbuf.st_ex_mode)) {
725 if (!add_one_stream(mem_ctx,
726 &state.num_streams, &state.streams,
728 SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp,
730 return NT_STATUS_NO_MEMORY;
734 state.mem_ctx = mem_ctx;
735 state.handle = handle;
736 state.status = NT_STATUS_OK;
738 /* If there are more streams, add them too. */
739 if (sbuf.st_ex_flags & UF_HASADS) {
741 status = walk_onefs_streams(handle->conn, fsp, fname,
744 if (!NT_STATUS_IS_OK(status)) {
745 TALLOC_FREE(state.streams);
749 if (!NT_STATUS_IS_OK(state.status)) {
750 TALLOC_FREE(state.streams);
755 *num_streams = state.num_streams;
756 *streams = state.streams;