![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcfs_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / pcfs|
Return to pcfs_lookup.c CVS log | Up to [Net/2] / Net2 / pcfs |
1.1 root 1: /*
2: * Written by Paul Popelka ([email protected])
3: *
4: * You can do anything you want with this software,
5: * just don't say you wrote it,
6: * and don't remove this notice.
7: *
8: * This software is provided "as is".
9: *
10: * The author supplies this software to be publicly
11: * redistributed on the understanding that the author
12: * is not responsible for the correct functioning of
13: * this software in any circumstances and is not liable
14: * for any damages caused by this software.
15: *
16: * October 1992
17: *
18: * pcfs_lookup.c,v 1.3 1993/05/20 03:34:16 cgd Exp
19: */
20:
21: #include "param.h"
22: #include "namei.h"
23: #include "buf.h"
24: #include "vnode.h"
25: #include "mount.h"
26:
27: #include "bpb.h"
28: #include "direntry.h"
29: #include "denode.h"
30: #include "pcfsmount.h"
31: #include "fat.h"
32:
33: /*
34: * When we search a directory the blocks containing directory
35: * entries are read and examined. The directory entries
36: * contain information that would normally be in the inode
37: * of a unix filesystem. This means that some of a directory's
38: * contents may also be in memory resident denodes (sort of
39: * an inode). This can cause problems if we are searching
40: * while some other process is modifying a directory. To
41: * prevent one process from accessing incompletely modified
42: * directory information we depend upon being the soul owner
43: * of a directory block. bread/brelse provide this service.
44: * This being the case, when a process modifies a directory
45: * it must first acquire the disk block that contains the
46: * directory entry to be modified. Then update the disk
47: * block and the denode, and then write the disk block out
48: * to disk. This way disk blocks containing directory
49: * entries and in memory denode's will be in synch.
50: */
51: int
52: pcfs_lookup(vdp, ndp, p)
53: struct vnode *vdp; /* vnode of directory to search */
54: struct nameidata *ndp;
55: struct proc *p;
56: {
57: daddr_t bn;
58: int flag;
59: int error;
60: int lockparent;
61: int wantparent;
62: int slotstatus;
63: #define NONE 0
64: #define FOUND 1
65: int slotoffset;
66: int slotcluster;
67: int frcn;
68: u_long cluster;
69: int rootreloff;
70: int diroff;
71: int isadir; /* ~0 if found direntry is a directory */
72: u_long scn; /* starting cluster number */
73: struct denode *dp;
74: struct denode *pdp;
75: struct denode *tdp;
76: struct pcfsmount *pmp;
77: struct buf *bp = 0;
78: struct direntry *dep;
79: u_char dosfilename[12];
80:
81: #if defined(PCFSDEBUG)
82: printf("pcfs_lookup(): looking for %s\n", ndp->ni_ptr);
83: #endif /* defined(PCFSDEBUG) */
84: ndp->ni_dvp = vdp;
85: ndp->ni_vp = NULL;
86: dp = VTODE(vdp);
87: pmp = dp->de_pmp;
88: lockparent = ndp->ni_nameiop & LOCKPARENT;
89: flag = ndp->ni_nameiop & OPMASK;
90: wantparent = ndp->ni_nameiop & (LOCKPARENT | WANTPARENT);
91: #if defined(PCFSDEBUG)
92: printf("pcfs_lookup(): vdp %08x, dp %08x, Attr %02x\n",
93: vdp, dp, dp->de_Attributes);
94: #endif /* defined(PCFSDEBUG) */
95:
96: /*
97: * Be sure vdp is a directory. Since dos filesystems
98: * don't have the concept of execute permission anybody
99: * can search a directory.
100: */
101: if ((dp->de_Attributes & ATTR_DIRECTORY) == 0)
102: return ENOTDIR;
103:
104: /*
105: * See if the component of the pathname we are looking for
106: * is in the directory cache. If so then do a few things
107: * and return.
108: */
109: if (error = cache_lookup(ndp)) {
110: int vpid;
111:
112: if (error == ENOENT)
113: return error;
114: #ifdef PARANOID
115: if (vdp == ndp->ni_rdir && ndp->ni_isdotdot)
116: panic("pcfs_lookup: .. thru root");
117: #endif /* PARANOID */
118: pdp = dp;
119: vdp = ndp->ni_vp;
120: dp = VTODE(vdp);
121: vpid = vdp->v_id;
122: if (pdp == dp) {
123: VREF(vdp);
124: error = 0;
125: } else if (ndp->ni_isdotdot) {
126: DEUNLOCK(pdp);
127: error = vget(vdp);
128: if (!error && lockparent && *ndp->ni_next == '\0')
129: DELOCK(pdp);
130: } else {
131: error = vget(vdp);
132: if (!lockparent || error || *ndp->ni_next != '\0')
133: DEUNLOCK(pdp);
134: }
135:
136: if (!error) {
137: if (vpid == vdp->v_id) {
138: #if defined(PCFSDEBUG)
139: printf("pcfs_lookup(): cache hit, vnode %08x, file %s\n", vdp, dp->de_Name);
140: #endif /* defined(PCFSDEBUG) */
141: return 0;
142: }
143: deput(dp);
144: if (lockparent && pdp != dp && *ndp->ni_next == '\0')
145: DEUNLOCK(pdp);
146: }
147: DELOCK(pdp);
148: dp = pdp;
149: vdp = DETOV(dp);
150: ndp->ni_vp = NULL;
151: }
152:
153: /*
154: * If they are going after the . or .. entry in the
155: * root directory, they won't find it. DOS filesystems
156: * don't have them in the root directory. So, we fake it.
157: * deget() is in on this scam too.
158: */
159: if ((vdp->v_flag & VROOT) && ndp->ni_ptr[0] == '.' &&
160: (ndp->ni_namelen == 1 ||
161: (ndp->ni_namelen == 2 && ndp->ni_ptr[1] == '.'))) {
162: isadir = ATTR_DIRECTORY;
163: scn = PCFSROOT;
164: #if defined(PCFSDEBUG)
165: printf("pcfs_lookup(): looking for . or .. in root directory\n");
166: #endif /* defined(PCFSDEBUG) */
167: cluster == PCFSROOT;
168: diroff = PCFSROOT_OFS;
169: goto foundroot;
170: }
171:
172: /*
173: * Don't search for free slots unless we are creating
174: * a filename and we are at the end of the pathname.
175: */
176: slotstatus = FOUND;
177: if ((flag == CREATE || flag == RENAME) && *ndp->ni_next == '\0') {
178: slotstatus = NONE;
179: slotoffset = -1;
180: }
181:
182: unix2dosfn((u_char *)ndp->ni_ptr, dosfilename, ndp->ni_namelen);
183: dosfilename[11] = 0;
184: #if defined(PCFSDEBUG)
185: printf("pcfs_lookup(): dos version of filename %s, length %d\n",
186: dosfilename, ndp->ni_namelen);
187: #endif /* defined(PCFSDEBUG) */
188: /*
189: * Search the directory pointed at by vdp for the
190: * name pointed at by ndp->ni_ptr.
191: */
192: tdp = NULL;
193: /*
194: * The outer loop ranges over the clusters that make
195: * up the directory. Note that the root directory is
196: * different from all other directories. It has a
197: * fixed number of blocks that are not part of the
198: * pool of allocatable clusters. So, we treat it a
199: * little differently.
200: * The root directory starts at "cluster" 0.
201: */
202: rootreloff = 0;
203: for (frcn = 0; ; frcn++) {
204: if (error = pcbmap(dp, frcn, &bn, &cluster)) {
205: if (error == E2BIG)
206: break;
207: return error;
208: }
209: error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp);
210: if (error) {
211: brelse(bp);
212: return error;
213: }
214: dep = (struct direntry *)bp->b_un.b_addr;
215: for (diroff = 0; diroff < pmp->pm_depclust; diroff++, dep++) {
216: /*
217: * If the slot is empty and we are still looking for
218: * an empty then remember this one. If the slot is
219: * not empty then check to see if it matches what we
220: * are looking for. If the slot has never been filled
221: * with anything, then the remainder of the directory
222: * has never been used, so there is no point in searching
223: * it.
224: */
225: if (dep->deName[0] == SLOT_EMPTY ||
226: dep->deName[0] == SLOT_DELETED) {
227: if (slotstatus != FOUND) {
228: slotstatus = FOUND;
229: if (cluster == PCFSROOT)
230: slotoffset = rootreloff;
231: else
232: slotoffset = diroff;
233: slotcluster = cluster;
234: }
235: if (dep->deName[0] == SLOT_EMPTY) {
236: brelse(bp);
237: goto notfound;
238: }
239: } else {
240: /* Ignore volume labels (anywhere, not just
241: * the root directory). */
242: if ((dep->deAttributes & ATTR_VOLUME) == 0 &&
243: bcmp(dosfilename, dep->deName, 11) == 0) {
244: #if defined(PCFSDEBUG)
245: printf("pcfs_lookup(): match diroff %d, rootreloff %d\n", diroff, rootreloff);
246: #endif /* defined(PCFSDEBUG) */
247: /*
248: * Remember where this directory entry came from
249: * for whoever did this lookup.
250: * If this is the root directory we are interested
251: * in the offset relative to the beginning of the
252: * directory (not the beginning of the cluster).
253: */
254: if (cluster == PCFSROOT)
255: diroff = rootreloff;
256: ndp->ni_pcfs.pcfs_offset = diroff;
257: ndp->ni_pcfs.pcfs_cluster = cluster;
258: goto found;
259: }
260: }
261: rootreloff++;
262: } /* for (diroff = 0; .... */
263: /*
264: * Release the buffer holding the directory cluster
265: * just searched.
266: */
267: brelse(bp);
268: } /* for (frcn = 0; ; frcn++) */
269: notfound:;
270: /*
271: * We hold no disk buffers at this point.
272: */
273:
274: /*
275: * If we get here we didn't find the entry we were looking
276: * for. But that's ok if we are creating or renaming and
277: * are at the end of the pathname and the directory hasn't
278: * been removed.
279: */
280: #if defined(PCFSDEBUG)
281: printf("pcfs_lookup(): flag %d, refcnt %d, slotstatus %d\n",
282: flag, dp->de_refcnt, slotstatus);
283: printf(" slotoffset %d, slotcluster %d\n",
284: slotoffset, slotcluster);
285: #endif /* defined(PCFSDEBUG) */
286: if ((flag == CREATE || flag == RENAME) &&
287: *ndp->ni_next == '\0' && dp->de_refcnt != 0) {
288: if (slotstatus == NONE) {
289: ndp->ni_pcfs.pcfs_offset = 0;
290: ndp->ni_pcfs.pcfs_cluster = 0;
291: ndp->ni_pcfs.pcfs_count = 0;
292: } else {
293: #if defined(PCFSDEBUG)
294: printf("pcfs_lookup(): saving empty slot location\n");
295: #endif /* defined(PCFSDEBUG) */
296: ndp->ni_pcfs.pcfs_offset = slotoffset;
297: ndp->ni_pcfs.pcfs_cluster = slotcluster;
298: ndp->ni_pcfs.pcfs_count = 1;
299: }
300: /* dp->de_flag |= DEUPD; /* never update dos directories */
301: ndp->ni_nameiop |= SAVENAME;
302: if (!lockparent) /* leave searched dir locked? */
303: DEUNLOCK(dp);
304: }
305: /*
306: * Insert name in cache as non-existant if not
307: * trying to create it.
308: */
309: if (ndp->ni_makeentry && flag != CREATE)
310: cache_enter(ndp);
311: return ENOENT;
312:
313: found:;
314: /*
315: * NOTE: We still have the buffer with matched
316: * directory entry at this point.
317: */
318: isadir = dep->deAttributes & ATTR_DIRECTORY;
319: scn = dep->deStartCluster;
320:
321: foundroot:;
322: /*
323: * If we entered at foundroot, then we are looking
324: * for the . or .. entry of the filesystems root
325: * directory. isadir and scn were setup before
326: * jumping here. And, bp is null. There is no buf header.
327: */
328:
329: /*
330: * If deleting and at the end of the path, then
331: * if we matched on "." then don't deget() we would
332: * probably panic(). Otherwise deget() the directory
333: * entry.
334: */
335: if (flag == DELETE && ndp->ni_next == '\0') {
336: if (dp->de_StartCluster == scn &&
337: isadir) { /* "." */
338: VREF(vdp);
339: ndp->ni_vp = vdp;
340: if (bp) brelse(bp);
341: return 0;
342: }
343: error = deget(pmp, cluster, diroff, dep, &tdp);
344: if (error) {
345: if (bp) brelse(bp);
346: return error;
347: }
348: ndp->ni_vp = DETOV(tdp);
349: if (!lockparent)
350: DEUNLOCK(dp);
351: if (bp) brelse(bp);
352: return 0;
353: }
354:
355: /*
356: * If renaming.
357: */
358: if (flag == RENAME && wantparent && *ndp->ni_next == '\0') {
359: if (dp->de_StartCluster == scn &&
360: isadir) {
361: if (bp) brelse(bp);
362: return EISDIR;
363: }
364: error = deget(pmp, cluster, diroff, dep, &tdp);
365: if (error) {
366: if (bp) brelse(bp);
367: return error;
368: }
369: ndp->ni_vp = DETOV(tdp);
370: ndp->ni_nameiop |= SAVENAME;
371: if (!lockparent)
372: DEUNLOCK(dp);
373: if (bp) brelse(bp);
374: return 0;
375: }
376:
377: /*
378: * ?
379: */
380: pdp = dp;
381: if (ndp->ni_isdotdot) {
382: DEUNLOCK(pdp);
383: error = deget(pmp, cluster, diroff, dep, &tdp);
384: if (error) {
385: DELOCK(pdp);
386: if (bp) brelse(bp);
387: return error;
388: }
389: if (lockparent && *ndp->ni_next == '\0')
390: DELOCK(pdp);
391: ndp->ni_vp = DETOV(tdp);
392: } else if (dp->de_StartCluster == scn &&
393: isadir) { /* "." */
394: VREF(vdp);
395: ndp->ni_vp = vdp;
396: } else {
397: error = deget(pmp, cluster, diroff, dep, &tdp);
398: if (error) {
399: if (bp) brelse(bp);
400: return error;
401: }
402: if (!lockparent || *ndp->ni_next != '\0')
403: DEUNLOCK(pdp);
404: ndp->ni_vp = DETOV(tdp);
405: }
406: if (bp) brelse(bp);
407:
408: /*
409: * Insert name in cache if wanted.
410: */
411: if (ndp->ni_makeentry)
412: cache_enter(ndp);
413: return 0;
414: }
415:
416: /*
417: * dep - directory to copy into the directory
418: * ndp - nameidata structure containing info on
419: * where to put the directory entry in the directory.
420: * depp - return the address of the denode for the
421: * created directory entry if depp != 0
422: */
423: int
424: createde(dep, ndp, depp)
425: struct denode *dep;
426: struct nameidata *ndp;
427: struct denode **depp;
428: {
429: int bn;
430: int error;
431: u_long dirclust, diroffset;
432: struct direntry *ndep;
433: struct denode *ddep = VTODE(ndp->ni_dvp); /* directory to add to */
434: struct pcfsmount *pmp = dep->de_pmp;
435: struct buf *bp;
436: #if defined(PCFSDEBUG)
437: printf("createde(dep %08x, ndp %08x, depp %08x)\n", dep, ndp, depp);
438: #endif /* defined(PCFSDEBUG) */
439:
440: /*
441: * If no space left in the directory then allocate
442: * another cluster and chain it onto the end of the
443: * file. There is one exception to this. That is,
444: * if the root directory has no more space it can NOT
445: * be expanded. extendfile() checks for and fails attempts to
446: * extend the root directory. We just return an error
447: * in that case.
448: */
449: if (ndp->ni_pcfs.pcfs_count == 0) {
450: if (error = extendfile(ddep, &bp, &dirclust))
451: return error;
452: ndep = (struct direntry *)bp->b_un.b_addr;
453: /*
454: * Let caller know where we put the directory entry.
455: */
456: ndp->ni_pcfs.pcfs_cluster = dirclust;
457: ndp->ni_pcfs.pcfs_offset = diroffset = 0;
458: }
459:
460: else {
461: /*
462: * There is space in the existing directory. So,
463: * we just read in the cluster with space. Copy
464: * the new directory entry in. Then write it to
465: * disk.
466: * NOTE: DOS directories do not get smaller as
467: * clusters are emptied.
468: */
469: dirclust = ndp->ni_pcfs.pcfs_cluster;
470: diroffset = ndp->ni_pcfs.pcfs_offset;
471:
472: error = readep(pmp, dirclust, diroffset, &bp, &ndep);
473: if (error)
474: return error;
475: }
476: *ndep = dep->de_de;
477: /*
478: * If they want us to return with the denode gotten.
479: */
480: if (depp) {
481: error = deget(pmp, dirclust, diroffset, ndep, depp);
482: if (error)
483: return error;
484: }
485: if (error = bwrite(bp))
486: /*deput()?*/
487: return error;
488: return 0;
489: }
490:
491: /*
492: * Read in a directory entry and mark it as being deleted.
493: */
494: int
495: markdeleted(pmp, dirclust, diroffset)
496: struct pcfsmount *pmp;
497: u_long dirclust;
498: u_long diroffset;
499: {
500: int error;
501: struct direntry *ep;
502: struct buf *bp;
503:
504: error = readep(pmp, dirclust, diroffset, &bp, &ep);
505: if (error)
506: return error;
507: ep->deName[0] = SLOT_DELETED;
508: return bwrite(bp);
509: }
510:
511: /*
512: * Remove a directory entry.
513: * At this point the file represented by the directory
514: * entry to be removed is still full length until no
515: * one has it open. When the file no longer being
516: * used pcfs_inactive() is called and will truncate
517: * the file to 0 length. When the vnode containing
518: * the denode is needed for some other purpose by
519: * VFS it will call pcfs_reclaim() which will remove
520: * the denode from the denode cache.
521: */
522: int
523: removede(ndp)
524: struct nameidata *ndp;
525: {
526: struct denode *dep = VTODE(ndp->ni_vp); /* the file being removed */
527: struct pcfsmount *pmp = dep->de_pmp;
528: int error;
529:
530: #if defined(PCFSDEBUG)
531: /*printf("removede(): filename %s\n", dep->de_Name);
532: printf("rmde(): dep %08x, ndpcluster %d, ndpoffset %d\n",
533: dep, ndp->ni_pcfs.pcfs_cluster, ndp->ni_pcfs.pcfs_offset);*/
534: #endif /* defined(PCFSDEBUG) */
535:
536: /*
537: * Read the directory block containing the directory
538: * entry we are to make free. The nameidata structure
539: * holds the cluster number and directory entry index
540: * number of the entry to free.
541: */
542: error = markdeleted(pmp, ndp->ni_pcfs.pcfs_cluster,
543: ndp->ni_pcfs.pcfs_offset);
544:
545: dep->de_refcnt--;
546: return error;
547: }
548:
549: /*
550: * Be sure a directory is empty except for "." and "..".
551: * Return 1 if empty, return 0 if not empty or error.
552: */
553: int
554: dosdirempty(dep)
555: struct denode *dep;
556: {
557: int dei;
558: int error;
559: u_long cn;
560: daddr_t bn;
561: struct buf *bp;
562: struct pcfsmount *pmp = dep->de_pmp;
563: struct direntry *dentp;
564:
565: /*
566: * Since the filesize field in directory entries for a directory
567: * is zero, we just have to feel our way through the directory
568: * until we hit end of file.
569: */
570: for (cn = 0;; cn++) {
571: error = pcbmap(dep, cn, &bn, 0);
572: if (error == E2BIG)
573: return 1; /* it's empty */
574: error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED,
575: &bp);
576: if (error) {
577: brelse(bp);
578: return error;
579: }
580: dentp = (struct direntry *)bp->b_un.b_addr;
581: for (dei = 0; dei < pmp->pm_depclust; dei++) {
582: if (dentp->deName[0] != SLOT_DELETED) {
583: /*
584: * In dos directories an entry whose name starts with SLOT_EMPTY (0)
585: * starts the beginning of the unused part of the directory, so we
586: * can just return that it is empty.
587: */
588: if (dentp->deName[0] == SLOT_EMPTY) {
589: brelse(bp);
590: return 1;
591: }
592: /*
593: * Any names other than "." and ".." in a directory mean
594: * it is not empty.
595: */
596: if (bcmp(dentp->deName, ". ", 11) &&
597: bcmp(dentp->deName, ".. ", 11)) {
598: brelse(bp);
599: #if defined(PCFSDEBUG)
600: printf("dosdirempty(): entry %d found %02x, %02x\n", dei, dentp->deName[0],
601: dentp->deName[1]);
602: #endif /* defined(PCFSDEBUG) */
603: return 0; /* not empty */
604: }
605: }
606: dentp++;
607: }
608: brelse(bp);
609: }
610: /*NOTREACHED*/
611: }
612:
613: /*
614: * Check to see if the directory described by target is
615: * in some subdirectory of source. This prevents something
616: * like the following from succeeding and leaving a bunch
617: * or files and directories orphaned.
618: * mv /a/b/c /a/b/c/d/e/f
619: * Where c and f are directories.
620: * source - the inode for /a/b/c
621: * target - the inode for /a/b/c/d/e/f
622: * Returns 0 if target is NOT a subdirectory of source.
623: * Otherwise returns a non-zero error number.
624: * The target inode is always unlocked on return.
625: */
626: int
627: doscheckpath(source, target)
628: struct denode *source;
629: struct denode *target;
630: {
631: daddr_t scn;
632: struct denode dummy;
633: struct pcfsmount *pmp;
634: struct direntry *ep;
635: struct denode *dep;
636: struct buf *bp = NULL;
637: int error = 0;
638:
639: dep = target;
640: if ((target->de_Attributes & ATTR_DIRECTORY) == 0 ||
641: (source->de_Attributes & ATTR_DIRECTORY) == 0) {
642: error = ENOTDIR;
643: goto out;
644: }
645: if (dep->de_StartCluster == source->de_StartCluster) {
646: error = EEXIST;
647: goto out;
648: }
649: if (dep->de_StartCluster == PCFSROOT)
650: goto out;
651: for (;;) {
652: if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) {
653: error = ENOTDIR;
654: break;
655: }
656: pmp = dep->de_pmp;
657: scn = dep->de_StartCluster;
658: error = readep(pmp, scn, 1, &bp, &ep);
659: if (error)
660: break;
661: if ((ep->deAttributes & ATTR_DIRECTORY) == 0 ||
662: bcmp(ep->deName, ".. ", 11) != 0) {
663: /* Bad Directory */
664: error = ENOTDIR;
665: break;
666: }
667: if (ep->deStartCluster == source->de_StartCluster) {
668: error = EINVAL;
669: break;
670: }
671: if (ep->deStartCluster == PCFSROOT)
672: break;
673: deput(dep);
674: /* NOTE: deget() clears dep on error */
675: error = deget(pmp, ep->deStartCluster, 0, ep, &dep);
676: brelse(bp);
677: bp = NULL;
678: if (error)
679: break;
680: }
681: out:;
682: if (bp)
683: brelse(bp);
684: if (error == ENOTDIR)
685: printf("doscheckpath(): .. not a directory?\n");
686: if (dep != NULL)
687: deput(dep);
688: return error;
689: }
690:
691: /*
692: * Read in the disk block containing the directory entry
693: * (dirclu, dirofs) and return the address of the buf header,
694: * and the address of the directory entry within the block.
695: */
696: int
697: readep(pmp, dirclu, dirofs, bpp, epp)
698: struct pcfsmount *pmp;
699: u_long dirclu, dirofs;
700: struct buf **bpp;
701: struct direntry **epp;
702: {
703: int error;
704: daddr_t bn;
705:
706: bn = detobn(pmp, dirclu, dirofs);
707: if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, bpp)) {
708: brelse(*bpp);
709: *bpp = NULL;
710: return error;
711: }
712: if (epp)
713: *epp = bptoep(pmp, *bpp, dirofs);
714: return 0;
715: }
716:
717:
718: /*
719: * Read in the disk block containing the directory entry
720: * dep came from and return the address of the buf header,
721: * and the address of the directory entry within the block.
722: */
723: int
724: readde(dep, bpp, epp)
725: struct denode *dep;
726: struct buf **bpp;
727: struct direntry **epp;
728: {
729: return readep(dep->de_pmp, dep->de_dirclust, dep->de_diroffset,
730: bpp, epp);
731: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.