kernel/fs/pathname.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  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  27 /*        All Rights Reserved   */
  28
  29 /*
  30  * University Copyright- Copyright (c) 1982, 1986, 1988
  31  * The Regents of the University of California
  32  * All Rights Reserved
  33  *
  34  * University Acknowledgment- Portions of this document are derived from
  35  * software developed by the University of California, Berkeley, and its
  36  * contributors.
  37  */
  38
  39
  40 #include <sys/types.h>
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/uio.h>
  44 #include <sys/errno.h>
  45 #include <sys/pathname.h>
  46 #include <sys/kmem.h>
  47 #include <sys/cred.h>
  48 #include <sys/vnode.h>
  49 #include <sys/debug.h>
  50
  51 /*
  52  * Pathname utilities.
  53  *
  54  * In translating file names we copy each argument file
  55  * name into a pathname structure where we operate on it.
  56  * Each pathname structure can hold "pn_bufsize" characters
  57  * including a terminating null, and operations here support
  58  * allocating and freeing pathname structures, fetching
  59  * strings from user space, getting the next character from
  60  * a pathname, combining two pathnames (used in symbolic
  61  * link processing), and peeling off the first component
  62  * of a pathname.
  63  */
  64
  65 /*
  66  * Allocate contents of pathname structure.  Structure is typically
  67  * an automatic variable in calling routine for convenience.
  68  *
  69  * May sleep in the call to kmem_alloc() and so must not be called
  70  * from interrupt level.
  71  */
  72 void
  73 pn_alloc(struct pathname *pnp)
  74 {
  75         pn_alloc_sz(pnp, MAXPATHLEN);
  76 }
  77 void
  78 pn_alloc_sz(struct pathname *pnp, size_t sz)
  79 {
  80         pnp->pn_path = pnp->pn_buf = kmem_alloc(sz, KM_SLEEP);
  81         pnp->pn_pathlen = 0;
  82         pnp->pn_bufsize = sz;
  83 }
  84
  85 /*
  86  * Free pathname resources.
  87  */
  88 void
  89 pn_free(struct pathname *pnp)
  90 {
  91         /* pn_bufsize is usually MAXPATHLEN, but may not be */
  92         kmem_free(pnp->pn_buf, pnp->pn_bufsize);
  93         pnp->pn_path = pnp->pn_buf = NULL;
  94         pnp->pn_pathlen = pnp->pn_bufsize = 0;
  95 }
  96
  97 /*
  98  * Pull a path name from user or kernel space.
  99  * Called from pn_get() after allocation of a MAXPATHLEN buffer.
 100  * Also called directly with a TYPICALMAXPATHLEN-size buffer
 101  * on the stack as a local optimization.
 102  */
 103 int
 104 pn_get_buf(char *str, enum uio_seg seg, struct pathname *pnp,
 105         void *buf, size_t bufsize)
 106 {
 107         int error;
 108
 109         pnp->pn_path = pnp->pn_buf = buf;
 110         pnp->pn_bufsize = bufsize;
 111         if (seg == UIO_USERSPACE)
 112                 error = copyinstr(str, pnp->pn_path, bufsize, &pnp->pn_pathlen);
 113         else
 114                 error = copystr(str, pnp->pn_path, bufsize, &pnp->pn_pathlen);
 115         if (error)
 116                 return (error);
 117         pnp->pn_pathlen--;              /* don't count null byte */
 118         return (0);
 119 }
 120
 121 /*
 122  * Pull a path name from user or kernel space.
 123  */
 124 int
 125 pn_get(char *str, enum uio_seg seg, struct pathname *pnp)
 126 {
 127         int error;
 128         void *buf;
 129
 130         buf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
 131         if ((error = pn_get_buf(str, seg, pnp, buf, MAXPATHLEN)) != 0)
 132                 pn_free(pnp);
 133         return (error);
 134 }
 135
 136 /*
 137  * Set path name to argument string.  Storage has already been allocated
 138  * and pn_buf points to it.
 139  *
 140  * On error, all fields except pn_buf will be undefined.
 141  */
 142 int
 143 pn_set(struct pathname *pnp, char *path)
 144 {
 145         int error;
 146
 147         pnp->pn_path = pnp->pn_buf;
 148         error = copystr(path, pnp->pn_path, pnp->pn_bufsize, &pnp->pn_pathlen);
 149         pnp->pn_pathlen--;              /* don't count null byte */
 150         return (error);
 151 }
 152
 153 /*
 154  * Combine two argument path names by putting the second argument
 155  * before the first in the first's buffer.  This isn't very general;
 156  * it is designed specifically for symbolic link processing.
 157  * This function copies the symlink in-place in the pathname.  This is to
 158  * ensure that vnode path caching remains correct.  At the point where this is
 159  * called (from lookuppnvp), we have called pn_getcomponent(), found it is a
 160  * symlink, and are now replacing the contents.  The complen parameter indicates
 161  * how much of the pathname to replace.  If the symlink is an absolute path,
 162  * then we overwrite the entire contents of the pathname.
 163  */
 164 int
 165 pn_insert(struct pathname *pnp, struct pathname *sympnp, size_t complen)
 166 {
 167
 168         if (*sympnp->pn_path == '/') {
 169                 /*
 170                  * Full path, replace everything
 171                  */
 172                 if (pnp->pn_pathlen + sympnp->pn_pathlen >= pnp->pn_bufsize)
 173                         return (ENAMETOOLONG);
 174                 if (pnp->pn_pathlen != 0)
 175                         ovbcopy(pnp->pn_path, pnp->pn_buf + sympnp->pn_pathlen,
 176                             pnp->pn_pathlen);
 177                 bcopy(sympnp->pn_path, pnp->pn_buf, sympnp->pn_pathlen);
 178                 pnp->pn_pathlen += sympnp->pn_pathlen;
 179                 pnp->pn_buf[pnp->pn_pathlen] = '\0';
 180                 pnp->pn_path = pnp->pn_buf;
 181         } else {
 182                 /*
 183                  * Partial path, replace only last component
 184                  */
 185                 if ((pnp->pn_path - pnp->pn_buf) - complen +
 186                     pnp->pn_pathlen + sympnp->pn_pathlen >= pnp->pn_bufsize)
 187                         return (ENAMETOOLONG);
 188
 189                 if (pnp->pn_pathlen != 0)
 190                         ovbcopy(pnp->pn_path, pnp->pn_path - complen +
 191                             sympnp->pn_pathlen, pnp->pn_pathlen + 1);
 192                 pnp->pn_path -= complen;
 193                 bcopy(sympnp->pn_path, pnp->pn_path, sympnp->pn_pathlen);
 194                 pnp->pn_pathlen += sympnp->pn_pathlen;
 195         }
 196
 197         return (0);
 198 }
 199
 200 int
 201 pn_getsymlink(vnode_t *vp, struct pathname *pnp, cred_t *crp)
 202 {
 203         struct iovec aiov;
 204         struct uio auio;
 205         int error;
 206
 207         aiov.iov_base = pnp->pn_path = pnp->pn_buf;
 208         aiov.iov_len = pnp->pn_bufsize;
 209         auio.uio_iov = &aiov;
 210         auio.uio_iovcnt = 1;
 211         auio.uio_loffset = 0;
 212         auio.uio_segflg = UIO_SYSSPACE;
 213         auio.uio_extflg = UIO_COPY_CACHED;
 214         auio.uio_resid = pnp->pn_bufsize;
 215         if ((error = fop_readlink(vp, &auio, crp, NULL)) == 0) {
 216                 pnp->pn_pathlen = pnp->pn_bufsize - auio.uio_resid;
 217                 if (pnp->pn_pathlen == pnp->pn_bufsize)
 218                         error = ENAMETOOLONG;
 219                 else
 220                         pnp->pn_path[pnp->pn_pathlen] = '\0';
 221         }
 222         return (error);
 223 }
 224
 225 /*
 226  * Get next component from a path name and leave in
 227  * buffer "component" which should have room for
 228  * MAXNAMELEN bytes (including a null terminator character).
 229  */
 230 int
 231 pn_getcomponent(struct pathname *pnp, char *component)
 232 {
 233         char c, *cp, *path, saved;
 234         size_t pathlen;
 235
 236         path = pnp->pn_path;
 237         pathlen = pnp->pn_pathlen;
 238         if (pathlen >= MAXNAMELEN) {
 239                 saved = path[MAXNAMELEN];
 240                 path[MAXNAMELEN] = '/'; /* guarantees loop termination */
 241                 for (cp = path; (c = *cp) != '/'; cp++)
 242                         *component++ = c;
 243                 path[MAXNAMELEN] = saved;
 244                 if (cp - path == MAXNAMELEN)
 245                         return (ENAMETOOLONG);
 246         } else {
 247                 path[pathlen] = '/';    /* guarantees loop termination */
 248                 for (cp = path; (c = *cp) != '/'; cp++)
 249                         *component++ = c;
 250                 path[pathlen] = '\0';
 251         }
 252
 253         pnp->pn_path = cp;
 254         pnp->pn_pathlen = pathlen - (cp - path);
 255         *component = '\0';
 256         return (0);
 257 }
 258
 259 /*
 260  * Skip over consecutive slashes in the path name.
 261  */
 262 void
 263 pn_skipslash(struct pathname *pnp)
 264 {
 265         while (pnp->pn_pathlen > 0 && *pnp->pn_path == '/') {
 266                 pnp->pn_path++;
 267                 pnp->pn_pathlen--;
 268         }
 269 }
 270
 271 /*
 272  * Sets pn_path to the last component in the pathname, updating
 273  * pn_pathlen.  If pathname is empty, or degenerate, leaves pn_path
 274  * pointing at NULL char.  The pathname is explicitly null-terminated
 275  * so that any trailing slashes are effectively removed.
 276  */
 277 void
 278 pn_setlast(struct pathname *pnp)
 279 {
 280         char *buf = pnp->pn_buf;
 281         char *path = pnp->pn_path + pnp->pn_pathlen - 1;
 282         char *endpath;
 283
 284         while (path > buf && *path == '/')
 285                 --path;
 286         endpath = path + 1;
 287         while (path > buf && *path != '/')
 288                 --path;
 289         if (*path == '/')
 290                 path++;
 291         *endpath = '\0';
 292         pnp->pn_path = path;
 293         pnp->pn_pathlen = endpath - path;
 294 }
 295
 296 /*
 297  * Eliminate any trailing slashes in the pathname.
 298  * Return non-zero iff there were any trailing slashes.
 299  */
 300 int
 301 pn_fixslash(struct pathname *pnp)
 302 {
 303         char *start = pnp->pn_path;
 304         char *end = start + pnp->pn_pathlen;
 305
 306         while (end > start && *(end - 1) == '/')
 307                 end--;
 308         if (pnp->pn_pathlen == end - start)
 309                 return (0);
 310         *end = '\0';
 311         pnp->pn_pathlen = end - start;
 312         return (1);
 313 }
 314
 315 /*
 316  * Add a slash to the end of the pathname, if it will fit.
 317  * Return ENAMETOOLONG if it won't.
 318  */
 319 int
 320 pn_addslash(struct pathname *pnp)
 321 {
 322         if (pnp->pn_path + pnp->pn_pathlen + 1 >=
 323             pnp->pn_buf + pnp->pn_bufsize) {
 324                 if (pnp->pn_pathlen + 1 >= pnp->pn_bufsize)     /* no room */
 325                         return (ENAMETOOLONG);
 326                 /*
 327                  * Move the component to the start of the buffer
 328                  * so we have room to add the trailing slash.
 329                  */
 330                 ovbcopy(pnp->pn_path, pnp->pn_buf, pnp->pn_pathlen);
 331                 pnp->pn_path = pnp->pn_buf;
 332         }
 333         pnp->pn_path[pnp->pn_pathlen++] = '/';
 334         pnp->pn_path[pnp->pn_pathlen] = '\0';
 335         return (0);
 336 }