usr/src/uts/common/fs/smbclnt/smbfs/smbfs_xattr.c

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