xref: /illumos-gate/usr/src/uts/common/fs/smbclnt/smbfs/smbfs_xattr.c (revision aedf2b3bb56b025fcaf87b49ec6c8aeea07f16d7) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Functions supporting Solaris Extended Attributes,
29  * used to provide access to CIFS "named streams".
30  */
31 
32 #include <sys/systm.h>
33 #include <sys/cred.h>
34 #include <sys/vnode.h>
35 #include <sys/vfs.h>
36 #include <sys/filio.h>
37 #include <sys/uio.h>
38 #include <sys/dirent.h>
39 #include <sys/errno.h>
40 #include <sys/sysmacros.h>
41 #include <sys/kmem.h>
42 #include <sys/stat.h>
43 #include <sys/cmn_err.h>
44 #include <sys/dnlc.h>
45 #include <sys/u8_textprep.h>
46 
47 #include <netsmb/smb_osdep.h>
48 #include <netsmb/smb.h>
49 #include <netsmb/smb_conn.h>
50 #include <netsmb/smb_subr.h>
51 #include <netsmb/smb_rq.h>
52 
53 #include <smbfs/smbfs.h>
54 #include <smbfs/smbfs_node.h>
55 #include <smbfs/smbfs_subr.h>
56 
57 #include <fs/fs_subr.h>
58 
59 /*
60  * Solaris wants there to be a directory node to contain
61  * all the extended attributes.  The SMB protocol does not
62  * really support a directory here, and uses very different
63  * operations to list attributes, etc. so we "fake up" an
64  * smbnode here to represent the attributes directory.
65  *
66  * We need to give this (fake) directory a unique identity,
67  * and since we're using the full remote pathname as the
68  * unique identity of all nodes, the easiest thing to do
69  * here is append a colon (:) to the given pathname.
70  *
71  * There are several places where smbfs_fullpath and its
72  * callers must decide what separator to use when building
73  * a remote path name, and the rule is now as follows:
74  * 1: When no XATTR involved, use "\\" as the separator.
75  * 2: Traversal into the (fake) XATTR dir adds one ":"
76  * 3: Children of the XATTR dir add nothing (sep=0)
77  * The result should be _one_ colon before the attr name.
78  */
79 
80 /* ARGSUSED */
81 int
82 smbfs_get_xattrdir(vnode_t *pvp, vnode_t **vpp, cred_t *cr, int flags)
83 {
84 	vnode_t *xvp;
85 	smbnode_t *pnp, *xnp;
86 
87 	pnp = VTOSMB(pvp);
88 
89 	xvp = smbfs_make_node(pvp->v_vfsp,
90 	    pnp->n_rpath, pnp->n_rplen,
91 	    NULL, 0, ':', NULL);
92 	ASSERT(xvp);
93 	/* Note: xvp has a VN_HOLD, which our caller expects. */
94 	xnp = VTOSMB(xvp);
95 
96 	/* If it's a new node, initialize. */
97 	if (xvp->v_type == VNON) {
98 
99 		mutex_enter(&xvp->v_lock);
100 		xvp->v_type = VDIR;
101 		xvp->v_flag |= V_XATTRDIR;
102 		mutex_exit(&xvp->v_lock);
103 
104 		mutex_enter(&xnp->r_statelock);
105 		xnp->n_flag |= N_XATTR;
106 		mutex_exit(&xnp->r_statelock);
107 	}
108 
109 	/* Success! */
110 	*vpp = xvp;
111 	return (0);
112 }
113 
114 /*
115  * Find the parent of an XATTR directory or file,
116  * by trimming off the ":attrname" part of rpath.
117  * Called on XATTR files to get the XATTR dir, and
118  * called on the XATTR dir to get the real object
119  * under which the (faked up) XATTR dir lives.
120  */
121 int
122 smbfs_xa_parent(vnode_t *vp, vnode_t **vpp)
123 {
124 	smbnode_t *np = VTOSMB(vp);
125 	vnode_t *pvp;
126 	int rplen;
127 
128 	if ((np->n_flag & N_XATTR) == 0)
129 		return (EINVAL);
130 
131 	if (vp->v_flag & V_XATTRDIR) {
132 		/*
133 		 * Want the parent of the XATTR directory.
134 		 * That's easy: just remove trailing ":"
135 		 */
136 		rplen = np->n_rplen - 1;
137 		if (rplen < 1) {
138 			SMBVDEBUG("rplen < 1?");
139 			return (ENOENT);
140 		}
141 		if (np->n_rpath[rplen] != ':') {
142 			SMBVDEBUG("last is not colon");
143 			return (ENOENT);
144 		}
145 	} else {
146 		/*
147 		 * Want the XATTR directory given
148 		 * one of its XATTR files (children).
149 		 * Find the ":" and trim after it.
150 		 */
151 		for (rplen = 1; rplen < np->n_rplen; rplen++)
152 			if (np->n_rpath[rplen] == ':')
153 				break;
154 		/* Should have found ":stream_name" */
155 		if (rplen >= np->n_rplen) {
156 			SMBVDEBUG("colon not found");
157 			return (ENOENT);
158 		}
159 		rplen++; /* keep the ":" */
160 		if (rplen >= np->n_rplen) {
161 			SMBVDEBUG("no stream name");
162 			return (ENOENT);
163 		}
164 	}
165 
166 	pvp = smbfs_make_node(vp->v_vfsp,
167 	    np->n_rpath, rplen,
168 	    NULL, 0, 0, NULL);
169 	ASSERT(pvp);
170 
171 	/* Note: pvp has a VN_HOLD from _make_node */
172 	*vpp = pvp;
173 	return (0);
174 }
175 
176 /*
177  * This is called by smbfs_pathconf to find out
178  * if some file has any extended attributes.
179  * There's no short-cut way to find out, so we
180  * just list the attributes the usual way and
181  * check for an empty result.
182  *
183  * Returns 1: (exists) or 0: (none found)
184  */
185 int
186 smbfs_xa_exists(vnode_t *vp, cred_t *cr)
187 {
188 	smbnode_t *xnp;
189 	vnode_t *xvp;
190 	struct smb_cred scred;
191 	struct smbfs_fctx ctx;
192 	int error, rc = 0;
193 
194 	/* Get the xattr dir */
195 	error = smbfs_get_xattrdir(vp, &xvp, cr, LOOKUP_XATTR);
196 	if (error)
197 		return (0);
198 	/* NB: have VN_HOLD on xpv */
199 	xnp = VTOSMB(xvp);
200 
201 	smb_credinit(&scred, cr);
202 
203 	bzero(&ctx, sizeof (ctx));
204 	ctx.f_flags = SMBFS_RDD_FINDFIRST;
205 	ctx.f_dnp = xnp;
206 	ctx.f_scred = &scred;
207 	ctx.f_ssp = xnp->n_mount->smi_share;
208 
209 	error = smbfs_xa_findopen(&ctx, xnp, "*", 1);
210 	if (error)
211 		goto out;
212 
213 	error = smbfs_xa_findnext(&ctx, 1);
214 	if (error)
215 		goto out;
216 
217 	/* Have at least one named stream. */
218 	SMBVDEBUG("ctx.f_name: %s\n", ctx.f_name);
219 	rc = 1;
220 
221 out:
222 	/* NB: Always call findclose, error or not. */
223 	(void) smbfs_xa_findclose(&ctx);
224 	smb_credrele(&scred);
225 	VN_RELE(xvp);
226 	return (rc);
227 }
228 
229 
230 /*
231  * This is called to get attributes (size, etc.) of either
232  * the "faked up" XATTR directory or a named stream.
233  */
234 int
235 smbfs_xa_getfattr(struct smbnode *xnp, struct smbfattr *fap,
236 	struct smb_cred *scrp)
237 {
238 	vnode_t *xvp;	/* xattr */
239 	vnode_t *pvp;	/* parent */
240 	smbnode_t *pnp;	/* parent */
241 	int error, nlen;
242 	const char *name, *sname;
243 
244 	xvp = SMBTOV(xnp);
245 
246 	/*
247 	 * Simulate smbfs_smb_getfattr() for a named stream.
248 	 * OK to leave a,c,m times zero (expected w/ XATTR).
249 	 * The XATTR directory is easy (all fake).
250 	 */
251 	if (xvp->v_flag & V_XATTRDIR) {
252 		fap->fa_attr = SMB_FA_DIR;
253 		fap->fa_size = DEV_BSIZE;
254 		return (0);
255 	}
256 
257 	/*
258 	 * Do a lookup in the XATTR directory,
259 	 * using the stream name (last part)
260 	 * from the xattr node.
261 	 */
262 	error = smbfs_xa_parent(xvp, &pvp);
263 	if (error)
264 		return (error);
265 	/* Note: pvp has a VN_HOLD */
266 	pnp = VTOSMB(pvp);
267 
268 	/* Get stream name (ptr and length) */
269 	ASSERT(xnp->n_rplen > pnp->n_rplen);
270 	nlen = xnp->n_rplen - pnp->n_rplen;
271 	name = xnp->n_rpath + pnp->n_rplen;
272 	sname = name;
273 
274 	/* Note: this can allocate a new "name" */
275 	error = smbfs_smb_lookup(pnp, &name, &nlen, fap, scrp);
276 	if (error == 0 && name != sname)
277 		smbfs_name_free(name, nlen);
278 
279 	VN_RELE(pvp);
280 
281 	return (error);
282 }
283 
284 /*
285  * Fetch the entire attribute list here in findopen.
286  * Will parse the results in findnext.
287  *
288  * This is called on the XATTR directory, so we
289  * have to get the (real) parent object first.
290  */
291 /* ARGSUSED */
292 int
293 smbfs_xa_findopen(struct smbfs_fctx *ctx, struct smbnode *dnp,
294 	const char *wildcard, int wclen)
295 {
296 	vnode_t *pvp;	/* parent */
297 	smbnode_t *pnp;
298 	struct smb_t2rq *t2p;
299 	struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
300 	struct mbchain *mbp;
301 	int error;
302 
303 	ASSERT(dnp->n_flag & N_XATTR);
304 
305 	ctx->f_type = ft_XA;
306 	ctx->f_namesz = SMB_MAXFNAMELEN + 1;
307 	if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp)))
308 		ctx->f_namesz *= 2;
309 	ctx->f_name = kmem_alloc(ctx->f_namesz, KM_SLEEP);
310 
311 	error = smbfs_xa_parent(SMBTOV(dnp), &pvp);
312 	if (error)
313 		return (error);
314 	ASSERT(pvp);
315 	/* Note: pvp has a VN_HOLD */
316 	pnp = VTOSMB(pvp);
317 
318 	if (ctx->f_t2) {
319 		smb_t2_done(ctx->f_t2);
320 		ctx->f_t2 = NULL;
321 	}
322 
323 	error = smb_t2_alloc(SSTOCP(ctx->f_ssp),
324 	    SMB_TRANS2_QUERY_PATH_INFORMATION,
325 	    ctx->f_scred, &t2p);
326 	if (error)
327 		goto out;
328 	ctx->f_t2 = t2p;
329 
330 	mbp = &t2p->t2_tparam;
331 	mb_init(mbp);
332 	mb_put_uint16le(mbp, SMB_QFILEINFO_STREAM_INFO);
333 	mb_put_uint32le(mbp, 0);
334 	error = smbfs_fullpath(mbp, vcp, pnp, NULL, NULL, 0);
335 	if (error)
336 		goto out;
337 	t2p->t2_maxpcount = 2;
338 	t2p->t2_maxdcount = INT16_MAX;
339 	error = smb_t2_request(t2p);
340 	if (error) {
341 		if (smb_t2_err(t2p) == NT_STATUS_INVALID_PARAMETER)
342 			error = ENOTSUP;
343 	}
344 	/*
345 	 * No returned parameters to parse.
346 	 * Returned data are in t2_rdata,
347 	 * which we'll parse in _findnext.
348 	 * However, save the wildcard.
349 	 */
350 	ctx->f_wildcard = wildcard;
351 	ctx->f_wclen = wclen;
352 
353 out:
354 	VN_RELE(pvp);
355 	return (error);
356 }
357 
358 /*
359  * Get the next name in an XATTR directory into f_name
360  */
361 /* ARGSUSED */
362 int
363 smbfs_xa_findnext(struct smbfs_fctx *ctx, uint16_t limit)
364 {
365 	struct mdchain *mdp;
366 	struct smb_t2rq *t2p;
367 	uint32_t size, next;
368 	uint64_t llongint;
369 	int error, skip, used, nmlen;
370 
371 	t2p = ctx->f_t2;
372 	mdp = &t2p->t2_rdata;
373 
374 	if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
375 		ASSERT(ctx->f_wildcard);
376 		SMBVDEBUG("wildcard: %s\n", ctx->f_wildcard);
377 	}
378 
379 again:
380 	if (ctx->f_flags & SMBFS_RDD_EOF)
381 		return (ENOENT);
382 
383 	/* Parse FILE_STREAM_INFORMATION */
384 	if ((error = md_get_uint32le(mdp, &next)) != 0)	/* offset to */
385 		return (ENOENT);
386 	if ((error = md_get_uint32le(mdp, &size)) != 0) /* name len */
387 		return (ENOENT);
388 	md_get_uint64le(mdp, &llongint); /* file size */
389 	ctx->f_attr.fa_size = llongint;
390 	md_get_uint64le(mdp, NULL);	/* alloc. size */
391 	used = 4 + 4 + 8 + 8;	/* how much we consumed */
392 
393 	/*
394 	 * Copy the string, but skip the first char (":")
395 	 * Watch out for zero-length strings here.
396 	 */
397 	if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) {
398 		if (size >= 2) {
399 			size -= 2; used += 2;
400 			md_get_uint16le(mdp, NULL);
401 		}
402 		nmlen = min(size, SMB_MAXFNAMELEN * 2);
403 	} else {
404 		if (size >= 1) {
405 			size -= 1; used += 1;
406 			md_get_uint8(mdp, NULL);
407 		}
408 		nmlen = min(size, SMB_MAXFNAMELEN);
409 	}
410 
411 	ASSERT(nmlen < ctx->f_namesz);
412 	ctx->f_nmlen = nmlen;
413 	error = md_get_mem(mdp, ctx->f_name, nmlen, MB_MSYSTEM);
414 	if (error)
415 		return (error);
416 	used += nmlen;
417 
418 	/*
419 	 * Convert UCS-2 to UTF-8
420 	 */
421 	smbfs_fname_tolocal(ctx);
422 	if (nmlen)
423 		SMBVDEBUG("name: %s\n", ctx->f_name);
424 	else
425 		SMBVDEBUG("null name!\n");
426 
427 	/*
428 	 * Skip padding until next offset
429 	 */
430 	if (next > used) {
431 		skip = next - used;
432 		md_get_mem(mdp, NULL, skip, MB_MSYSTEM);
433 	}
434 	if (next == 0)
435 		ctx->f_flags |= SMBFS_RDD_EOF;
436 
437 	/*
438 	 * Chop off the trailing ":$DATA"
439 	 * The 6 here is strlen(":$DATA")
440 	 */
441 	if (ctx->f_nmlen >= 6) {
442 		char *p = ctx->f_name + ctx->f_nmlen - 6;
443 		if (strncmp(p, ":$DATA", 6) == 0) {
444 			*p = '\0'; /* Chop! */
445 			ctx->f_nmlen -= 6;
446 		}
447 	}
448 
449 	/*
450 	 * The Chop above will typically leave
451 	 * an empty name in the first slot,
452 	 * which we will skip here.
453 	 */
454 	if (ctx->f_nmlen == 0)
455 		goto again;
456 
457 	/*
458 	 * If this is a lookup of a specific name,
459 	 * skip past any non-matching names.
460 	 */
461 	if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
462 		if (ctx->f_wclen != ctx->f_nmlen)
463 			goto again;
464 		if (u8_strcmp(ctx->f_wildcard, ctx->f_name,
465 		    ctx->f_nmlen, U8_STRCMP_CI_LOWER,
466 		    U8_UNICODE_LATEST, &error) || error)
467 			goto again;
468 	}
469 
470 	return (0);
471 }
472 
473 /*
474  * Find first/next/close for XATTR directories.
475  * NB: also used by smbfs_smb_lookup
476  */
477 
478 int
479 smbfs_xa_findclose(struct smbfs_fctx *ctx)
480 {
481 
482 	if (ctx->f_name)
483 		kmem_free(ctx->f_name, ctx->f_namesz);
484 	if (ctx->f_t2)
485 		smb_t2_done(ctx->f_t2);
486 
487 	return (0);
488 }
489