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/>.
23 #include <sys/isi_enc.h>
26 * OneFS stores streams without the explicit :$DATA at the end, so this strips
27 * it off. All onefs_stream functions must call through this instead of
28 * split_ntfs_stream_name directly.
30 NTSTATUS onefs_split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
31 char **pbase, char **pstream)
36 status = split_ntfs_stream_name(mem_ctx, fname, pbase, pstream);
37 if (!NT_STATUS_IS_OK(status)) {
41 /* Default $DATA stream. */
42 if (pstream == NULL || *pstream == NULL) {
46 /* Strip off the $DATA. */
47 stream = strrchr_m(*pstream, ':');
54 int onefs_is_stream(const char *path, char **pbase, char **pstream,
57 (*is_stream) = is_ntfs_stream_name(path);
63 if (!NT_STATUS_IS_OK(onefs_split_ntfs_stream_name(talloc_tos(), path,
65 DEBUG(10, ("onefs_split_ntfs_stream_name failed\n"));
73 int onefs_close(vfs_handle_struct *handle, struct files_struct *fsp)
78 ret = SMB_VFS_NEXT_CLOSE(handle, fsp->base_fsp);
80 ret2 = SMB_VFS_NEXT_CLOSE(handle, fsp);
82 return ret ? ret : ret2;
86 * Get the ADS directory fd for a file.
88 static int get_stream_dir_fd(connection_struct *conn, const char *base,
95 /* If a valid base_fdp was given, use it. */
96 if (base_fdp && *base_fdp >= 0) {
99 base_fd = onefs_sys_create_file(conn,
118 /* Open the ADS directory. */
119 dir_fd = onefs_sys_create_file(conn,
134 /* Close base_fd if it's not need or on error. */
135 if (!base_fdp || dir_fd < 0) {
141 /* Set the out base_fdp if successful and it was requested. */
142 if (base_fdp && dir_fd >= 0) {
149 int onefs_rename(vfs_handle_struct *handle, const char *oldname,
152 TALLOC_CTX *frame = NULL;
163 frame = talloc_stackframe();
165 ret = onefs_is_stream(oldname, &obase, &osname, &old_is_stream);
169 ret = onefs_is_stream(newname, &nbase, &nsname, &new_is_stream);
173 if (!old_is_stream && !new_is_stream) {
174 return SMB_VFS_NEXT_RENAME(handle, oldname, newname);
177 dir_fd = get_stream_dir_fd(handle->conn, obase, NULL);
182 DEBUG(8,("onefs_rename called for %s : %s => %s : %s\n",
183 obase, osname, nbase, nsname));
185 /* Handle rename of stream to default stream specially. */
186 if (nsname == NULL) {
187 ret = enc_renameat(dir_fd, osname, ENC_DEFAULT, AT_FDCWD,
190 ret = enc_renameat(dir_fd, osname, ENC_DEFAULT, dir_fd, nsname,
205 * Merge a base file's sbuf into the a streams's sbuf.
207 static void merge_stat(SMB_STRUCT_STAT *stream_sbuf,
208 const SMB_STRUCT_STAT *base_sbuf)
210 int dos_flags = (UF_DOS_NOINDEX | UF_DOS_ARCHIVE |
211 UF_DOS_HIDDEN | UF_DOS_RO | UF_DOS_SYSTEM);
212 stream_sbuf->st_mtime = base_sbuf->st_mtime;
213 stream_sbuf->st_ctime = base_sbuf->st_ctime;
214 stream_sbuf->st_atime = base_sbuf->st_atime;
215 stream_sbuf->st_flags &= ~dos_flags;
216 stream_sbuf->st_flags |= base_sbuf->st_flags & dos_flags;
219 static int stat_stream(vfs_handle_struct *handle, const char *base,
220 const char *stream, SMB_STRUCT_STAT *sbuf, int flags)
222 SMB_STRUCT_STAT base_sbuf;
223 int base_fd = -1, dir_fd, ret, saved_errno;
225 dir_fd = get_stream_dir_fd(handle->conn, base, &base_fd);
230 /* Stat the stream. */
231 ret = enc_fstatat(dir_fd, stream, ENC_DEFAULT, sbuf, flags);
233 /* Now stat the base file and merge the results. */
234 ret = sys_fstat(base_fd, &base_sbuf);
236 merge_stat(sbuf, &base_sbuf);
247 int onefs_stat(vfs_handle_struct *handle, const char *path,
248 SMB_STRUCT_STAT *sbuf)
255 ret = onefs_is_stream(path, &base, &stream, &is_stream);
260 return SMB_VFS_NEXT_STAT(handle, path, sbuf);
263 /* If it's the ::$DATA stream just stat the base file name. */
265 return SMB_VFS_NEXT_STAT(handle, base, sbuf);
268 return stat_stream(handle, base, stream, sbuf, 0);
271 int onefs_fstat(vfs_handle_struct *handle, struct files_struct *fsp,
272 SMB_STRUCT_STAT *sbuf)
274 SMB_STRUCT_STAT base_sbuf;
277 /* Stat the stream, by calling next_fstat on the stream's fd. */
278 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
283 /* Stat the base file and merge the results. */
284 if (fsp != NULL && fsp->base_fsp != NULL) {
285 ret = sys_fstat(fsp->base_fsp->fh->fd, &base_sbuf);
287 merge_stat(sbuf, &base_sbuf);
294 int onefs_lstat(vfs_handle_struct *handle, const char *path,
295 SMB_STRUCT_STAT *sbuf)
302 ret = onefs_is_stream(path, &base, &stream, &is_stream);
307 return SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
310 /* If it's the ::$DATA stream just stat the base file name. */
312 return SMB_VFS_NEXT_LSTAT(handle, base, sbuf);
315 return stat_stream(handle, base, stream, sbuf, AT_SYMLINK_NOFOLLOW);
318 int onefs_unlink(vfs_handle_struct *handle, const char *path)
324 int dir_fd, saved_errno;
326 ret = onefs_is_stream(path, &base, &stream, &is_stream);
332 return SMB_VFS_NEXT_UNLINK(handle, path);
335 /* If it's the ::$DATA stream just unlink the base file name. */
337 return SMB_VFS_NEXT_UNLINK(handle, base);
340 dir_fd = get_stream_dir_fd(handle->conn, base, NULL);
345 ret = enc_unlinkat(dir_fd, stream, ENC_DEFAULT, 0);
353 int onefs_vtimes_streams(vfs_handle_struct *handle, const char *fname,
354 int flags, struct timespec times[3])
363 START_PROFILE(syscall_ntimes);
365 ret = onefs_is_stream(fname, &base, &stream, &is_stream);
370 ret = vtimes(fname, times, flags);
374 dirfd = get_stream_dir_fd(handle->conn, base, NULL);
379 ret = enc_vtimesat(dirfd, stream, ENC_DEFAULT, times, flags);
381 END_PROFILE(syscall_ntimes);
389 int onefs_chflags(vfs_handle_struct *handle, const char *path,
395 if (!NT_STATUS_IS_OK(onefs_split_ntfs_stream_name(talloc_tos(), path,
397 DEBUG(10, ("onefs_split_ntfs_stream_name failed\n"));
403 * Only set the attributes on the base file. ifs_createfile handles
404 * file creation attribute semantics.
406 return SMB_VFS_NEXT_CHFLAGS(handle, base, flags);
410 * Streaminfo enumeration functionality
412 struct streaminfo_state {
414 vfs_handle_struct *handle;
415 unsigned int num_streams;
416 struct stream_struct *streams;
420 static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
421 struct stream_struct **streams,
422 const char *name, SMB_OFF_T size,
423 SMB_OFF_T alloc_size)
425 struct stream_struct *tmp;
427 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, *streams, struct stream_struct,
433 tmp[*num_streams].name = talloc_asprintf(mem_ctx, ":%s:%s", name,
435 if (tmp[*num_streams].name == NULL) {
439 tmp[*num_streams].size = size;
440 tmp[*num_streams].alloc_size = alloc_size;
447 static NTSTATUS walk_onefs_streams(connection_struct *conn, files_struct *fsp,
449 struct streaminfo_state *state,
450 SMB_STRUCT_STAT *base_sbuf)
452 NTSTATUS status = NT_STATUS_OK;
453 bool opened_base_fd = false;
458 SMB_STRUCT_DIR *dirp = NULL;
459 SMB_STRUCT_DIRENT *dp = NULL;
460 files_struct fake_fs;
461 struct fd_handle fake_fh;
462 SMB_STRUCT_STAT stream_sbuf;
464 ZERO_STRUCT(fake_fh);
465 ZERO_STRUCT(fake_fs);
467 /* If the base file is already open, use its fd. */
468 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
469 base_fd = fsp->fh->fd;
471 opened_base_fd = true;
474 dir_fd = get_stream_dir_fd(conn, fname, &base_fd);
476 return map_nt_error_from_unix(errno);
479 /* Open the ADS directory. */
480 if ((dirp = fdopendir(dir_fd)) == NULL) {
481 DEBUG(0, ("Error on opendir %s. errno=%d (%s)\n",
482 fname, errno, strerror(errno)));
483 status = map_nt_error_from_unix(errno);
488 fake_fs.fh = &fake_fh;
489 fake_fs.fsp_name = SMB_STRDUP(fname);
491 /* Iterate over the streams in the ADS directory. */
492 while ((dp = SMB_VFS_READDIR(conn, dirp)) != NULL) {
493 /* Skip the "." and ".." entries */
494 if ((strcmp(dp->d_name, ".") == 0) ||
495 (strcmp(dp->d_name, "..") == 0))
498 /* Open actual stream */
499 if ((stream_fd = onefs_sys_create_file(conn,
513 DEBUG(0, ("Error opening stream %s:%s. "
514 "errno=%d (%s)\n", fname, dp->d_name, errno,
519 /* Figure out the stat info. */
520 fake_fh.fd = stream_fd;
521 ret = SMB_VFS_FSTAT(&fake_fs, &stream_sbuf);
525 DEBUG(0, ("Error fstating stream %s:%s. "
526 "errno=%d (%s)\n", fname, dp->d_name, errno,
531 merge_stat(&stream_sbuf, base_sbuf);
533 if (!add_one_stream(state->mem_ctx,
534 &state->num_streams, &state->streams,
535 dp->d_name, stream_sbuf.st_size,
536 SMB_VFS_GET_ALLOC_SIZE(conn, NULL,
538 state->status = NT_STATUS_NO_MEMORY;
544 /* Cleanup everything that was opened. */
546 SMB_VFS_CLOSEDIR(conn, dirp);
551 if (opened_base_fd) {
552 SMB_ASSERT(base_fd >= 0);
556 SAFE_FREE(fake_fs.fsp_name);
560 NTSTATUS onefs_streaminfo(vfs_handle_struct *handle,
561 struct files_struct *fsp,
564 unsigned int *num_streams,
565 struct stream_struct **streams)
567 SMB_STRUCT_STAT sbuf;
570 struct streaminfo_state state;
572 /* Get a valid stat. */
573 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
574 if (is_ntfs_stream_name(fsp->fsp_name)) {
575 return NT_STATUS_INVALID_PARAMETER;
577 ret = SMB_VFS_FSTAT(fsp, &sbuf);
579 if (is_ntfs_stream_name(fname)) {
580 return NT_STATUS_INVALID_PARAMETER;
582 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
586 return map_nt_error_from_unix(errno);
589 state.streams = NULL;
590 state.num_streams = 0;
592 /* Add the default stream. */
593 if (S_ISREG(sbuf.st_mode)) {
594 if (!add_one_stream(mem_ctx,
595 &state.num_streams, &state.streams,
597 SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp,
599 return NT_STATUS_NO_MEMORY;
603 state.mem_ctx = mem_ctx;
604 state.handle = handle;
605 state.status = NT_STATUS_OK;
607 /* If there are more streams, add them too. */
608 if (sbuf.st_flags & UF_HASADS) {
610 status = walk_onefs_streams(handle->conn, fsp, fname,
613 if (!NT_STATUS_IS_OK(status)) {
614 TALLOC_FREE(state.streams);
618 if (!NT_STATUS_IS_OK(state.status)) {
619 TALLOC_FREE(state.streams);
624 *num_streams = state.num_streams;
625 *streams = state.streams;