vfs_lookup.c revision 1.168 1 /* $NetBSD: vfs_lookup.c,v 1.168 2011/04/11 02:19:27 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.168 2011/04/11 02:19:27 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. Find the root dir and cwd, establish the starting
578 * 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
696 /* we're now starting from the beginning of the buffer again */
697 cnp->cn_nameptr = ndp->ni_pnbuf;
698
699 /*
700 * Check if root directory should replace current directory.
701 */
702 if (ndp->ni_pnbuf[0] == '/') {
703 vput(searchdir);
704 /* Keep absolute symbolic links inside emulation root */
705 searchdir = ndp->ni_erootdir;
706 if (searchdir == NULL ||
707 (ndp->ni_pnbuf[1] == '.'
708 && ndp->ni_pnbuf[2] == '.'
709 && ndp->ni_pnbuf[3] == '/')) {
710 ndp->ni_erootdir = NULL;
711 searchdir = ndp->ni_rootdir;
712 }
713 vref(searchdir);
714 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
715 }
716
717 *newsearchdir_ret = searchdir;
718 return 0;
719 }
720
721 //////////////////////////////
722
723 /*
724 * Search a pathname.
725 * This is a very central and rather complicated routine.
726 *
727 * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
728 * The starting directory is passed in. The pathname is descended
729 * until done, or a symbolic link is encountered. The variable ni_more
730 * is clear if the path is completed; it is set to one if a symbolic
731 * link needing interpretation is encountered.
732 *
733 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
734 * whether the name is to be looked up, created, renamed, or deleted.
735 * When CREATE, RENAME, or DELETE is specified, information usable in
736 * creating, renaming, or deleting a directory entry may be calculated.
737 * If flag has LOCKPARENT or'ed into it, the parent directory is returned
738 * locked. Otherwise the parent directory is not returned. If the target
739 * of the pathname exists and LOCKLEAF is or'ed into the flag the target
740 * is returned locked, otherwise it is returned unlocked. When creating
741 * or renaming and LOCKPARENT is specified, the target may not be ".".
742 * When deleting and LOCKPARENT is specified, the target may be ".".
743 *
744 * Overall outline of lookup:
745 *
746 * dirloop:
747 * identify next component of name at ndp->ni_ptr
748 * handle degenerate case where name is null string
749 * if .. and crossing mount points and on mounted filesys, find parent
750 * call VOP_LOOKUP routine for next component name
751 * directory vnode returned in ni_dvp, locked.
752 * component vnode returned in ni_vp (if it exists), locked.
753 * if result vnode is mounted on and crossing mount points,
754 * find mounted on vnode
755 * if more components of name, do next level at dirloop
756 * return the answer in ni_vp, locked if LOCKLEAF set
757 * if LOCKPARENT set, return locked parent in ni_dvp
758 */
759
760 static int
761 lookup_parsepath(struct namei_state *state)
762 {
763 const char *cp; /* pointer into pathname argument */
764
765 struct componentname *cnp = state->cnp;
766 struct nameidata *ndp = state->ndp;
767
768 KASSERT(cnp == &ndp->ni_cnd);
769
770 /*
771 * Search a new directory.
772 *
773 * The cn_hash value is for use by vfs_cache.
774 * The last component of the filename is left accessible via
775 * cnp->cn_nameptr for callers that need the name. Callers needing
776 * the name set the SAVENAME flag. When done, they assume
777 * responsibility for freeing the pathname buffer.
778 *
779 * At this point, our only vnode state is that the search dir
780 * is held and locked.
781 */
782 cnp->cn_consume = 0;
783 cp = NULL;
784 cnp->cn_hash = namei_hash(cnp->cn_nameptr, &cp);
785 cnp->cn_namelen = cp - cnp->cn_nameptr;
786 if (cnp->cn_namelen > NAME_MAX) {
787 return ENAMETOOLONG;
788 }
789 #ifdef NAMEI_DIAGNOSTIC
790 { char c = *cp;
791 *(char *)cp = '\0';
792 printf("{%s}: ", cnp->cn_nameptr);
793 *(char *)cp = c; }
794 #endif /* NAMEI_DIAGNOSTIC */
795 ndp->ni_pathlen -= cnp->cn_namelen;
796 ndp->ni_next = cp;
797 /*
798 * If this component is followed by a slash, then move the pointer to
799 * the next component forward, and remember that this component must be
800 * a directory.
801 */
802 if (*cp == '/') {
803 do {
804 cp++;
805 } while (*cp == '/');
806 state->slashes = cp - ndp->ni_next;
807 ndp->ni_pathlen -= state->slashes;
808 ndp->ni_next = cp;
809 cnp->cn_flags |= REQUIREDIR;
810 } else {
811 state->slashes = 0;
812 cnp->cn_flags &= ~REQUIREDIR;
813 }
814 /*
815 * We do special processing on the last component, whether or not it's
816 * a directory. Cache all intervening lookups, but not the final one.
817 */
818 if (*cp == '\0') {
819 if (state->docache)
820 cnp->cn_flags |= MAKEENTRY;
821 else
822 cnp->cn_flags &= ~MAKEENTRY;
823 cnp->cn_flags |= ISLASTCN;
824 } else {
825 cnp->cn_flags |= MAKEENTRY;
826 cnp->cn_flags &= ~ISLASTCN;
827 }
828 if (cnp->cn_namelen == 2 &&
829 cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
830 cnp->cn_flags |= ISDOTDOT;
831 else
832 cnp->cn_flags &= ~ISDOTDOT;
833
834 return 0;
835 }
836
837 static int
838 lookup_once(struct namei_state *state,
839 struct vnode *searchdir,
840 struct vnode **newsearchdir_ret,
841 struct vnode **foundobj_ret)
842 {
843 struct vnode *tmpvn; /* scratch vnode */
844 struct vnode *foundobj; /* result */
845 struct mount *mp; /* mount table entry */
846 struct lwp *l = curlwp;
847 int error;
848
849 struct componentname *cnp = state->cnp;
850 struct nameidata *ndp = state->ndp;
851
852 KASSERT(cnp == &ndp->ni_cnd);
853 *newsearchdir_ret = searchdir;
854
855 /*
856 * Handle "..": two special cases.
857 * 1. If at root directory (e.g. after chroot)
858 * or at absolute root directory
859 * then ignore it so can't get out.
860 * 1a. If at the root of the emulation filesystem go to the real
861 * root. So "/../<path>" is always absolute.
862 * 1b. If we have somehow gotten out of a jail, warn
863 * and also ignore it so we can't get farther out.
864 * 2. If this vnode is the root of a mounted
865 * filesystem, then replace it with the
866 * vnode which was mounted on so we take the
867 * .. in the other file system.
868 */
869 if (cnp->cn_flags & ISDOTDOT) {
870 struct proc *p = l->l_proc;
871
872 for (;;) {
873 if (searchdir == ndp->ni_rootdir ||
874 searchdir == rootvnode) {
875 foundobj = searchdir;
876 vref(foundobj);
877 *foundobj_ret = foundobj;
878 return 0;
879 }
880 if (ndp->ni_rootdir != rootvnode) {
881 int retval;
882
883 VOP_UNLOCK(searchdir);
884 retval = vn_isunder(searchdir, ndp->ni_rootdir, l);
885 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
886 if (!retval) {
887 /* Oops! We got out of jail! */
888 log(LOG_WARNING,
889 "chrooted pid %d uid %d (%s) "
890 "detected outside of its chroot\n",
891 p->p_pid, kauth_cred_geteuid(l->l_cred),
892 p->p_comm);
893 /* Put us at the jail root. */
894 vput(searchdir);
895 searchdir = NULL;
896 foundobj = ndp->ni_rootdir;
897 vref(foundobj);
898 vref(foundobj);
899 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
900 *newsearchdir_ret = foundobj;
901 *foundobj_ret = foundobj;
902 return 0;
903 }
904 }
905 if ((searchdir->v_vflag & VV_ROOT) == 0 ||
906 (cnp->cn_flags & NOCROSSMOUNT))
907 break;
908 tmpvn = searchdir;
909 searchdir = searchdir->v_mount->mnt_vnodecovered;
910 vref(searchdir);
911 vput(tmpvn);
912 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
913 *newsearchdir_ret = searchdir;
914 }
915 }
916
917 /*
918 * We now have a segment name to search for, and a directory to search.
919 * Our vnode state here is that "searchdir" is held and locked.
920 */
921 unionlookup:
922 foundobj = NULL;
923 error = VOP_LOOKUP(searchdir, &foundobj, cnp);
924
925 if (error != 0) {
926 #ifdef DIAGNOSTIC
927 if (foundobj != NULL)
928 panic("leaf `%s' should be empty", cnp->cn_nameptr);
929 #endif /* DIAGNOSTIC */
930 #ifdef NAMEI_DIAGNOSTIC
931 printf("not found\n");
932 #endif /* NAMEI_DIAGNOSTIC */
933 if ((error == ENOENT) &&
934 (searchdir->v_vflag & VV_ROOT) &&
935 (searchdir->v_mount->mnt_flag & MNT_UNION)) {
936 tmpvn = searchdir;
937 searchdir = searchdir->v_mount->mnt_vnodecovered;
938 vref(searchdir);
939 vput(tmpvn);
940 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
941 *newsearchdir_ret = searchdir;
942 goto unionlookup;
943 }
944
945 if (error != EJUSTRETURN)
946 return error;
947
948 /*
949 * If this was not the last component, or there were trailing
950 * slashes, and we are not going to create a directory,
951 * then the name must exist.
952 */
953 if ((cnp->cn_flags & (REQUIREDIR | CREATEDIR)) == REQUIREDIR) {
954 return ENOENT;
955 }
956
957 /*
958 * If creating and at end of pathname, then can consider
959 * allowing file to be created.
960 */
961 if (state->rdonly) {
962 return EROFS;
963 }
964
965 /*
966 * We return success and a NULL foundobj to indicate
967 * that the entry doesn't currently exist, leaving a
968 * pointer to the (possibly locked) directory vnode as
969 * searchdir.
970 */
971 *foundobj_ret = NULL;
972 return (0);
973 }
974 #ifdef NAMEI_DIAGNOSTIC
975 printf("found\n");
976 #endif /* NAMEI_DIAGNOSTIC */
977
978 /*
979 * Take into account any additional components consumed by the
980 * underlying filesystem. This will include any trailing slashes after
981 * the last component consumed.
982 */
983 if (cnp->cn_consume > 0) {
984 ndp->ni_pathlen -= cnp->cn_consume - state->slashes;
985 ndp->ni_next += cnp->cn_consume - state->slashes;
986 cnp->cn_consume = 0;
987 if (ndp->ni_next[0] == '\0')
988 cnp->cn_flags |= ISLASTCN;
989 }
990
991 /*
992 * "foundobj" and "searchdir" are both locked and held,
993 * and may be the same vnode.
994 */
995
996 /*
997 * Check to see if the vnode has been mounted on;
998 * if so find the root of the mounted file system.
999 */
1000 while (foundobj->v_type == VDIR && (mp = foundobj->v_mountedhere) &&
1001 (cnp->cn_flags & NOCROSSMOUNT) == 0) {
1002 error = vfs_busy(mp, NULL);
1003 if (error != 0) {
1004 vput(foundobj);
1005 return error;
1006 }
1007 KASSERT(searchdir != foundobj);
1008 VOP_UNLOCK(searchdir);
1009 vput(foundobj);
1010 error = VFS_ROOT(mp, &foundobj);
1011 vfs_unbusy(mp, false, NULL);
1012 if (error) {
1013 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1014 return error;
1015 }
1016 VOP_UNLOCK(foundobj);
1017 vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1018 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1019 }
1020
1021 *foundobj_ret = foundobj;
1022 return 0;
1023 }
1024
1025 //////////////////////////////
1026
1027 static int
1028 namei_oneroot(struct namei_state *state, struct vnode *forcecwd,
1029 int neverfollow, int inhibitmagic)
1030 {
1031 struct nameidata *ndp = state->ndp;
1032 struct componentname *cnp = state->cnp;
1033 struct vnode *searchdir, *foundobj;
1034 const char *cp;
1035 int error;
1036
1037 error = namei_start(state, forcecwd, &searchdir);
1038 if (error) {
1039 ndp->ni_dvp = NULL;
1040 ndp->ni_vp = NULL;
1041 return error;
1042 }
1043
1044 /*
1045 * Setup: break out flag bits into variables.
1046 */
1047 state->docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
1048 if (cnp->cn_nameiop == DELETE)
1049 state->docache = 0;
1050 state->rdonly = cnp->cn_flags & RDONLY;
1051
1052 /*
1053 * Keep going until we run out of path components.
1054 */
1055 cnp->cn_nameptr = ndp->ni_pnbuf;
1056 for (;;) {
1057
1058 /*
1059 * If the directory we're on is unmounted, bail out.
1060 * XXX: should this also check if it's unlinked?
1061 */
1062 if (searchdir->v_mount == NULL) {
1063 vput(searchdir);
1064 ndp->ni_dvp = NULL;
1065 ndp->ni_vp = NULL;
1066 return (ENOENT);
1067 }
1068
1069 /*
1070 * Look up the next path component.
1071 * (currently, this may consume more than one)
1072 */
1073
1074 cnp->cn_flags &= ~ISSYMLINK;
1075
1076 dirloop:
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 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 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 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
1139 if (foundobj == NULL) {
1140 /*
1141 * Success with no object returned means we're
1142 * creating something and it isn't already
1143 * there. Break out of the main loop now so
1144 * the code below doesn't have to test for
1145 * foundobj == NULL.
1146 */
1147 break;
1148 }
1149
1150 /*
1151 * Check for symbolic link. If we've reached one,
1152 * follow it, unless we aren't supposed to. Back up
1153 * over any slashes that we skipped, as we will need
1154 * them again.
1155 */
1156 if (namei_atsymlink(state, foundobj)) {
1157 ndp->ni_pathlen += state->slashes;
1158 ndp->ni_next -= state->slashes;
1159 cnp->cn_flags |= ISSYMLINK;
1160 if (neverfollow) {
1161 error = EINVAL;
1162 } else {
1163 /*
1164 * dholland 20110410: if we're at a
1165 * union mount it might make sense to
1166 * use the top of the union stack here
1167 * rather than the layer we found the
1168 * symlink in. (FUTURE)
1169 */
1170 error = namei_follow(state, inhibitmagic,
1171 searchdir, foundobj,
1172 &searchdir);
1173 }
1174 if (error) {
1175 KASSERT(searchdir != foundobj);
1176 vput(searchdir);
1177 vput(foundobj);
1178 ndp->ni_dvp = NULL;
1179 ndp->ni_vp = NULL;
1180 return error;
1181 }
1182 vput(foundobj);
1183 foundobj = NULL;
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 if (searchdir) {
1194 vput(searchdir);
1195 }
1196 vput(foundobj);
1197 ndp->ni_dvp = NULL;
1198 ndp->ni_vp = NULL;
1199 state->attempt_retry = 1;
1200 return ENOTDIR;
1201 }
1202
1203 /*
1204 * Not a symbolic link. If this was not the
1205 * last component, then continue at the next
1206 * component, else return.
1207 */
1208 if (!(cnp->cn_flags & ISLASTCN)) {
1209 cnp->cn_nameptr = ndp->ni_next;
1210 if (searchdir == foundobj) {
1211 vrele(searchdir);
1212 } else {
1213 vput(searchdir);
1214 }
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 vput(foundobj);
1237 foundobj = ndp->ni_rootdir;
1238 vref(foundobj);
1239 vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1240 }
1241
1242 /*
1243 * If the caller requested the parent node (i.e. it's
1244 * a CREATE, DELETE, or RENAME), and we don't have one
1245 * (because this is the root directory, or we crossed
1246 * a mount point), then we must fail.
1247 */
1248 if (cnp->cn_nameiop != LOOKUP &&
1249 (searchdir == NULL ||
1250 searchdir->v_mount != foundobj->v_mount)) {
1251 switch (cnp->cn_nameiop) {
1252 case CREATE:
1253 error = EEXIST;
1254 break;
1255 case DELETE:
1256 case RENAME:
1257 error = EBUSY;
1258 break;
1259 default:
1260 KASSERT(0);
1261 }
1262 if (searchdir) {
1263 vput(searchdir);
1264 }
1265 vput(foundobj);
1266 foundobj = NULL;
1267 ndp->ni_dvp = NULL;
1268 ndp->ni_vp = NULL;
1269 state->attempt_retry = 1;
1270 return (error);
1271 }
1272
1273 /*
1274 * Disallow directory write attempts on read-only lookups.
1275 * Prefers EEXIST over EROFS for the CREATE case.
1276 */
1277 if (state->rdonly &&
1278 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
1279 error = EROFS;
1280 if (foundobj != searchdir) {
1281 vput(foundobj);
1282 }
1283 if (searchdir) {
1284 vput(searchdir);
1285 }
1286 ndp->ni_dvp = NULL;
1287 ndp->ni_vp = NULL;
1288 state->attempt_retry = 1;
1289 return (error);
1290 }
1291 if ((cnp->cn_flags & LOCKLEAF) == 0) {
1292 VOP_UNLOCK(foundobj);
1293 }
1294
1295 break;
1296 }
1297
1298 /*
1299 * Done.
1300 */
1301
1302 /*
1303 * If LOCKPARENT is not set, the parent directory isn't returned.
1304 */
1305 if ((cnp->cn_flags & LOCKPARENT) == 0 && searchdir != NULL) {
1306 if (searchdir == foundobj) {
1307 vrele(searchdir);
1308 } else {
1309 vput(searchdir);
1310 }
1311 searchdir = NULL;
1312 }
1313
1314 ndp->ni_dvp = searchdir;
1315 ndp->ni_vp = foundobj;
1316 return 0;
1317 }
1318
1319 static int
1320 namei_tryemulroot(struct namei_state *state, struct vnode *forcecwd,
1321 int neverfollow, int inhibitmagic)
1322 {
1323 int error;
1324
1325 struct nameidata *ndp = state->ndp;
1326 struct componentname *cnp = state->cnp;
1327 const char *savepath = NULL;
1328
1329 KASSERT(cnp == &ndp->ni_cnd);
1330
1331 if (cnp->cn_flags & TRYEMULROOT) {
1332 savepath = pathbuf_stringcopy_get(ndp->ni_pathbuf);
1333 }
1334
1335 emul_retry:
1336 state->attempt_retry = 0;
1337
1338 error = namei_oneroot(state, forcecwd, neverfollow, inhibitmagic);
1339 if (error) {
1340 /*
1341 * Once namei has started up, the existence of ni_erootdir
1342 * tells us whether we're working from an emulation root.
1343 * The TRYEMULROOT flag isn't necessarily authoritative.
1344 */
1345 if (ndp->ni_erootdir != NULL && state->attempt_retry) {
1346 /* Retry the whole thing using the normal root */
1347 cnp->cn_flags &= ~TRYEMULROOT;
1348 state->attempt_retry = 0;
1349
1350 /* kinda gross */
1351 strcpy(ndp->ni_pathbuf->pb_path, savepath);
1352 pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1353 savepath = NULL;
1354
1355 goto emul_retry;
1356 }
1357 }
1358 if (savepath != NULL) {
1359 pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1360 }
1361 return error;
1362 }
1363
1364 int
1365 namei(struct nameidata *ndp)
1366 {
1367 struct namei_state state;
1368 int error;
1369
1370 namei_init(&state, ndp);
1371 error = namei_tryemulroot(&state, NULL,
1372 0/*!neverfollow*/, 0/*!inhibitmagic*/);
1373 namei_cleanup(&state);
1374
1375 if (error) {
1376 /* make sure no stray refs leak out */
1377 KASSERT(ndp->ni_dvp == NULL);
1378 KASSERT(ndp->ni_vp == NULL);
1379 }
1380
1381 return error;
1382 }
1383
1384 ////////////////////////////////////////////////////////////
1385
1386 /*
1387 * Externally visible interfaces used by nfsd (bletch, yuk, XXX)
1388 *
1389 * The "index" version differs from the "main" version in that it's
1390 * called from a different place in a different context. For now I
1391 * want to be able to shuffle code in from one call site without
1392 * affecting the other.
1393 *
1394 * It turns out that the "main" version was a cut and pasted copy of
1395 * namei with a few changes; the "index" version on the other hand
1396 * always takes a single component and is an elaborate form of calling
1397 * VOP_LOOKUP once.
1398 */
1399
1400 int
1401 lookup_for_nfsd(struct nameidata *ndp, struct vnode *forcecwd, int neverfollow)
1402 {
1403 struct namei_state state;
1404 int error;
1405
1406 namei_init(&state, ndp);
1407 error = namei_tryemulroot(&state, forcecwd,
1408 neverfollow, 1/*inhibitmagic*/);
1409 namei_cleanup(&state);
1410
1411 if (error) {
1412 /* make sure no stray refs leak out */
1413 KASSERT(ndp->ni_dvp == NULL);
1414 KASSERT(ndp->ni_vp == NULL);
1415 }
1416
1417 return error;
1418 }
1419
1420 static int
1421 do_lookup_for_nfsd_index(struct namei_state *state, struct vnode *startdir)
1422 {
1423 int error = 0;
1424
1425 struct componentname *cnp = state->cnp;
1426 struct nameidata *ndp = state->ndp;
1427 struct vnode *foundobj;
1428 const char *cp; /* pointer into pathname argument */
1429
1430 KASSERT(cnp == &ndp->ni_cnd);
1431
1432 cnp->cn_nameptr = ndp->ni_pnbuf;
1433 state->docache = 1;
1434 state->rdonly = cnp->cn_flags & RDONLY;
1435 ndp->ni_dvp = NULL;
1436 cnp->cn_flags &= ~ISSYMLINK;
1437
1438 cnp->cn_consume = 0;
1439 cp = NULL;
1440 cnp->cn_hash = namei_hash(cnp->cn_nameptr, &cp);
1441 cnp->cn_namelen = cp - cnp->cn_nameptr;
1442 KASSERT(cnp->cn_namelen <= NAME_MAX);
1443 ndp->ni_pathlen -= cnp->cn_namelen;
1444 ndp->ni_next = cp;
1445 state->slashes = 0;
1446 cnp->cn_flags &= ~REQUIREDIR;
1447 cnp->cn_flags |= MAKEENTRY|ISLASTCN;
1448
1449 if (cnp->cn_namelen == 2 &&
1450 cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
1451 cnp->cn_flags |= ISDOTDOT;
1452 else
1453 cnp->cn_flags &= ~ISDOTDOT;
1454
1455 /*
1456 * Because lookup_once can change the startdir, we need our
1457 * own reference to it to avoid consuming the caller's.
1458 */
1459 vref(startdir);
1460 vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
1461 error = lookup_once(state, startdir, &startdir, &foundobj);
1462 vput(startdir);
1463 if (error) {
1464 goto bad;
1465 }
1466 ndp->ni_vp = foundobj;
1467
1468 if (foundobj == NULL) {
1469 return 0;
1470 }
1471
1472 KASSERT((cnp->cn_flags & LOCKPARENT) == 0);
1473 if ((cnp->cn_flags & LOCKLEAF) == 0) {
1474 VOP_UNLOCK(foundobj);
1475 }
1476 return (0);
1477
1478 bad:
1479 ndp->ni_vp = NULL;
1480 return (error);
1481 }
1482
1483 int
1484 lookup_for_nfsd_index(struct nameidata *ndp, struct vnode *startdir)
1485 {
1486 struct namei_state state;
1487 int error;
1488
1489 /*
1490 * Note: the name sent in here (is not|should not be) allowed
1491 * to contain a slash.
1492 */
1493 if (strlen(ndp->ni_pathbuf->pb_path) > NAME_MAX) {
1494 return ENAMETOOLONG;
1495 }
1496 if (strchr(ndp->ni_pathbuf->pb_path, '/')) {
1497 return EINVAL;
1498 }
1499
1500 ndp->ni_pathlen = strlen(ndp->ni_pathbuf->pb_path) + 1;
1501 ndp->ni_pnbuf = NULL;
1502 ndp->ni_cnd.cn_nameptr = NULL;
1503
1504 namei_init(&state, ndp);
1505 error = do_lookup_for_nfsd_index(&state, startdir);
1506 namei_cleanup(&state);
1507
1508 return error;
1509 }
1510
1511 ////////////////////////////////////////////////////////////
1512
1513 /*
1514 * Reacquire a path name component.
1515 * dvp is locked on entry and exit.
1516 * *vpp is locked on exit unless it's NULL.
1517 */
1518 int
1519 relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int dummy)
1520 {
1521 int rdonly; /* lookup read-only flag bit */
1522 int error = 0;
1523 #ifdef DEBUG
1524 uint32_t newhash; /* DEBUG: check name hash */
1525 const char *cp; /* DEBUG: check name ptr/len */
1526 #endif /* DEBUG */
1527
1528 (void)dummy;
1529
1530 /*
1531 * Setup: break out flag bits into variables.
1532 */
1533 rdonly = cnp->cn_flags & RDONLY;
1534 cnp->cn_flags &= ~ISSYMLINK;
1535
1536 /*
1537 * Search a new directory.
1538 *
1539 * The cn_hash value is for use by vfs_cache.
1540 * The last component of the filename is left accessible via
1541 * cnp->cn_nameptr for callers that need the name. Callers needing
1542 * the name set the SAVENAME flag. When done, they assume
1543 * responsibility for freeing the pathname buffer.
1544 */
1545 #ifdef DEBUG
1546 cp = NULL;
1547 newhash = namei_hash(cnp->cn_nameptr, &cp);
1548 if ((uint32_t)newhash != (uint32_t)cnp->cn_hash)
1549 panic("relookup: bad hash");
1550 if (cnp->cn_namelen != cp - cnp->cn_nameptr)
1551 panic("relookup: bad len");
1552 while (*cp == '/')
1553 cp++;
1554 if (*cp != 0)
1555 panic("relookup: not last component");
1556 #endif /* DEBUG */
1557
1558 /*
1559 * Check for degenerate name (e.g. / or "")
1560 * which is a way of talking about a directory,
1561 * e.g. like "/." or ".".
1562 */
1563 if (cnp->cn_nameptr[0] == '\0')
1564 panic("relookup: null name");
1565
1566 if (cnp->cn_flags & ISDOTDOT)
1567 panic("relookup: lookup on dot-dot");
1568
1569 /*
1570 * We now have a segment name to search for, and a directory to search.
1571 */
1572 cnp->cn_flags |= INRELOOKUP;
1573 error = VOP_LOOKUP(dvp, vpp, cnp);
1574 cnp->cn_flags &= ~INRELOOKUP;
1575 if ((error) != 0) {
1576 #ifdef DIAGNOSTIC
1577 if (*vpp != NULL)
1578 panic("leaf `%s' should be empty", cnp->cn_nameptr);
1579 #endif
1580 if (error != EJUSTRETURN)
1581 goto bad;
1582 }
1583
1584 #ifdef DIAGNOSTIC
1585 /*
1586 * Check for symbolic link
1587 */
1588 if (*vpp && (*vpp)->v_type == VLNK && (cnp->cn_flags & FOLLOW))
1589 panic("relookup: symlink found");
1590 #endif
1591
1592 /*
1593 * Check for read-only lookups.
1594 */
1595 if (rdonly && cnp->cn_nameiop != LOOKUP) {
1596 error = EROFS;
1597 if (*vpp) {
1598 vput(*vpp);
1599 }
1600 goto bad;
1601 }
1602 return (0);
1603
1604 bad:
1605 *vpp = NULL;
1606 return (error);
1607 }
1608
1609 /*
1610 * namei_simple - simple forms of namei.
1611 *
1612 * These are wrappers to allow the simple case callers of namei to be
1613 * left alone while everything else changes under them.
1614 */
1615
1616 /* Flags */
1617 struct namei_simple_flags_type {
1618 int dummy;
1619 };
1620 static const struct namei_simple_flags_type ns_nn, ns_nt, ns_fn, ns_ft;
1621 const namei_simple_flags_t NSM_NOFOLLOW_NOEMULROOT = &ns_nn;
1622 const namei_simple_flags_t NSM_NOFOLLOW_TRYEMULROOT = &ns_nt;
1623 const namei_simple_flags_t NSM_FOLLOW_NOEMULROOT = &ns_fn;
1624 const namei_simple_flags_t NSM_FOLLOW_TRYEMULROOT = &ns_ft;
1625
1626 static
1627 int
1628 namei_simple_convert_flags(namei_simple_flags_t sflags)
1629 {
1630 if (sflags == NSM_NOFOLLOW_NOEMULROOT)
1631 return NOFOLLOW | 0;
1632 if (sflags == NSM_NOFOLLOW_TRYEMULROOT)
1633 return NOFOLLOW | TRYEMULROOT;
1634 if (sflags == NSM_FOLLOW_NOEMULROOT)
1635 return FOLLOW | 0;
1636 if (sflags == NSM_FOLLOW_TRYEMULROOT)
1637 return FOLLOW | TRYEMULROOT;
1638 panic("namei_simple_convert_flags: bogus sflags\n");
1639 return 0;
1640 }
1641
1642 int
1643 namei_simple_kernel(const char *path, namei_simple_flags_t sflags,
1644 struct vnode **vp_ret)
1645 {
1646 struct nameidata nd;
1647 struct pathbuf *pb;
1648 int err;
1649
1650 pb = pathbuf_create(path);
1651 if (pb == NULL) {
1652 return ENOMEM;
1653 }
1654
1655 NDINIT(&nd,
1656 LOOKUP,
1657 namei_simple_convert_flags(sflags),
1658 pb);
1659 err = namei(&nd);
1660 if (err != 0) {
1661 pathbuf_destroy(pb);
1662 return err;
1663 }
1664 *vp_ret = nd.ni_vp;
1665 pathbuf_destroy(pb);
1666 return 0;
1667 }
1668
1669 int
1670 namei_simple_user(const char *path, namei_simple_flags_t sflags,
1671 struct vnode **vp_ret)
1672 {
1673 struct pathbuf *pb;
1674 struct nameidata nd;
1675 int err;
1676
1677 err = pathbuf_copyin(path, &pb);
1678 if (err) {
1679 return err;
1680 }
1681
1682 NDINIT(&nd,
1683 LOOKUP,
1684 namei_simple_convert_flags(sflags),
1685 pb);
1686 err = namei(&nd);
1687 if (err != 0) {
1688 pathbuf_destroy(pb);
1689 return err;
1690 }
1691 *vp_ret = nd.ni_vp;
1692 pathbuf_destroy(pb);
1693 return 0;
1694 }
1695