vfs_lookup.c revision 1.165 1 /* $NetBSD: vfs_lookup.c,v 1.165 2011/04/11 02:18:07 dholland Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1986, 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)vfs_lookup.c 8.10 (Berkeley) 5/27/95
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.165 2011/04/11 02:18:07 dholland Exp $");
41
42 #include "opt_magiclinks.h"
43
44 #include <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/kernel.h>
47 #include <sys/syslimits.h>
48 #include <sys/time.h>
49 #include <sys/namei.h>
50 #include <sys/vnode.h>
51 #include <sys/mount.h>
52 #include <sys/errno.h>
53 #include <sys/filedesc.h>
54 #include <sys/hash.h>
55 #include <sys/proc.h>
56 #include <sys/syslog.h>
57 #include <sys/kauth.h>
58 #include <sys/ktrace.h>
59
60 #ifndef MAGICLINKS
61 #define MAGICLINKS 0
62 #endif
63
64 int vfs_magiclinks = MAGICLINKS;
65
66 /*
67 * Substitute replacement text for 'magic' strings in symlinks.
68 * Returns 0 if successful, and returns non-zero if an error
69 * occurs. (Currently, the only possible error is running out
70 * of temporary pathname space.)
71 *
72 * Looks for "@<string>" and "@<string>/", where <string> is a
73 * recognized 'magic' string. Replaces the "@<string>" with the
74 * appropriate replacement text. (Note that in some cases the
75 * replacement text may have zero length.)
76 *
77 * This would have been table driven, but the variance in
78 * replacement strings (and replacement string lengths) made
79 * that impractical.
80 */
81 #define VNL(x) \
82 (sizeof(x) - 1)
83
84 #define VO '{'
85 #define VC '}'
86
87 #define MATCH(str) \
88 ((termchar == '/' && i + VNL(str) == *len) || \
89 (i + VNL(str) < *len && \
90 cp[i + VNL(str)] == termchar)) && \
91 !strncmp((str), &cp[i], VNL(str))
92
93 #define SUBSTITUTE(m, s, sl) \
94 if ((newlen + (sl)) >= MAXPATHLEN) \
95 return 1; \
96 i += VNL(m); \
97 if (termchar != '/') \
98 i++; \
99 (void)memcpy(&tmp[newlen], (s), (sl)); \
100 newlen += (sl); \
101 change = 1; \
102 termchar = '/';
103
104 static int
105 symlink_magic(struct proc *p, char *cp, size_t *len)
106 {
107 char *tmp;
108 size_t change, i, newlen, slen;
109 char termchar = '/';
110 char idtmp[11]; /* enough for 32 bit *unsigned* integer */
111
112
113 tmp = PNBUF_GET();
114 for (change = i = newlen = 0; i < *len; ) {
115 if (cp[i] != '@') {
116 tmp[newlen++] = cp[i++];
117 continue;
118 }
119
120 i++;
121
122 /* Check for @{var} syntax. */
123 if (cp[i] == VO) {
124 termchar = VC;
125 i++;
126 }
127
128 /*
129 * The following checks should be ordered according
130 * to frequency of use.
131 */
132 if (MATCH("machine_arch")) {
133 slen = VNL(MACHINE_ARCH);
134 SUBSTITUTE("machine_arch", MACHINE_ARCH, slen);
135 } else if (MATCH("machine")) {
136 slen = VNL(MACHINE);
137 SUBSTITUTE("machine", MACHINE, slen);
138 } else if (MATCH("hostname")) {
139 SUBSTITUTE("hostname", hostname, hostnamelen);
140 } else if (MATCH("osrelease")) {
141 slen = strlen(osrelease);
142 SUBSTITUTE("osrelease", osrelease, slen);
143 } else if (MATCH("emul")) {
144 slen = strlen(p->p_emul->e_name);
145 SUBSTITUTE("emul", p->p_emul->e_name, slen);
146 } else if (MATCH("kernel_ident")) {
147 slen = strlen(kernel_ident);
148 SUBSTITUTE("kernel_ident", kernel_ident, slen);
149 } else if (MATCH("domainname")) {
150 SUBSTITUTE("domainname", domainname, domainnamelen);
151 } else if (MATCH("ostype")) {
152 slen = strlen(ostype);
153 SUBSTITUTE("ostype", ostype, slen);
154 } else if (MATCH("uid")) {
155 slen = snprintf(idtmp, sizeof(idtmp), "%u",
156 kauth_cred_geteuid(kauth_cred_get()));
157 SUBSTITUTE("uid", idtmp, slen);
158 } else if (MATCH("ruid")) {
159 slen = snprintf(idtmp, sizeof(idtmp), "%u",
160 kauth_cred_getuid(kauth_cred_get()));
161 SUBSTITUTE("ruid", idtmp, slen);
162 } else if (MATCH("gid")) {
163 slen = snprintf(idtmp, sizeof(idtmp), "%u",
164 kauth_cred_getegid(kauth_cred_get()));
165 SUBSTITUTE("gid", idtmp, slen);
166 } else if (MATCH("rgid")) {
167 slen = snprintf(idtmp, sizeof(idtmp), "%u",
168 kauth_cred_getgid(kauth_cred_get()));
169 SUBSTITUTE("rgid", idtmp, slen);
170 } else {
171 tmp[newlen++] = '@';
172 if (termchar == VC)
173 tmp[newlen++] = VO;
174 }
175 }
176
177 if (change) {
178 (void)memcpy(cp, tmp, newlen);
179 *len = newlen;
180 }
181 PNBUF_PUT(tmp);
182
183 return 0;
184 }
185
186 #undef VNL
187 #undef VO
188 #undef VC
189 #undef MATCH
190 #undef SUBSTITUTE
191
192 ////////////////////////////////////////////////////////////
193
194 /*
195 * Determine the namei hash (for cn_hash) for name.
196 * If *ep != NULL, hash from name to ep-1.
197 * If *ep == NULL, hash from name until the first NUL or '/', and
198 * return the location of this termination character in *ep.
199 *
200 * This function returns an equivalent hash to the MI hash32_strn().
201 * The latter isn't used because in the *ep == NULL case, determining
202 * the length of the string to the first NUL or `/' and then calling
203 * hash32_strn() involves unnecessary double-handling of the data.
204 */
205 uint32_t
206 namei_hash(const char *name, const char **ep)
207 {
208 uint32_t hash;
209
210 hash = HASH32_STR_INIT;
211 if (*ep != NULL) {
212 for (; name < *ep; name++)
213 hash = hash * 33 + *(const uint8_t *)name;
214 } else {
215 for (; *name != '\0' && *name != '/'; name++)
216 hash = hash * 33 + *(const uint8_t *)name;
217 *ep = name;
218 }
219 return (hash + (hash >> 5));
220 }
221
222 ////////////////////////////////////////////////////////////
223
224 /*
225 * Sealed abstraction for pathnames.
226 *
227 * System-call-layer level code that is going to call namei should
228 * first create a pathbuf and adjust all the bells and whistles on it
229 * as needed by context
230 */
231
232 struct pathbuf {
233 char *pb_path;
234 char *pb_pathcopy;
235 unsigned pb_pathcopyuses;
236 };
237
238 static struct pathbuf *
239 pathbuf_create_raw(void)
240 {
241 struct pathbuf *pb;
242
243 pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
244 if (pb == NULL) {
245 return NULL;
246 }
247 pb->pb_path = PNBUF_GET();
248 if (pb->pb_path == NULL) {
249 kmem_free(pb, sizeof(*pb));
250 return NULL;
251 }
252 pb->pb_pathcopy = NULL;
253 pb->pb_pathcopyuses = 0;
254 return pb;
255 }
256
257 void
258 pathbuf_destroy(struct pathbuf *pb)
259 {
260 KASSERT(pb->pb_pathcopyuses == 0);
261 KASSERT(pb->pb_pathcopy == NULL);
262 PNBUF_PUT(pb->pb_path);
263 kmem_free(pb, sizeof(*pb));
264 }
265
266 struct pathbuf *
267 pathbuf_assimilate(char *pnbuf)
268 {
269 struct pathbuf *pb;
270
271 pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
272 if (pb == NULL) {
273 return NULL;
274 }
275 pb->pb_path = pnbuf;
276 pb->pb_pathcopy = NULL;
277 pb->pb_pathcopyuses = 0;
278 return pb;
279 }
280
281 struct pathbuf *
282 pathbuf_create(const char *path)
283 {
284 struct pathbuf *pb;
285 int error;
286
287 pb = pathbuf_create_raw();
288 if (pb == NULL) {
289 return NULL;
290 }
291 error = copystr(path, pb->pb_path, PATH_MAX, NULL);
292 if (error != 0) {
293 KASSERT(!"kernel path too long in pathbuf_create");
294 /* make sure it's null-terminated, just in case */
295 pb->pb_path[PATH_MAX-1] = '\0';
296 }
297 return pb;
298 }
299
300 int
301 pathbuf_copyin(const char *userpath, struct pathbuf **ret)
302 {
303 struct pathbuf *pb;
304 int error;
305
306 pb = pathbuf_create_raw();
307 if (pb == NULL) {
308 return ENOMEM;
309 }
310 error = copyinstr(userpath, pb->pb_path, PATH_MAX, NULL);
311 if (error) {
312 pathbuf_destroy(pb);
313 return error;
314 }
315 *ret = pb;
316 return 0;
317 }
318
319 /*
320 * XXX should not exist
321 */
322 int
323 pathbuf_maybe_copyin(const char *path, enum uio_seg seg, struct pathbuf **ret)
324 {
325 if (seg == UIO_USERSPACE) {
326 return pathbuf_copyin(path, ret);
327 } else {
328 *ret = pathbuf_create(path);
329 if (*ret == NULL) {
330 return ENOMEM;
331 }
332 return 0;
333 }
334 }
335
336 /*
337 * Get a copy of the path buffer as it currently exists. If this is
338 * called after namei starts the results may be arbitrary.
339 */
340 void
341 pathbuf_copystring(const struct pathbuf *pb, char *buf, size_t maxlen)
342 {
343 strlcpy(buf, pb->pb_path, maxlen);
344 }
345
346 /*
347 * These two functions allow access to a saved copy of the original
348 * path string. The first copy should be gotten before namei is
349 * called. Each copy that is gotten should be put back.
350 */
351
352 const char *
353 pathbuf_stringcopy_get(struct pathbuf *pb)
354 {
355 if (pb->pb_pathcopyuses == 0) {
356 pb->pb_pathcopy = PNBUF_GET();
357 strcpy(pb->pb_pathcopy, pb->pb_path);
358 }
359 pb->pb_pathcopyuses++;
360 return pb->pb_pathcopy;
361 }
362
363 void
364 pathbuf_stringcopy_put(struct pathbuf *pb, const char *str)
365 {
366 KASSERT(str == pb->pb_pathcopy);
367 KASSERT(pb->pb_pathcopyuses > 0);
368 pb->pb_pathcopyuses--;
369 if (pb->pb_pathcopyuses == 0) {
370 PNBUF_PUT(pb->pb_pathcopy);
371 pb->pb_pathcopy = NULL;
372 }
373 }
374
375
376 ////////////////////////////////////////////////////////////
377
378 /*
379 * Convert a pathname into a pointer to a locked vnode.
380 *
381 * The FOLLOW flag is set when symbolic links are to be followed
382 * when they occur at the end of the name translation process.
383 * Symbolic links are always followed for all other pathname
384 * components other than the last.
385 *
386 * The segflg defines whether the name is to be copied from user
387 * space or kernel space.
388 *
389 * Overall outline of namei:
390 *
391 * copy in name
392 * get starting directory
393 * while (!done && !error) {
394 * call lookup to search path.
395 * if symbolic link, massage name in buffer and continue
396 * }
397 */
398
399 /*
400 * Internal state for a namei operation.
401 */
402 struct namei_state {
403 struct nameidata *ndp;
404 struct componentname *cnp;
405
406 int docache; /* == 0 do not cache last component */
407 int rdonly; /* lookup read-only flag bit */
408 int slashes;
409
410 unsigned attempt_retry:1; /* true if error allows emul retry */
411 };
412
413
414 /*
415 * Initialize the namei working state.
416 */
417 static void
418 namei_init(struct namei_state *state, struct nameidata *ndp)
419 {
420 state->ndp = ndp;
421 state->cnp = &ndp->ni_cnd;
422 KASSERT((state->cnp->cn_flags & INRELOOKUP) == 0);
423
424 state->docache = 0;
425 state->rdonly = 0;
426 state->slashes = 0;
427
428 #ifdef DIAGNOSTIC
429 if (!state->cnp->cn_cred)
430 panic("namei: bad cred/proc");
431 if (state->cnp->cn_nameiop & (~OPMASK))
432 panic("namei: nameiop contaminated with flags");
433 if (state->cnp->cn_flags & OPMASK)
434 panic("namei: flags contaminated with nameiops");
435 #endif
436
437 /*
438 * The buffer for name translation shall be the one inside the
439 * pathbuf.
440 */
441 state->ndp->ni_pnbuf = state->ndp->ni_pathbuf->pb_path;
442 }
443
444 /*
445 * Clean up the working namei state, leaving things ready for return
446 * from namei.
447 */
448 static void
449 namei_cleanup(struct namei_state *state)
450 {
451 KASSERT(state->cnp == &state->ndp->ni_cnd);
452
453 /* nothing for now */
454 (void)state;
455 }
456
457 //////////////////////////////
458
459 /*
460 * Get the directory context.
461 * Initializes the rootdir and erootdir state and returns a reference
462 * to the starting dir.
463 */
464 static struct vnode *
465 namei_getstartdir(struct namei_state *state)
466 {
467 struct nameidata *ndp = state->ndp;
468 struct componentname *cnp = state->cnp;
469 struct cwdinfo *cwdi; /* pointer to cwd state */
470 struct lwp *self = curlwp; /* thread doing namei() */
471 struct vnode *rootdir, *erootdir, *curdir, *startdir;
472
473 cwdi = self->l_proc->p_cwdi;
474 rw_enter(&cwdi->cwdi_lock, RW_READER);
475
476 /* root dir */
477 if (cwdi->cwdi_rdir == NULL || (cnp->cn_flags & NOCHROOT)) {
478 rootdir = rootvnode;
479 } else {
480 rootdir = cwdi->cwdi_rdir;
481 }
482
483 /* emulation root dir, if any */
484 if ((cnp->cn_flags & TRYEMULROOT) == 0) {
485 /* if we don't want it, don't fetch it */
486 erootdir = NULL;
487 } else if (cnp->cn_flags & EMULROOTSET) {
488 /* explicitly set emulroot; "/../" doesn't override this */
489 erootdir = ndp->ni_erootdir;
490 } else if (!strncmp(ndp->ni_pnbuf, "/../", 4)) {
491 /* explicit reference to real rootdir */
492 erootdir = NULL;
493 } else {
494 /* may be null */
495 erootdir = cwdi->cwdi_edir;
496 }
497
498 /* current dir */
499 curdir = cwdi->cwdi_cdir;
500
501 if (ndp->ni_pnbuf[0] != '/') {
502 startdir = curdir;
503 erootdir = NULL;
504 } else if (cnp->cn_flags & TRYEMULROOT && erootdir != NULL) {
505 startdir = erootdir;
506 } else {
507 startdir = rootdir;
508 erootdir = NULL;
509 }
510
511 state->ndp->ni_rootdir = rootdir;
512 state->ndp->ni_erootdir = erootdir;
513
514 /*
515 * Get a reference to the start dir so we can safely unlock cwdi.
516 *
517 * XXX: should we hold references to rootdir and erootdir while
518 * we're running? What happens if a multithreaded process chroots
519 * during namei?
520 */
521 vref(startdir);
522
523 rw_exit(&cwdi->cwdi_lock);
524 return startdir;
525 }
526
527 /*
528 * Get the directory context for the nfsd case, in parallel to
529 * getstartdir. Initializes the rootdir and erootdir state and
530 * returns a reference to the passed-instarting dir.
531 */
532 static struct vnode *
533 namei_getstartdir_for_nfsd(struct namei_state *state, struct vnode *startdir)
534 {
535 /* always use the real root, and never set an emulation root */
536 state->ndp->ni_rootdir = rootvnode;
537 state->ndp->ni_erootdir = NULL;
538
539 vref(startdir);
540 return startdir;
541 }
542
543
544 /*
545 * Ktrace the namei operation.
546 */
547 static void
548 namei_ktrace(struct namei_state *state)
549 {
550 struct nameidata *ndp = state->ndp;
551 struct componentname *cnp = state->cnp;
552 struct lwp *self = curlwp; /* thread doing namei() */
553 const char *emul_path;
554
555 if (ktrpoint(KTR_NAMEI)) {
556 if (ndp->ni_erootdir != NULL) {
557 /*
558 * To make any sense, the trace entry need to have the
559 * text of the emulation path prepended.
560 * Usually we can get this from the current process,
561 * but when called from emul_find_interp() it is only
562 * in the exec_package - so we get it passed in ni_next
563 * (this is a hack).
564 */
565 if (cnp->cn_flags & EMULROOTSET)
566 emul_path = ndp->ni_next;
567 else
568 emul_path = self->l_proc->p_emul->e_path;
569 ktrnamei2(emul_path, strlen(emul_path),
570 ndp->ni_pnbuf, ndp->ni_pathlen);
571 } else
572 ktrnamei(ndp->ni_pnbuf, ndp->ni_pathlen);
573 }
574 }
575
576 /*
577 * Start up namei. Copy the path, find the root dir and cwd, establish
578 * the starting directory for lookup, and lock it. Also calls ktrace when
579 * appropriate.
580 */
581 static int
582 namei_start(struct namei_state *state, struct vnode *forcecwd,
583 struct vnode **startdir_ret)
584 {
585 struct nameidata *ndp = state->ndp;
586 struct vnode *startdir;
587
588 /* length includes null terminator (was originally from copyinstr) */
589 ndp->ni_pathlen = strlen(ndp->ni_pnbuf) + 1;
590
591 /*
592 * POSIX.1 requirement: "" is not a valid file name.
593 */
594 if (ndp->ni_pathlen == 1) {
595 return ENOENT;
596 }
597
598 ndp->ni_loopcnt = 0;
599
600 /* Get starting directory, set up root, and ktrace. */
601 if (forcecwd != NULL) {
602 startdir = namei_getstartdir_for_nfsd(state, forcecwd);
603 /* no ktrace */
604 } else {
605 startdir = namei_getstartdir(state);
606 namei_ktrace(state);
607 }
608
609 vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
610
611 *startdir_ret = startdir;
612 return 0;
613 }
614
615 /*
616 * Check for being at a symlink.
617 */
618 static inline int
619 namei_atsymlink(struct namei_state *state, struct vnode *foundobj)
620 {
621 return (foundobj->v_type == VLNK) &&
622 (state->cnp->cn_flags & (FOLLOW|REQUIREDIR));
623 }
624
625 /*
626 * Follow a symlink.
627 */
628 static inline int
629 namei_follow(struct namei_state *state, int inhibitmagic,
630 struct vnode *searchdir, struct vnode *foundobj,
631 struct vnode **newsearchdir_ret)
632 {
633 struct nameidata *ndp = state->ndp;
634 struct componentname *cnp = state->cnp;
635
636 struct lwp *self = curlwp; /* thread doing namei() */
637 struct iovec aiov; /* uio for reading symbolic links */
638 struct uio auio;
639 char *cp; /* pointer into pathname argument */
640 size_t linklen;
641 int error;
642
643 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
644 return ELOOP;
645 }
646 if (foundobj->v_mount->mnt_flag & MNT_SYMPERM) {
647 error = VOP_ACCESS(foundobj, VEXEC, cnp->cn_cred);
648 if (error != 0)
649 return error;
650 }
651
652 /* FUTURE: fix this to not use a second buffer */
653 cp = PNBUF_GET();
654 aiov.iov_base = cp;
655 aiov.iov_len = MAXPATHLEN;
656 auio.uio_iov = &aiov;
657 auio.uio_iovcnt = 1;
658 auio.uio_offset = 0;
659 auio.uio_rw = UIO_READ;
660 auio.uio_resid = MAXPATHLEN;
661 UIO_SETUP_SYSSPACE(&auio);
662 error = VOP_READLINK(foundobj, &auio, cnp->cn_cred);
663 if (error) {
664 PNBUF_PUT(cp);
665 return error;
666 }
667 linklen = MAXPATHLEN - auio.uio_resid;
668 if (linklen == 0) {
669 PNBUF_PUT(cp);
670 return ENOENT;
671 }
672
673 /*
674 * Do symlink substitution, if appropriate, and
675 * check length for potential overflow.
676 *
677 * Inhibit symlink substitution for nfsd.
678 * XXX: This is how it was before; is that a bug or a feature?
679 */
680 if ((!inhibitmagic && vfs_magiclinks &&
681 symlink_magic(self->l_proc, cp, &linklen)) ||
682 (linklen + ndp->ni_pathlen >= MAXPATHLEN)) {
683 PNBUF_PUT(cp);
684 return ENAMETOOLONG;
685 }
686 if (ndp->ni_pathlen > 1) {
687 /* includes a null-terminator */
688 memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
689 } else {
690 cp[linklen] = '\0';
691 }
692 ndp->ni_pathlen += linklen;
693 memcpy(ndp->ni_pnbuf, cp, ndp->ni_pathlen);
694 PNBUF_PUT(cp);
695 vput(foundobj);
696
697 /*
698 * Check if root directory should replace current directory.
699 */
700 if (ndp->ni_pnbuf[0] == '/') {
701 vput(searchdir);
702 /* Keep absolute symbolic links inside emulation root */
703 searchdir = ndp->ni_erootdir;
704 if (searchdir == NULL ||
705 (ndp->ni_pnbuf[1] == '.'
706 && ndp->ni_pnbuf[2] == '.'
707 && ndp->ni_pnbuf[3] == '/')) {
708 ndp->ni_erootdir = NULL;
709 searchdir = ndp->ni_rootdir;
710 }
711 vref(searchdir);
712 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
713 }
714
715 *newsearchdir_ret = searchdir;
716 return 0;
717 }
718
719 //////////////////////////////
720
721 /*
722 * Search a pathname.
723 * This is a very central and rather complicated routine.
724 *
725 * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
726 * The starting directory is passed in. The pathname is descended
727 * until done, or a symbolic link is encountered. The variable ni_more
728 * is clear if the path is completed; it is set to one if a symbolic
729 * link needing interpretation is encountered.
730 *
731 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
732 * whether the name is to be looked up, created, renamed, or deleted.
733 * When CREATE, RENAME, or DELETE is specified, information usable in
734 * creating, renaming, or deleting a directory entry may be calculated.
735 * If flag has LOCKPARENT or'ed into it, the parent directory is returned
736 * locked. Otherwise the parent directory is not returned. If the target
737 * of the pathname exists and LOCKLEAF is or'ed into the flag the target
738 * is returned locked, otherwise it is returned unlocked. When creating
739 * or renaming and LOCKPARENT is specified, the target may not be ".".
740 * When deleting and LOCKPARENT is specified, the target may be ".".
741 *
742 * Overall outline of lookup:
743 *
744 * dirloop:
745 * identify next component of name at ndp->ni_ptr
746 * handle degenerate case where name is null string
747 * if .. and crossing mount points and on mounted filesys, find parent
748 * call VOP_LOOKUP routine for next component name
749 * directory vnode returned in ni_dvp, locked.
750 * component vnode returned in ni_vp (if it exists), locked.
751 * if result vnode is mounted on and crossing mount points,
752 * find mounted on vnode
753 * if more components of name, do next level at dirloop
754 * return the answer in ni_vp, locked if LOCKLEAF set
755 * if LOCKPARENT set, return locked parent in ni_dvp
756 */
757
758 static int
759 lookup_parsepath(struct namei_state *state)
760 {
761 const char *cp; /* pointer into pathname argument */
762
763 struct componentname *cnp = state->cnp;
764 struct nameidata *ndp = state->ndp;
765
766 KASSERT(cnp == &ndp->ni_cnd);
767
768 /*
769 * Search a new directory.
770 *
771 * The cn_hash value is for use by vfs_cache.
772 * The last component of the filename is left accessible via
773 * cnp->cn_nameptr for callers that need the name. Callers needing
774 * the name set the SAVENAME flag. When done, they assume
775 * responsibility for freeing the pathname buffer.
776 *
777 * At this point, our only vnode state is that the search dir
778 * is held and locked.
779 */
780 cnp->cn_consume = 0;
781 cp = NULL;
782 cnp->cn_hash = namei_hash(cnp->cn_nameptr, &cp);
783 cnp->cn_namelen = cp - cnp->cn_nameptr;
784 if (cnp->cn_namelen > NAME_MAX) {
785 return ENAMETOOLONG;
786 }
787 #ifdef NAMEI_DIAGNOSTIC
788 { char c = *cp;
789 *(char *)cp = '\0';
790 printf("{%s}: ", cnp->cn_nameptr);
791 *(char *)cp = c; }
792 #endif /* NAMEI_DIAGNOSTIC */
793 ndp->ni_pathlen -= cnp->cn_namelen;
794 ndp->ni_next = cp;
795 /*
796 * If this component is followed by a slash, then move the pointer to
797 * the next component forward, and remember that this component must be
798 * a directory.
799 */
800 if (*cp == '/') {
801 do {
802 cp++;
803 } while (*cp == '/');
804 state->slashes = cp - ndp->ni_next;
805 ndp->ni_pathlen -= state->slashes;
806 ndp->ni_next = cp;
807 cnp->cn_flags |= REQUIREDIR;
808 } else {
809 state->slashes = 0;
810 cnp->cn_flags &= ~REQUIREDIR;
811 }
812 /*
813 * We do special processing on the last component, whether or not it's
814 * a directory. Cache all intervening lookups, but not the final one.
815 */
816 if (*cp == '\0') {
817 if (state->docache)
818 cnp->cn_flags |= MAKEENTRY;
819 else
820 cnp->cn_flags &= ~MAKEENTRY;
821 cnp->cn_flags |= ISLASTCN;
822 } else {
823 cnp->cn_flags |= MAKEENTRY;
824 cnp->cn_flags &= ~ISLASTCN;
825 }
826 if (cnp->cn_namelen == 2 &&
827 cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
828 cnp->cn_flags |= ISDOTDOT;
829 else
830 cnp->cn_flags &= ~ISDOTDOT;
831
832 return 0;
833 }
834
835 static int
836 lookup_once(struct namei_state *state,
837 struct vnode *searchdir,
838 struct vnode **newsearchdir_ret,
839 struct vnode **foundobj_ret)
840 {
841 struct vnode *tmpvn; /* scratch vnode */
842 struct vnode *foundobj; /* result */
843 struct mount *mp; /* mount table entry */
844 struct lwp *l = curlwp;
845 int error;
846
847 struct componentname *cnp = state->cnp;
848 struct nameidata *ndp = state->ndp;
849
850 KASSERT(cnp == &ndp->ni_cnd);
851 *newsearchdir_ret = searchdir;
852
853 /*
854 * Handle "..": two special cases.
855 * 1. If at root directory (e.g. after chroot)
856 * or at absolute root directory
857 * then ignore it so can't get out.
858 * 1a. If at the root of the emulation filesystem go to the real
859 * root. So "/../<path>" is always absolute.
860 * 1b. If we have somehow gotten out of a jail, warn
861 * and also ignore it so we can't get farther out.
862 * 2. If this vnode is the root of a mounted
863 * filesystem, then replace it with the
864 * vnode which was mounted on so we take the
865 * .. in the other file system.
866 */
867 if (cnp->cn_flags & ISDOTDOT) {
868 struct proc *p = l->l_proc;
869
870 for (;;) {
871 if (searchdir == ndp->ni_rootdir ||
872 searchdir == rootvnode) {
873 foundobj = searchdir;
874 vref(foundobj);
875 *foundobj_ret = foundobj;
876 return 0;
877 }
878 if (ndp->ni_rootdir != rootvnode) {
879 int retval;
880
881 VOP_UNLOCK(searchdir);
882 retval = vn_isunder(searchdir, ndp->ni_rootdir, l);
883 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
884 if (!retval) {
885 /* Oops! We got out of jail! */
886 log(LOG_WARNING,
887 "chrooted pid %d uid %d (%s) "
888 "detected outside of its chroot\n",
889 p->p_pid, kauth_cred_geteuid(l->l_cred),
890 p->p_comm);
891 /* Put us at the jail root. */
892 vput(searchdir);
893 searchdir = NULL;
894 foundobj = ndp->ni_rootdir;
895 vref(foundobj);
896 vref(foundobj);
897 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
898 *newsearchdir_ret = foundobj;
899 *foundobj_ret = foundobj;
900 return 0;
901 }
902 }
903 if ((searchdir->v_vflag & VV_ROOT) == 0 ||
904 (cnp->cn_flags & NOCROSSMOUNT))
905 break;
906 tmpvn = searchdir;
907 searchdir = searchdir->v_mount->mnt_vnodecovered;
908 vref(searchdir);
909 vput(tmpvn);
910 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
911 *newsearchdir_ret = searchdir;
912 }
913 }
914
915 /*
916 * We now have a segment name to search for, and a directory to search.
917 * Our vnode state here is that "searchdir" is held and locked.
918 */
919 unionlookup:
920 foundobj = NULL;
921 error = VOP_LOOKUP(searchdir, &foundobj, cnp);
922
923 if (error != 0) {
924 #ifdef DIAGNOSTIC
925 if (foundobj != NULL)
926 panic("leaf `%s' should be empty", cnp->cn_nameptr);
927 #endif /* DIAGNOSTIC */
928 #ifdef NAMEI_DIAGNOSTIC
929 printf("not found\n");
930 #endif /* NAMEI_DIAGNOSTIC */
931 if ((error == ENOENT) &&
932 (searchdir->v_vflag & VV_ROOT) &&
933 (searchdir->v_mount->mnt_flag & MNT_UNION)) {
934 tmpvn = searchdir;
935 searchdir = searchdir->v_mount->mnt_vnodecovered;
936 vref(searchdir);
937 vput(tmpvn);
938 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
939 *newsearchdir_ret = searchdir;
940 goto unionlookup;
941 }
942
943 if (error != EJUSTRETURN)
944 return error;
945
946 /*
947 * If this was not the last component, or there were trailing
948 * slashes, and we are not going to create a directory,
949 * then the name must exist.
950 */
951 if ((cnp->cn_flags & (REQUIREDIR | CREATEDIR)) == REQUIREDIR) {
952 return ENOENT;
953 }
954
955 /*
956 * If creating and at end of pathname, then can consider
957 * allowing file to be created.
958 */
959 if (state->rdonly) {
960 return EROFS;
961 }
962
963 /*
964 * We return with foundobj NULL to indicate that the entry
965 * doesn't currently exist, leaving a pointer to the
966 * (possibly locked) directory vnode as searchdir.
967 */
968 *foundobj_ret = NULL;
969 return (0);
970 }
971 #ifdef NAMEI_DIAGNOSTIC
972 printf("found\n");
973 #endif /* NAMEI_DIAGNOSTIC */
974
975 /*
976 * Take into account any additional components consumed by the
977 * underlying filesystem. This will include any trailing slashes after
978 * the last component consumed.
979 */
980 if (cnp->cn_consume > 0) {
981 ndp->ni_pathlen -= cnp->cn_consume - state->slashes;
982 ndp->ni_next += cnp->cn_consume - state->slashes;
983 cnp->cn_consume = 0;
984 if (ndp->ni_next[0] == '\0')
985 cnp->cn_flags |= ISLASTCN;
986 }
987
988 /*
989 * "foundobj" and "searchdir" are both locked and held,
990 * and may be the same vnode.
991 */
992
993 /*
994 * Check to see if the vnode has been mounted on;
995 * if so find the root of the mounted file system.
996 */
997 while (foundobj->v_type == VDIR && (mp = foundobj->v_mountedhere) &&
998 (cnp->cn_flags & NOCROSSMOUNT) == 0) {
999 error = vfs_busy(mp, NULL);
1000 if (error != 0) {
1001 vput(foundobj);
1002 return error;
1003 }
1004 KASSERT(searchdir != foundobj);
1005 VOP_UNLOCK(searchdir);
1006 vput(foundobj);
1007 error = VFS_ROOT(mp, &foundobj);
1008 vfs_unbusy(mp, false, NULL);
1009 if (error) {
1010 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1011 return error;
1012 }
1013 VOP_UNLOCK(foundobj);
1014 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1015 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1016 }
1017
1018 *foundobj_ret = foundobj;
1019 return 0;
1020 }
1021
1022 //////////////////////////////
1023
1024 static int
1025 namei_oneroot(struct namei_state *state, struct vnode *forcecwd,
1026 int neverfollow, int inhibitmagic)
1027 {
1028 struct nameidata *ndp = state->ndp;
1029 struct componentname *cnp = state->cnp;
1030 struct vnode *searchdir, *foundobj;
1031 const char *cp;
1032 int error;
1033
1034 error = namei_start(state, forcecwd, &searchdir);
1035 if (error) {
1036 ndp->ni_dvp = NULL;
1037 ndp->ni_vp = NULL;
1038 return error;
1039 }
1040
1041 /*
1042 * Setup: break out flag bits into variables.
1043 */
1044 state->docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
1045 if (cnp->cn_nameiop == DELETE)
1046 state->docache = 0;
1047 state->rdonly = cnp->cn_flags & RDONLY;
1048
1049 /*
1050 * Keep going until we run out of path components.
1051 */
1052 cnp->cn_nameptr = ndp->ni_pnbuf;
1053 for (;;) {
1054
1055 /*
1056 * If the directory we're on is unmounted, bail out.
1057 * XXX: should this also check if it's unlinked?
1058 */
1059 if (searchdir->v_mount == NULL) {
1060 vput(searchdir);
1061 ndp->ni_dvp = NULL;
1062 ndp->ni_vp = NULL;
1063 return (ENOENT);
1064 }
1065
1066 /*
1067 * Look up the next path component.
1068 * (currently, this may consume more than one)
1069 */
1070
1071 ndp->ni_dvp = NULL;
1072 cnp->cn_flags &= ~ISSYMLINK;
1073
1074 dirloop:
1075 KASSERT(ndp->ni_dvp == NULL);
1076
1077 /*
1078 * If we have a leading string of slashes, remove
1079 * them, and just make sure the current node is a
1080 * directory.
1081 */
1082 cp = cnp->cn_nameptr;
1083 if (*cp == '/') {
1084 do {
1085 cp++;
1086 } while (*cp == '/');
1087 ndp->ni_pathlen -= cp - cnp->cn_nameptr;
1088 cnp->cn_nameptr = cp;
1089
1090 if (searchdir->v_type != VDIR) {
1091 vput(searchdir);
1092 KASSERT(ndp->ni_dvp == NULL);
1093 ndp->ni_vp = NULL;
1094 state->attempt_retry = 1;
1095 return ENOTDIR;
1096 }
1097 }
1098
1099 /*
1100 * If we've exhausted the path name, then just return the
1101 * current node.
1102 */
1103 if (cnp->cn_nameptr[0] == '\0') {
1104 vref(searchdir);
1105 foundobj = searchdir;
1106 cnp->cn_flags |= ISLASTCN;
1107
1108 /* bleh */
1109 goto terminal;
1110 }
1111
1112 error = lookup_parsepath(state);
1113 if (error) {
1114 vput(searchdir);
1115 KASSERT(ndp->ni_dvp == NULL);
1116 ndp->ni_vp = NULL;
1117 state->attempt_retry = 1;
1118 return (error);
1119 }
1120
1121 error = lookup_once(state, searchdir, &searchdir, &foundobj);
1122 if (error) {
1123 vput(searchdir);
1124 KASSERT(ndp->ni_dvp == NULL);
1125 ndp->ni_vp = NULL;
1126 /*
1127 * Note that if we're doing TRYEMULROOT we can
1128 * retry with the normal root. Where this is
1129 * currently set matches previous practice,
1130 * but the previous practice didn't make much
1131 * sense and somebody should sit down and
1132 * figure out which cases should cause retry
1133 * and which shouldn't. XXX.
1134 */
1135 state->attempt_retry = 1;
1136 return (error);
1137 }
1138 KASSERT(ndp->ni_dvp == NULL);
1139
1140 if (foundobj == NULL) {
1141 /*
1142 * Success with no object returned means we're
1143 * creating something and it isn't already
1144 * there. Break out of the main loop now so
1145 * the code below doesn't have to test for
1146 * foundobj == NULL.
1147 */
1148 break;
1149 }
1150
1151 /*
1152 * Check for symbolic link. If we've reached one,
1153 * follow it, unless we aren't supposed to. Back up
1154 * over any slashes that we skipped, as we will need
1155 * them again.
1156 */
1157 if (namei_atsymlink(state, foundobj)) {
1158 ndp->ni_pathlen += state->slashes;
1159 ndp->ni_next -= state->slashes;
1160 cnp->cn_flags |= ISSYMLINK;
1161 if (neverfollow) {
1162 error = EINVAL;
1163 } else {
1164 /*
1165 * dholland 20110410: if we're at a
1166 * union mount it might make sense to
1167 * use the top of the union stack here
1168 * rather than the layer we found the
1169 * symlink in. (FUTURE)
1170 */
1171 error = namei_follow(state, inhibitmagic,
1172 searchdir, foundobj,
1173 &searchdir);
1174 }
1175 if (error) {
1176 KASSERT(searchdir != foundobj);
1177 vput(searchdir);
1178 vput(foundobj);
1179 KASSERT(ndp->ni_dvp == NULL);
1180 ndp->ni_vp = NULL;
1181 return error;
1182 }
1183 cnp->cn_nameptr = ndp->ni_pnbuf;
1184 continue;
1185 }
1186
1187 /*
1188 * Check for directory, if the component was
1189 * followed by a series of slashes.
1190 */
1191 if ((foundobj->v_type != VDIR) && (cnp->cn_flags & REQUIREDIR)) {
1192 KASSERT(foundobj != searchdir);
1193 vput(foundobj);
1194 ndp->ni_vp = NULL;
1195 if (searchdir) {
1196 vput(searchdir);
1197 }
1198 state->attempt_retry = 1;
1199 return ENOTDIR;
1200 }
1201
1202 /*
1203 * Not a symbolic link. If this was not the
1204 * last component, then continue at the next
1205 * component, else return.
1206 */
1207 if (!(cnp->cn_flags & ISLASTCN)) {
1208 cnp->cn_nameptr = ndp->ni_next;
1209 if (searchdir == foundobj) {
1210 vrele(searchdir);
1211 } else {
1212 vput(searchdir);
1213 }
1214 KASSERT(ndp->ni_dvp == NULL);
1215 searchdir = foundobj;
1216 foundobj = NULL;
1217 goto dirloop;
1218 }
1219
1220 terminal:
1221 error = 0;
1222 if (foundobj == ndp->ni_erootdir) {
1223 /*
1224 * We are about to return the emulation root.
1225 * This isn't a good idea because code might
1226 * repeatedly lookup ".." until the file
1227 * matches that returned for "/" and loop
1228 * forever. So convert it to the real root.
1229 */
1230 if (searchdir == foundobj)
1231 vrele(foundobj);
1232 else
1233 if (searchdir != NULL)
1234 vput(searchdir);
1235 searchdir = NULL;
1236 KASSERT(ndp->ni_dvp == NULL);
1237 vput(foundobj);
1238 foundobj = ndp->ni_rootdir;
1239 vref(foundobj);
1240 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1241 }
1242
1243 /*
1244 * If the caller requested the parent node (i.e. it's
1245 * a CREATE, DELETE, or RENAME), and we don't have one
1246 * (because this is the root directory, or we crossed
1247 * a mount point), then we must fail.
1248 */
1249 if (cnp->cn_nameiop != LOOKUP &&
1250 (searchdir == NULL ||
1251 searchdir->v_mount != foundobj->v_mount)) {
1252 switch (cnp->cn_nameiop) {
1253 case CREATE:
1254 error = EEXIST;
1255 break;
1256 case DELETE:
1257 case RENAME:
1258 error = EBUSY;
1259 break;
1260 default:
1261 KASSERT(0);
1262 }
1263 if (searchdir) {
1264 vput(searchdir);
1265 }
1266 vput(foundobj);
1267 foundobj = NULL;
1268 KASSERT(ndp->ni_dvp == NULL);
1269 ndp->ni_vp = NULL;
1270 state->attempt_retry = 1;
1271 return (error);
1272 }
1273
1274 /*
1275 * Disallow directory write attempts on read-only lookups.
1276 * Prefers EEXIST over EROFS for the CREATE case.
1277 */
1278 if (state->rdonly &&
1279 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
1280 error = EROFS;
1281 if (foundobj != searchdir) {
1282 vput(foundobj);
1283 }
1284 if (searchdir) {
1285 vput(searchdir);
1286 }
1287 KASSERT(ndp->ni_dvp == NULL);
1288 ndp->ni_vp = NULL;
1289 state->attempt_retry = 1;
1290 return (error);
1291 }
1292 if ((cnp->cn_flags & LOCKLEAF) == 0) {
1293 VOP_UNLOCK(foundobj);
1294 }
1295
1296 break;
1297 }
1298
1299 /*
1300 * Done.
1301 */
1302
1303 /*
1304 * If LOCKPARENT is not set, the parent directory isn't returned.
1305 */
1306 if ((cnp->cn_flags & LOCKPARENT) == 0 && searchdir != NULL) {
1307 if (searchdir == foundobj) {
1308 vrele(searchdir);
1309 } else {
1310 vput(searchdir);
1311 }
1312 searchdir = NULL;
1313 }
1314
1315 ndp->ni_dvp = searchdir;
1316 ndp->ni_vp = foundobj;
1317 return 0;
1318 }
1319
1320 static int
1321 namei_tryemulroot(struct namei_state *state, struct vnode *forcecwd,
1322 int neverfollow, int inhibitmagic)
1323 {
1324 int error;
1325
1326 struct nameidata *ndp = state->ndp;
1327 struct componentname *cnp = state->cnp;
1328 const char *savepath = NULL;
1329
1330 KASSERT(cnp == &ndp->ni_cnd);
1331
1332 if (cnp->cn_flags & TRYEMULROOT) {
1333 savepath = pathbuf_stringcopy_get(ndp->ni_pathbuf);
1334 }
1335
1336 emul_retry:
1337 state->attempt_retry = 0;
1338
1339 error = namei_oneroot(state, forcecwd, neverfollow, inhibitmagic);
1340 if (error) {
1341 /*
1342 * Once namei has started up, the existence of ni_erootdir
1343 * tells us whether we're working from an emulation root.
1344 * The TRYEMULROOT flag isn't necessarily authoritative.
1345 */
1346 if (ndp->ni_erootdir != NULL && state->attempt_retry) {
1347 /* Retry the whole thing using the normal root */
1348 cnp->cn_flags &= ~TRYEMULROOT;
1349 state->attempt_retry = 0;
1350
1351 /* kinda gross */
1352 strcpy(ndp->ni_pathbuf->pb_path, savepath);
1353 pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1354 savepath = NULL;
1355
1356 goto emul_retry;
1357 }
1358 }
1359 if (savepath != NULL) {
1360 pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1361 }
1362 return error;
1363 }
1364
1365 int
1366 namei(struct nameidata *ndp)
1367 {
1368 struct namei_state state;
1369 int error;
1370
1371 namei_init(&state, ndp);
1372 error = namei_tryemulroot(&state, NULL,
1373 0/*!neverfollow*/, 0/*!inhibitmagic*/);
1374 namei_cleanup(&state);
1375
1376 if (error) {
1377 /* make sure no stray refs leak out */
1378 KASSERT(ndp->ni_dvp == NULL);
1379 KASSERT(ndp->ni_vp == NULL);
1380 }
1381
1382 return error;
1383 }
1384
1385 ////////////////////////////////////////////////////////////
1386
1387 /*
1388 * Externally visible interfaces used by nfsd (bletch, yuk, XXX)
1389 *
1390 * The "index" version differs from the "main" version in that it's
1391 * called from a different place in a different context. For now I
1392 * want to be able to shuffle code in from one call site without
1393 * affecting the other.
1394 *
1395 * It turns out that the "main" version was a cut and pasted copy of
1396 * namei with a few changes; the "index" version on the other hand
1397 * always takes a single component and is an elaborate form of calling
1398 * VOP_LOOKUP once.
1399 */
1400
1401 int
1402 lookup_for_nfsd(struct nameidata *ndp, struct vnode *forcecwd, int neverfollow)
1403 {
1404 struct namei_state state;
1405 int error;
1406
1407 namei_init(&state, ndp);
1408 error = namei_tryemulroot(&state, forcecwd,
1409 neverfollow, 1/*inhibitmagic*/);
1410 namei_cleanup(&state);
1411
1412 if (error) {
1413 /* make sure no stray refs leak out */
1414 KASSERT(ndp->ni_dvp == NULL);
1415 KASSERT(ndp->ni_vp == NULL);
1416 }
1417
1418 return error;
1419 }
1420
1421 static int
1422 do_lookup_for_nfsd_index(struct namei_state *state, struct vnode *startdir)
1423 {
1424 int error = 0;
1425
1426 struct componentname *cnp = state->cnp;
1427 struct nameidata *ndp = state->ndp;
1428 struct vnode *foundobj;
1429 const char *cp; /* pointer into pathname argument */
1430
1431 KASSERT(cnp == &ndp->ni_cnd);
1432
1433 cnp->cn_nameptr = ndp->ni_pnbuf;
1434 state->docache = 1;
1435 state->rdonly = cnp->cn_flags & RDONLY;
1436 ndp->ni_dvp = NULL;
1437 cnp->cn_flags &= ~ISSYMLINK;
1438
1439 cnp->cn_consume = 0;
1440 cp = NULL;
1441 cnp->cn_hash = namei_hash(cnp->cn_nameptr, &cp);
1442 cnp->cn_namelen = cp - cnp->cn_nameptr;
1443 KASSERT(cnp->cn_namelen <= NAME_MAX);
1444 ndp->ni_pathlen -= cnp->cn_namelen;
1445 ndp->ni_next = cp;
1446 state->slashes = 0;
1447 cnp->cn_flags &= ~REQUIREDIR;
1448 cnp->cn_flags |= MAKEENTRY|ISLASTCN;
1449
1450 if (cnp->cn_namelen == 2 &&
1451 cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
1452 cnp->cn_flags |= ISDOTDOT;
1453 else
1454 cnp->cn_flags &= ~ISDOTDOT;
1455
1456 /*
1457 * Because lookup_once can change the startdir, we need our
1458 * own reference to it to avoid consuming the caller's.
1459 */
1460 vref(startdir);
1461 vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
1462 error = lookup_once(state, startdir, &startdir, &foundobj);
1463 vput(startdir);
1464 if (error) {
1465 goto bad;
1466 }
1467 ndp->ni_vp = foundobj;
1468
1469 if (foundobj == NULL) {
1470 return 0;
1471 }
1472
1473 KASSERT((cnp->cn_flags & LOCKPARENT) == 0);
1474 if ((cnp->cn_flags & LOCKLEAF) == 0) {
1475 VOP_UNLOCK(foundobj);
1476 }
1477 return (0);
1478
1479 bad:
1480 ndp->ni_vp = NULL;
1481 return (error);
1482 }
1483
1484 int
1485 lookup_for_nfsd_index(struct nameidata *ndp, struct vnode *startdir)
1486 {
1487 struct namei_state state;
1488 int error;
1489
1490 /*
1491 * Note: the name sent in here (is not|should not be) allowed
1492 * to contain a slash.
1493 */
1494 if (strlen(ndp->ni_pathbuf->pb_path) > NAME_MAX) {
1495 return ENAMETOOLONG;
1496 }
1497 if (strchr(ndp->ni_pathbuf->pb_path, '/')) {
1498 return EINVAL;
1499 }
1500
1501 ndp->ni_pathlen = strlen(ndp->ni_pathbuf->pb_path) + 1;
1502 ndp->ni_pnbuf = NULL;
1503 ndp->ni_cnd.cn_nameptr = NULL;
1504
1505 namei_init(&state, ndp);
1506 error = do_lookup_for_nfsd_index(&state, startdir);
1507 namei_cleanup(&state);
1508
1509 return error;
1510 }
1511
1512 ////////////////////////////////////////////////////////////
1513
1514 /*
1515 * Reacquire a path name component.
1516 * dvp is locked on entry and exit.
1517 * *vpp is locked on exit unless it's NULL.
1518 */
1519 int
1520 relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int dummy)
1521 {
1522 int rdonly; /* lookup read-only flag bit */
1523 int error = 0;
1524 #ifdef DEBUG
1525 uint32_t newhash; /* DEBUG: check name hash */
1526 const char *cp; /* DEBUG: check name ptr/len */
1527 #endif /* DEBUG */
1528
1529 (void)dummy;
1530
1531 /*
1532 * Setup: break out flag bits into variables.
1533 */
1534 rdonly = cnp->cn_flags & RDONLY;
1535 cnp->cn_flags &= ~ISSYMLINK;
1536
1537 /*
1538 * Search a new directory.
1539 *
1540 * The cn_hash value is for use by vfs_cache.
1541 * The last component of the filename is left accessible via
1542 * cnp->cn_nameptr for callers that need the name. Callers needing
1543 * the name set the SAVENAME flag. When done, they assume
1544 * responsibility for freeing the pathname buffer.
1545 */
1546 #ifdef DEBUG
1547 cp = NULL;
1548 newhash = namei_hash(cnp->cn_nameptr, &cp);
1549 if ((uint32_t)newhash != (uint32_t)cnp->cn_hash)
1550 panic("relookup: bad hash");
1551 if (cnp->cn_namelen != cp - cnp->cn_nameptr)
1552 panic("relookup: bad len");
1553 while (*cp == '/')
1554 cp++;
1555 if (*cp != 0)
1556 panic("relookup: not last component");
1557 #endif /* DEBUG */
1558
1559 /*
1560 * Check for degenerate name (e.g. / or "")
1561 * which is a way of talking about a directory,
1562 * e.g. like "/." or ".".
1563 */
1564 if (cnp->cn_nameptr[0] == '\0')
1565 panic("relookup: null name");
1566
1567 if (cnp->cn_flags & ISDOTDOT)
1568 panic("relookup: lookup on dot-dot");
1569
1570 /*
1571 * We now have a segment name to search for, and a directory to search.
1572 */
1573 cnp->cn_flags |= INRELOOKUP;
1574 error = VOP_LOOKUP(dvp, vpp, cnp);
1575 cnp->cn_flags &= ~INRELOOKUP;
1576 if ((error) != 0) {
1577 #ifdef DIAGNOSTIC
1578 if (*vpp != NULL)
1579 panic("leaf `%s' should be empty", cnp->cn_nameptr);
1580 #endif
1581 if (error != EJUSTRETURN)
1582 goto bad;
1583 }
1584
1585 #ifdef DIAGNOSTIC
1586 /*
1587 * Check for symbolic link
1588 */
1589 if (*vpp && (*vpp)->v_type == VLNK && (cnp->cn_flags & FOLLOW))
1590 panic("relookup: symlink found");
1591 #endif
1592
1593 /*
1594 * Check for read-only lookups.
1595 */
1596 if (rdonly && cnp->cn_nameiop != LOOKUP) {
1597 error = EROFS;
1598 if (*vpp) {
1599 vput(*vpp);
1600 }
1601 goto bad;
1602 }
1603 return (0);
1604
1605 bad:
1606 *vpp = NULL;
1607 return (error);
1608 }
1609
1610 /*
1611 * namei_simple - simple forms of namei.
1612 *
1613 * These are wrappers to allow the simple case callers of namei to be
1614 * left alone while everything else changes under them.
1615 */
1616
1617 /* Flags */
1618 struct namei_simple_flags_type {
1619 int dummy;
1620 };
1621 static const struct namei_simple_flags_type ns_nn, ns_nt, ns_fn, ns_ft;
1622 const namei_simple_flags_t NSM_NOFOLLOW_NOEMULROOT = &ns_nn;
1623 const namei_simple_flags_t NSM_NOFOLLOW_TRYEMULROOT = &ns_nt;
1624 const namei_simple_flags_t NSM_FOLLOW_NOEMULROOT = &ns_fn;
1625 const namei_simple_flags_t NSM_FOLLOW_TRYEMULROOT = &ns_ft;
1626
1627 static
1628 int
1629 namei_simple_convert_flags(namei_simple_flags_t sflags)
1630 {
1631 if (sflags == NSM_NOFOLLOW_NOEMULROOT)
1632 return NOFOLLOW | 0;
1633 if (sflags == NSM_NOFOLLOW_TRYEMULROOT)
1634 return NOFOLLOW | TRYEMULROOT;
1635 if (sflags == NSM_FOLLOW_NOEMULROOT)
1636 return FOLLOW | 0;
1637 if (sflags == NSM_FOLLOW_TRYEMULROOT)
1638 return FOLLOW | TRYEMULROOT;
1639 panic("namei_simple_convert_flags: bogus sflags\n");
1640 return 0;
1641 }
1642
1643 int
1644 namei_simple_kernel(const char *path, namei_simple_flags_t sflags,
1645 struct vnode **vp_ret)
1646 {
1647 struct nameidata nd;
1648 struct pathbuf *pb;
1649 int err;
1650
1651 pb = pathbuf_create(path);
1652 if (pb == NULL) {
1653 return ENOMEM;
1654 }
1655
1656 NDINIT(&nd,
1657 LOOKUP,
1658 namei_simple_convert_flags(sflags),
1659 pb);
1660 err = namei(&nd);
1661 if (err != 0) {
1662 pathbuf_destroy(pb);
1663 return err;
1664 }
1665 *vp_ret = nd.ni_vp;
1666 pathbuf_destroy(pb);
1667 return 0;
1668 }
1669
1670 int
1671 namei_simple_user(const char *path, namei_simple_flags_t sflags,
1672 struct vnode **vp_ret)
1673 {
1674 struct pathbuf *pb;
1675 struct nameidata nd;
1676 int err;
1677
1678 err = pathbuf_copyin(path, &pb);
1679 if (err) {
1680 return err;
1681 }
1682
1683 NDINIT(&nd,
1684 LOOKUP,
1685 namei_simple_convert_flags(sflags),
1686 pb);
1687 err = namei(&nd);
1688 if (err != 0) {
1689 pathbuf_destroy(pb);
1690 return err;
1691 }
1692 *vp_ret = nd.ni_vp;
1693 pathbuf_destroy(pb);
1694 return 0;
1695 }
1696