2 * Store streams in xattrs
4 * Copyright (C) Volker Lendecke, 2008
6 * Partly based on James Peach's Darwin module, which is
8 * Copyright (C) James Peach 2006-2007
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
27 #define DBGC_CLASS DBGC_VFS
34 vfs_handle_struct *handle;
37 static SMB_INO_T stream_inode(const SMB_STRUCT_STAT *sbuf, const char *sname)
39 struct MD5Context ctx;
40 unsigned char hash[16];
44 DEBUG(10, ("stream_inode called for %lu/%lu [%s]\n",
45 (unsigned long)sbuf->st_dev,
46 (unsigned long)sbuf->st_ino, sname));
48 upper_sname = talloc_strdup_upper(talloc_tos(), sname);
49 SMB_ASSERT(upper_sname != NULL);
52 MD5Update(&ctx, (unsigned char *)&(sbuf->st_dev),
53 sizeof(sbuf->st_dev));
54 MD5Update(&ctx, (unsigned char *)&(sbuf->st_ino),
55 sizeof(sbuf->st_ino));
56 MD5Update(&ctx, (unsigned char *)upper_sname,
57 talloc_get_size(upper_sname)-1);
60 TALLOC_FREE(upper_sname);
62 /* Hopefully all the variation is in the lower 4 (or 8) bytes! */
63 memcpy(&result, hash, sizeof(result));
65 DEBUG(10, ("stream_inode returns %lu\n", (unsigned long)result));
70 static ssize_t get_xattr_size(connection_struct *conn,
73 const char *xattr_name)
79 status = get_ea_value(talloc_tos(), conn, fsp, fname,
82 if (!NT_STATUS_IS_OK(status)) {
86 result = ea.value.length-1;
87 TALLOC_FREE(ea.value.data);
91 static bool streams_xattr_recheck(struct stream_io *sio)
96 char *xattr_name = NULL;
98 if (sio->fsp->fsp_name == sio->fsp_name_ptr) {
102 status = split_ntfs_stream_name(talloc_tos(), sio->fsp->fsp_name,
104 if (!NT_STATUS_IS_OK(status)) {
109 /* how can this happen */
114 xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
115 SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
116 if (xattr_name == NULL) {
120 TALLOC_FREE(sio->xattr_name);
121 TALLOC_FREE(sio->base);
122 sio->xattr_name = talloc_strdup(VFS_MEMCTX_FSP_EXTENSION(sio->handle, sio->fsp),
124 sio->base = talloc_strdup(VFS_MEMCTX_FSP_EXTENSION(sio->handle, sio->fsp),
126 sio->fsp_name_ptr = sio->fsp->fsp_name;
128 if ((sio->xattr_name == NULL) || (sio->base == NULL)) {
135 static int streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,
136 SMB_STRUCT_STAT *sbuf)
139 struct stream_io *io = (struct stream_io *)
140 VFS_FETCH_FSP_EXTENSION(handle, fsp);
142 DEBUG(10, ("streams_xattr_fstat called for %d\n", fsp->fh->fd));
144 if (io == NULL || fsp->base_fsp == NULL) {
145 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
148 if (!streams_xattr_recheck(io)) {
152 if (lp_posix_pathnames()) {
153 ret = SMB_VFS_LSTAT(handle->conn, io->base, sbuf);
155 ret = SMB_VFS_STAT(handle->conn, io->base, sbuf);
162 sbuf->st_size = get_xattr_size(handle->conn, fsp->base_fsp,
163 io->base, io->xattr_name);
164 if (sbuf->st_size == -1) {
168 DEBUG(10, ("sbuf->st_size = %d\n", (int)sbuf->st_size));
170 sbuf->st_ino = stream_inode(sbuf, io->xattr_name);
171 sbuf->st_mode &= ~S_IFMT;
172 sbuf->st_mode |= S_IFREG;
173 sbuf->st_blocks = sbuf->st_size % STAT_ST_BLOCKSIZE + 1;
178 static int streams_xattr_stat(vfs_handle_struct *handle, const char *fname,
179 SMB_STRUCT_STAT *sbuf)
182 char *base = NULL, *sname = NULL;
186 if (!is_ntfs_stream_name(fname)) {
187 return SMB_VFS_NEXT_STAT(handle, fname, sbuf);
190 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &sname);
191 if (!NT_STATUS_IS_OK(status)) {
197 return SMB_VFS_NEXT_STAT(handle, base, sbuf);
200 if (SMB_VFS_STAT(handle->conn, base, sbuf) == -1) {
204 xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
205 SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
206 if (xattr_name == NULL) {
211 sbuf->st_size = get_xattr_size(handle->conn, NULL, base, xattr_name);
212 if (sbuf->st_size == -1) {
217 sbuf->st_ino = stream_inode(sbuf, xattr_name);
218 sbuf->st_mode &= ~S_IFMT;
219 sbuf->st_mode |= S_IFREG;
220 sbuf->st_blocks = sbuf->st_size % STAT_ST_BLOCKSIZE + 1;
229 static int streams_xattr_lstat(vfs_handle_struct *handle, const char *fname,
230 SMB_STRUCT_STAT *sbuf)
237 if (!is_ntfs_stream_name(fname)) {
238 return SMB_VFS_NEXT_LSTAT(handle, fname, sbuf);
241 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &sname);
242 if (!NT_STATUS_IS_OK(status)) {
248 return SMB_VFS_NEXT_LSTAT(handle, base, sbuf);
251 if (SMB_VFS_LSTAT(handle->conn, base, sbuf) == -1) {
255 xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
256 SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
257 if (xattr_name == NULL) {
262 sbuf->st_size = get_xattr_size(handle->conn, NULL, base, xattr_name);
263 if (sbuf->st_size == -1) {
268 sbuf->st_ino = stream_inode(sbuf, xattr_name);
269 sbuf->st_mode &= ~S_IFMT;
270 sbuf->st_mode |= S_IFREG;
271 sbuf->st_blocks = sbuf->st_size % STAT_ST_BLOCKSIZE + 1;
280 static int streams_xattr_open(vfs_handle_struct *handle, const char *fname,
281 files_struct *fsp, int flags, mode_t mode)
285 struct stream_io *sio;
292 DEBUG(10, ("streams_xattr_open called for %s\n", fname));
294 if (!is_ntfs_stream_name(fname)) {
295 return SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
298 frame = talloc_stackframe();
300 status = split_ntfs_stream_name(talloc_tos(), fname,
302 if (!NT_STATUS_IS_OK(status)) {
308 hostfd = SMB_VFS_NEXT_OPEN(handle, base, fsp, flags, mode);
313 xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
314 SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
315 if (xattr_name == NULL) {
321 * We use baseflags to turn off nasty side-effects when opening the
325 baseflags &= ~O_TRUNC;
326 baseflags &= ~O_EXCL;
327 baseflags &= ~O_CREAT;
329 hostfd = SMB_VFS_OPEN(handle->conn, base, fsp, baseflags, mode);
331 /* It is legit to open a stream on a directory, but the base
332 * fd has to be read-only.
334 if ((hostfd == -1) && (errno == EISDIR)) {
335 baseflags &= ~O_ACCMODE;
336 baseflags |= O_RDONLY;
337 hostfd = SMB_VFS_OPEN(handle->conn, fname, fsp, baseflags,
345 status = get_ea_value(talloc_tos(), handle->conn, NULL, base,
348 DEBUG(10, ("get_ea_value returned %s\n", nt_errstr(status)));
350 if (!NT_STATUS_IS_OK(status)
351 && !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
353 * The base file is not there. This is an error even if we got
354 * O_CREAT, the higher levels should have created the base
357 DEBUG(10, ("streams_xattr_open: base file %s not around, "
358 "returning ENOENT\n", base));
363 if (!NT_STATUS_IS_OK(status)) {
365 * The attribute does not exist
368 if (flags & O_CREAT) {
370 * Darn, xattrs need at least 1 byte
374 DEBUG(10, ("creating attribute %s on file %s\n",
377 if (fsp->base_fsp->fh->fd != -1) {
378 if (SMB_VFS_FSETXATTR(
379 fsp->base_fsp, xattr_name,
381 flags & O_EXCL ? XATTR_CREATE : 0) == -1) {
385 if (SMB_VFS_SETXATTR(
386 handle->conn, base, xattr_name,
388 flags & O_EXCL ? XATTR_CREATE : 0) == -1) {
395 if (flags & O_TRUNC) {
397 if (fsp->base_fsp->fh->fd != -1) {
398 if (SMB_VFS_FSETXATTR(
399 fsp->base_fsp, xattr_name,
401 flags & O_EXCL ? XATTR_CREATE : 0) == -1) {
405 if (SMB_VFS_SETXATTR(
406 handle->conn, base, xattr_name,
408 flags & O_EXCL ? XATTR_CREATE : 0) == -1) {
414 sio = (struct stream_io *)VFS_ADD_FSP_EXTENSION(handle, fsp,
422 sio->xattr_name = talloc_strdup(VFS_MEMCTX_FSP_EXTENSION(handle, fsp),
424 sio->base = talloc_strdup(VFS_MEMCTX_FSP_EXTENSION(handle, fsp),
426 sio->fsp_name_ptr = fsp->fsp_name;
427 sio->handle = handle;
430 if ((sio->xattr_name == NULL) || (sio->base == NULL)) {
441 * BUGBUGBUG -- we would need to call fd_close_posix here, but
442 * we don't have a full fsp yet
451 static int streams_xattr_unlink(vfs_handle_struct *handle, const char *fname)
459 if (!is_ntfs_stream_name(fname)) {
460 return SMB_VFS_NEXT_UNLINK(handle, fname);
463 status = split_ntfs_stream_name(talloc_tos(), fname, &base, &sname);
464 if (!NT_STATUS_IS_OK(status)) {
470 return SMB_VFS_NEXT_UNLINK(handle, base);
473 xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
474 SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
475 if (xattr_name == NULL) {
480 ret = SMB_VFS_REMOVEXATTR(handle->conn, base, xattr_name);
482 if ((ret == -1) && (errno == ENOATTR)) {
495 static int streams_xattr_rename(vfs_handle_struct *handle,
500 TALLOC_CTX *frame = NULL;
515 o_is_stream = is_ntfs_stream_name(oldname);
516 n_is_stream = is_ntfs_stream_name(newname);
518 if (!o_is_stream && !n_is_stream) {
519 return SMB_VFS_NEXT_RENAME(handle, oldname, newname);
522 frame = talloc_stackframe();
527 status = split_ntfs_stream_name(talloc_tos(), oldname, &obase, &ostream);
528 if (!NT_STATUS_IS_OK(status)) {
533 status = split_ntfs_stream_name(talloc_tos(), newname, &nbase, &nstream);
534 if (!NT_STATUS_IS_OK(status)) {
539 /*TODO: maybe call SMB_VFS_NEXT_RENAME() both streams are NULL (::$DATA) */
540 if (ostream == NULL) {
545 if (nstream == NULL) {
550 if (StrCaseCmp(ostream, nstream) == 0) {
556 oxattr_name = talloc_asprintf(talloc_tos(), "%s%s",
557 SAMBA_XATTR_DOSSTREAM_PREFIX, ostream);
558 if (oxattr_name == NULL) {
563 nxattr_name = talloc_asprintf(talloc_tos(), "%s%s",
564 SAMBA_XATTR_DOSSTREAM_PREFIX, nstream);
565 if (nxattr_name == NULL) {
570 /* read the old stream */
571 status = get_ea_value(talloc_tos(), handle->conn, NULL,
572 base, oxattr_name, &ea);
573 if (!NT_STATUS_IS_OK(status)) {
578 /* (over)write the new stream */
579 nret = SMB_VFS_SETXATTR(handle->conn, base, nxattr_name,
580 ea.value.data, ea.value.length, 0);
582 if (errno == ENOATTR) {
588 /* remove the old stream */
589 oret = SMB_VFS_REMOVEXATTR(handle->conn, base, oxattr_name);
591 if (errno == ENOATTR) {
605 static NTSTATUS walk_xattr_streams(connection_struct *conn, files_struct *fsp,
607 bool (*fn)(struct ea_struct *ea,
614 size_t prefix_len = strlen(SAMBA_XATTR_DOSSTREAM_PREFIX);
616 status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
618 if (!NT_STATUS_IS_OK(status)) {
622 for (i=0; i<num_names; i++) {
625 if (strncmp(names[i], SAMBA_XATTR_DOSSTREAM_PREFIX,
630 status = get_ea_value(names, conn, fsp, fname, names[i], &ea);
631 if (!NT_STATUS_IS_OK(status)) {
632 DEBUG(10, ("Could not get ea %s for file %s: %s\n",
633 names[i], fname, nt_errstr(status)));
637 ea.name = talloc_asprintf(ea.value.data, ":%s",
638 names[i] + prefix_len);
639 if (ea.name == NULL) {
640 DEBUG(0, ("talloc failed\n"));
644 if (!fn(&ea, private_data)) {
645 TALLOC_FREE(ea.value.data);
649 TALLOC_FREE(ea.value.data);
656 static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
657 struct stream_struct **streams,
658 const char *name, SMB_OFF_T size,
659 SMB_OFF_T alloc_size)
661 struct stream_struct *tmp;
663 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, *streams, struct stream_struct,
669 tmp[*num_streams].name = talloc_strdup(tmp, name);
670 if (tmp[*num_streams].name == NULL) {
674 tmp[*num_streams].size = size;
675 tmp[*num_streams].alloc_size = alloc_size;
682 struct streaminfo_state {
684 vfs_handle_struct *handle;
685 unsigned int num_streams;
686 struct stream_struct *streams;
690 static bool collect_one_stream(struct ea_struct *ea, void *private_data)
692 struct streaminfo_state *state =
693 (struct streaminfo_state *)private_data;
695 if (!add_one_stream(state->mem_ctx,
696 &state->num_streams, &state->streams,
697 ea->name, ea->value.length-1,
698 smb_roundup(state->handle->conn,
699 ea->value.length-1))) {
700 state->status = NT_STATUS_NO_MEMORY;
707 static NTSTATUS streams_xattr_streaminfo(vfs_handle_struct *handle,
708 struct files_struct *fsp,
711 unsigned int *pnum_streams,
712 struct stream_struct **pstreams)
714 SMB_STRUCT_STAT sbuf;
717 struct streaminfo_state state;
719 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
720 if (is_ntfs_stream_name(fsp->fsp_name)) {
721 return NT_STATUS_INVALID_PARAMETER;
723 ret = SMB_VFS_FSTAT(fsp, &sbuf);
726 if (is_ntfs_stream_name(fname)) {
727 return NT_STATUS_INVALID_PARAMETER;
729 if (lp_posix_pathnames()) {
730 ret = SMB_VFS_LSTAT(handle->conn, fname, &sbuf);
732 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
737 return map_nt_error_from_unix(errno);
740 state.streams = NULL;
741 state.num_streams = 0;
743 if (!S_ISDIR(sbuf.st_mode)) {
744 if (!add_one_stream(mem_ctx,
745 &state.num_streams, &state.streams,
746 "::$DATA", sbuf.st_size,
747 SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp,
749 return NT_STATUS_NO_MEMORY;
753 state.mem_ctx = mem_ctx;
754 state.handle = handle;
755 state.status = NT_STATUS_OK;
757 status = walk_xattr_streams(handle->conn, fsp, fname,
758 collect_one_stream, &state);
760 if (!NT_STATUS_IS_OK(status)) {
761 TALLOC_FREE(state.streams);
765 if (!NT_STATUS_IS_OK(state.status)) {
766 TALLOC_FREE(state.streams);
770 *pnum_streams = state.num_streams;
771 *pstreams = state.streams;
775 static uint32_t streams_xattr_fs_capabilities(struct vfs_handle_struct *handle)
777 return SMB_VFS_NEXT_FS_CAPABILITIES(handle) | FILE_NAMED_STREAMS;
780 static ssize_t streams_xattr_pwrite(vfs_handle_struct *handle,
781 files_struct *fsp, const void *data,
782 size_t n, SMB_OFF_T offset)
784 struct stream_io *sio =
785 (struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
790 DEBUG(10, ("streams_xattr_pwrite called for %d bytes\n", (int)n));
793 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
796 if (!streams_xattr_recheck(sio)) {
800 status = get_ea_value(talloc_tos(), handle->conn, fsp->base_fsp,
801 sio->base, sio->xattr_name, &ea);
802 if (!NT_STATUS_IS_OK(status)) {
806 if ((offset + n) > ea.value.length-1) {
809 tmp = TALLOC_REALLOC_ARRAY(talloc_tos(), ea.value.data, uint8,
813 TALLOC_FREE(ea.value.data);
818 ea.value.length = offset + n + 1;
819 ea.value.data[offset+n] = 0;
822 memcpy(ea.value.data + offset, data, n);
824 if (fsp->base_fsp->fh->fd != -1) {
825 ret = SMB_VFS_FSETXATTR(fsp->base_fsp,
827 ea.value.data, ea.value.length, 0);
829 ret = SMB_VFS_SETXATTR(fsp->conn, fsp->base_fsp->fsp_name,
831 ea.value.data, ea.value.length, 0);
833 TALLOC_FREE(ea.value.data);
842 static ssize_t streams_xattr_pread(vfs_handle_struct *handle,
843 files_struct *fsp, void *data,
844 size_t n, SMB_OFF_T offset)
846 struct stream_io *sio =
847 (struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
850 size_t length, overlap;
853 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
856 if (!streams_xattr_recheck(sio)) {
860 status = get_ea_value(talloc_tos(), handle->conn, fsp->base_fsp,
861 sio->base, sio->xattr_name, &ea);
862 if (!NT_STATUS_IS_OK(status)) {
866 length = ea.value.length-1;
868 /* Attempt to read past EOF. */
869 if (length <= offset) {
874 overlap = (offset + n) > length ? (length - offset) : n;
875 memcpy(data, ea.value.data + offset, overlap);
877 TALLOC_FREE(ea.value.data);
881 static int streams_xattr_ftruncate(struct vfs_handle_struct *handle,
882 struct files_struct *fsp,
889 struct stream_io *sio =
890 (struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
892 DEBUG(10, ("streams_xattr_ftruncate called for file %s offset %.0f\n",
897 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
900 if (!streams_xattr_recheck(sio)) {
904 status = get_ea_value(talloc_tos(), handle->conn, fsp->base_fsp,
905 sio->base, sio->xattr_name, &ea);
906 if (!NT_STATUS_IS_OK(status)) {
910 tmp = TALLOC_REALLOC_ARRAY(talloc_tos(), ea.value.data, uint8,
914 TALLOC_FREE(ea.value.data);
919 /* Did we expand ? */
920 if (ea.value.length < offset + 1) {
921 memset(&tmp[ea.value.length], '\0',
922 offset + 1 - ea.value.length);
926 ea.value.length = offset + 1;
927 ea.value.data[offset] = 0;
929 if (fsp->base_fsp->fh->fd != -1) {
930 ret = SMB_VFS_FSETXATTR(fsp->base_fsp,
932 ea.value.data, ea.value.length, 0);
934 ret = SMB_VFS_SETXATTR(fsp->conn, fsp->base_fsp->fsp_name,
936 ea.value.data, ea.value.length, 0);
939 TALLOC_FREE(ea.value.data);
948 /* VFS operations structure */
950 static vfs_op_tuple streams_xattr_ops[] = {
951 {SMB_VFS_OP(streams_xattr_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
952 SMB_VFS_LAYER_TRANSPARENT},
953 {SMB_VFS_OP(streams_xattr_open), SMB_VFS_OP_OPEN,
954 SMB_VFS_LAYER_TRANSPARENT},
955 {SMB_VFS_OP(streams_xattr_stat), SMB_VFS_OP_STAT,
956 SMB_VFS_LAYER_TRANSPARENT},
957 {SMB_VFS_OP(streams_xattr_fstat), SMB_VFS_OP_FSTAT,
958 SMB_VFS_LAYER_TRANSPARENT},
959 {SMB_VFS_OP(streams_xattr_lstat), SMB_VFS_OP_LSTAT,
960 SMB_VFS_LAYER_TRANSPARENT},
961 {SMB_VFS_OP(streams_xattr_pread), SMB_VFS_OP_PREAD,
962 SMB_VFS_LAYER_TRANSPARENT},
963 {SMB_VFS_OP(streams_xattr_pwrite), SMB_VFS_OP_PWRITE,
964 SMB_VFS_LAYER_TRANSPARENT},
965 {SMB_VFS_OP(streams_xattr_unlink), SMB_VFS_OP_UNLINK,
966 SMB_VFS_LAYER_TRANSPARENT},
967 {SMB_VFS_OP(streams_xattr_rename), SMB_VFS_OP_RENAME,
968 SMB_VFS_LAYER_TRANSPARENT},
969 {SMB_VFS_OP(streams_xattr_ftruncate), SMB_VFS_OP_FTRUNCATE,
970 SMB_VFS_LAYER_TRANSPARENT},
971 {SMB_VFS_OP(streams_xattr_streaminfo), SMB_VFS_OP_STREAMINFO,
972 SMB_VFS_LAYER_OPAQUE},
973 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
976 NTSTATUS vfs_streams_xattr_init(void);
977 NTSTATUS vfs_streams_xattr_init(void)
979 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "streams_xattr",