/*
 *  Written by Paul Popelka (paulp@uts.amdahl.com)
 *
 *  You can do anything you want with this software,
 *    just don't say you wrote it,
 *    and don't remove this notice.
 *
 *  This software is provided "as is".
 *
 *  The author supplies this software to be publicly
 *  redistributed on the understanding that the author
 *  is not responsible for the correct functioning of
 *  this software in any circumstances and is not liable
 *  for any damages caused by this software.
 *
 *  October 1992
 *
 *	$Id: pcfs_lookup.c,v 1.3 1993/05/20 03:34:16 cgd Exp $
 */

#include "param.h"
#include "namei.h"
#include "buf.h"
#include "vnode.h"
#include "mount.h"

#include "bpb.h"
#include "direntry.h"
#include "denode.h"
#include "pcfsmount.h"
#include "fat.h"

/*
 *  When we search a directory the blocks containing directory
 *  entries are read and examined.  The directory entries
 *  contain information that would normally be in the inode
 *  of a unix filesystem.  This means that some of a directory's
 *  contents may also be in memory resident denodes (sort of
 *  an inode).  This can cause problems if we are searching
 *  while some other process is modifying a directory.  To
 *  prevent one process from accessing incompletely modified
 *  directory information we depend upon being the soul owner
 *  of a directory block.  bread/brelse provide this service.
 *  This being the case, when a process modifies a directory
 *  it must first acquire the disk block that contains the
 *  directory entry to be modified.  Then update the disk
 *  block and the denode, and then write the disk block out
 *  to disk.  This way disk blocks containing directory
 *  entries and in memory denode's will be in synch.
 */
int
pcfs_lookup(vdp, ndp, p)
	struct vnode *vdp;	/* vnode of directory to search		*/
	struct nameidata *ndp;
	struct proc *p;
{
	daddr_t bn;
	int flag;
	int error;
	int lockparent;
	int wantparent;
	int slotstatus;
#define	NONE	0
#define	FOUND	1
	int slotoffset;
	int slotcluster;
	int frcn;
	u_long cluster;
	int rootreloff;
	int diroff;
	int isadir;		/* ~0 if found direntry is a directory	*/
	u_long scn;		/* starting cluster number		*/
	struct denode *dp;
	struct denode *pdp;
	struct denode *tdp;
	struct pcfsmount *pmp;
	struct buf *bp = 0;
	struct direntry *dep;
	u_char dosfilename[12];

#if defined(PCFSDEBUG)
printf("pcfs_lookup(): looking for %s\n", ndp->ni_ptr);
#endif /* defined(PCFSDEBUG) */
	ndp->ni_dvp = vdp;
	ndp->ni_vp  = NULL;
	dp = VTODE(vdp);
	pmp = dp->de_pmp;
	lockparent = ndp->ni_nameiop & LOCKPARENT;
	flag = ndp->ni_nameiop & OPMASK;
	wantparent = ndp->ni_nameiop & (LOCKPARENT | WANTPARENT);
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): vdp %08x, dp %08x, Attr %02x\n",
	vdp, dp, dp->de_Attributes);
#endif /* defined(PCFSDEBUG) */

/*
 *  Be sure vdp is a directory.  Since dos filesystems
 *  don't have the concept of execute permission anybody
 *  can search a directory.
 */
	if ((dp->de_Attributes & ATTR_DIRECTORY) == 0)
		return ENOTDIR;

/*
 *  See if the component of the pathname we are looking for
 *  is in the directory cache.  If so then do a few things
 *  and return.
 */
	if (error = cache_lookup(ndp)) {
		int vpid;

		if (error == ENOENT)
			return error;
#ifdef PARANOID
		if (vdp == ndp->ni_rdir  &&  ndp->ni_isdotdot)
			panic("pcfs_lookup: .. thru root");
#endif /* PARANOID */
		pdp = dp;
		vdp = ndp->ni_vp;
		dp  = VTODE(vdp);
		vpid = vdp->v_id;
		if (pdp == dp) {
			VREF(vdp);
			error = 0;
		} else if (ndp->ni_isdotdot) {
			DEUNLOCK(pdp);
			error = vget(vdp);
			if (!error && lockparent && *ndp->ni_next == '\0')
				DELOCK(pdp);
		} else {
			error = vget(vdp);
			if (!lockparent || error || *ndp->ni_next != '\0')
				DEUNLOCK(pdp);
		}

		if (!error) {
			if (vpid == vdp->v_id) {
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): cache hit, vnode %08x, file %s\n", vdp, dp->de_Name);
#endif /* defined(PCFSDEBUG) */
				return 0;
			}
			deput(dp);
			if (lockparent && pdp != dp && *ndp->ni_next == '\0')
				DEUNLOCK(pdp);
		}
		DELOCK(pdp);
		dp = pdp;
		vdp = DETOV(dp);
		ndp->ni_vp = NULL;
	}

/*
 *  If they are going after the . or .. entry in the
 *  root directory, they won't find it.  DOS filesystems
 *  don't have them in the root directory.  So, we fake it.
 *  deget() is in on this scam too.
 */
	if ((vdp->v_flag & VROOT)  &&  ndp->ni_ptr[0] == '.'  &&
	    (ndp->ni_namelen == 1  ||
	     (ndp->ni_namelen == 2  &&  ndp->ni_ptr[1] == '.'))) {
		isadir = ATTR_DIRECTORY;
		scn = PCFSROOT;
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): looking for . or .. in root directory\n");
#endif /* defined(PCFSDEBUG) */
		cluster == PCFSROOT;
		diroff = PCFSROOT_OFS;
		goto foundroot;
	}

/*
 *  Don't search for free slots unless we are creating
 *  a filename and we are at the end of the pathname.
 */
	slotstatus = FOUND;
	if ((flag == CREATE || flag == RENAME) && *ndp->ni_next == '\0') {
		slotstatus = NONE;
		slotoffset = -1;
	}

	unix2dosfn((u_char *)ndp->ni_ptr, dosfilename, ndp->ni_namelen);
	dosfilename[11] = 0;
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): dos version of filename %s, length %d\n",
	dosfilename, ndp->ni_namelen);
#endif /* defined(PCFSDEBUG) */
/*
 *  Search the directory pointed at by vdp for the
 *  name pointed at by ndp->ni_ptr.
 */
	tdp = NULL;
/*
 *  The outer loop ranges over the clusters that make
 *  up the directory.  Note that the root directory is
 *  different from all other directories.  It has a
 *  fixed number of blocks that are not part of the
 *  pool of allocatable clusters.  So, we treat it a
 *  little differently.
 *  The root directory starts at "cluster" 0.
 */
	rootreloff = 0;
	for (frcn = 0; ; frcn++) {
		if (error = pcbmap(dp, frcn, &bn, &cluster)) {
			if (error == E2BIG)
				break;
			return error;
		}
		error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp);
		if (error) {
			brelse(bp);
			return error;
		}
		dep = (struct direntry *)bp->b_un.b_addr;
		for (diroff = 0; diroff < pmp->pm_depclust; diroff++, dep++) {
/*
 *  If the slot is empty and we are still looking for
 *  an empty then remember this one.  If the slot is
 *  not empty then check to see if it matches what we
 *  are looking for.  If the slot has never been filled
 *  with anything, then the remainder of the directory
 *  has never been used, so there is no point in searching
 *  it.
 */
			if (dep->deName[0] == SLOT_EMPTY   ||
			    dep->deName[0] == SLOT_DELETED) {
				if (slotstatus != FOUND) {
					slotstatus  = FOUND;
					if (cluster == PCFSROOT)
						slotoffset = rootreloff;
					else
						slotoffset = diroff;
					slotcluster = cluster;
				}
				if (dep->deName[0] == SLOT_EMPTY) {
					brelse(bp);
					goto notfound;
				}
			} else {
				/* Ignore volume labels (anywhere, not just
				 * the root directory). */
				if ((dep->deAttributes & ATTR_VOLUME) == 0  &&
				    bcmp(dosfilename, dep->deName, 11) == 0) {
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): match diroff %d, rootreloff %d\n", diroff, rootreloff);
#endif /* defined(PCFSDEBUG) */
/*
 *  Remember where this directory entry came from
 *  for whoever did this lookup.
 *  If this is the root directory we are interested
 *  in the offset relative to the beginning of the
 *  directory (not the beginning of the cluster).
 */
					if (cluster == PCFSROOT)
						diroff = rootreloff;
					ndp->ni_pcfs.pcfs_offset = diroff;
					ndp->ni_pcfs.pcfs_cluster = cluster;
					goto found;
				}
			}
			rootreloff++;
		}			/* for (diroff = 0; .... */
/*
 *  Release the buffer holding the directory cluster
 *  just searched.
 */
		brelse(bp);
	}			/* for (frcn = 0; ; frcn++) */
notfound:;
/*
 *  We hold no disk buffers at this point.
 */

/*
 *  If we get here we didn't find the entry we were looking
 *  for.  But that's ok if we are creating or renaming and
 *  are at the end of the pathname and the directory hasn't
 *  been removed.
 */
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): flag %d, refcnt %d, slotstatus %d\n",
	flag, dp->de_refcnt, slotstatus);
printf("               slotoffset %d, slotcluster %d\n",
	slotoffset, slotcluster);
#endif /* defined(PCFSDEBUG) */
	if ((flag == CREATE || flag == RENAME)  &&
	    *ndp->ni_next == '\0' && dp->de_refcnt != 0) {
		if (slotstatus == NONE) {
			ndp->ni_pcfs.pcfs_offset  = 0;
			ndp->ni_pcfs.pcfs_cluster = 0;
			ndp->ni_pcfs.pcfs_count   = 0;
		} else {
#if defined(PCFSDEBUG)
printf("pcfs_lookup(): saving empty slot location\n");
#endif /* defined(PCFSDEBUG) */
			ndp->ni_pcfs.pcfs_offset  = slotoffset;
			ndp->ni_pcfs.pcfs_cluster = slotcluster;
			ndp->ni_pcfs.pcfs_count   = 1;
		}
/*		dp->de_flag |= DEUPD; /* never update dos directories */
		ndp->ni_nameiop |= SAVENAME;
		if (!lockparent)	/* leave searched dir locked?	*/
			DEUNLOCK(dp);
	}
/*
 *  Insert name in cache as non-existant if not
 *  trying to create it.
 */
	if (ndp->ni_makeentry && flag != CREATE)
		cache_enter(ndp);
	return ENOENT;

found:;
/*
 *  NOTE:  We still have the buffer with matched
 *  directory entry at this point.
 */
	isadir = dep->deAttributes & ATTR_DIRECTORY;
	scn = dep->deStartCluster;

foundroot:;
/*
 *  If we entered at foundroot, then we are looking
 *  for the . or .. entry of the filesystems root
 *  directory.  isadir and scn were setup before
 *  jumping here.  And, bp is null.  There is no buf header.
 */

/*
 *  If deleting and at the end of the path, then
 *  if we matched on "." then don't deget() we would
 *  probably panic().  Otherwise deget() the directory
 *  entry.
 */
	if (flag == DELETE && ndp->ni_next == '\0') {
		if (dp->de_StartCluster == scn  &&
		    isadir) { /* "." */
			VREF(vdp);
			ndp->ni_vp = vdp;
			if (bp) brelse(bp);
			return 0;
		}
		error = deget(pmp, cluster, diroff, dep, &tdp);
		if (error) {
			if (bp) brelse(bp);
			return error;
		}
		ndp->ni_vp = DETOV(tdp);
		if (!lockparent)
			DEUNLOCK(dp);
		if (bp) brelse(bp);
		return 0;
	}

/*
 *  If renaming.
 */
	if (flag == RENAME && wantparent && *ndp->ni_next == '\0') {
		if (dp->de_StartCluster == scn  &&
		    isadir) {
			if (bp) brelse(bp);
			return EISDIR;
		}
		error = deget(pmp, cluster, diroff, dep, &tdp);
		if (error) {
			if (bp) brelse(bp);
			return error;
		}
		ndp->ni_vp = DETOV(tdp);
		ndp->ni_nameiop |= SAVENAME;
		if (!lockparent)
			DEUNLOCK(dp);
		if (bp) brelse(bp);
		return 0;
	}

/*
 *  ?
 */
	pdp = dp;
	if (ndp->ni_isdotdot) {
		DEUNLOCK(pdp);
		error = deget(pmp, cluster, diroff, dep, &tdp);
		if (error) {
			DELOCK(pdp);
			if (bp) brelse(bp);
			return error;
		}
		if (lockparent && *ndp->ni_next == '\0')
			DELOCK(pdp);
		ndp->ni_vp = DETOV(tdp);
	} else if (dp->de_StartCluster == scn  &&
		   isadir) { /* "." */
		VREF(vdp);
		ndp->ni_vp = vdp;
	} else {
		error = deget(pmp, cluster, diroff, dep, &tdp);
		if (error) {
			if (bp) brelse(bp);
			return error;
		}
		if (!lockparent || *ndp->ni_next != '\0')
			DEUNLOCK(pdp);
		ndp->ni_vp = DETOV(tdp);
	}
	if (bp) brelse(bp);

/*
 *  Insert name in cache if wanted.
 */
	if (ndp->ni_makeentry)
		cache_enter(ndp);
	return 0;
}

/*
 *  dep - directory to copy into the directory
 *  ndp - nameidata structure containing info on
 *    where to put the directory entry in the directory.
 *  depp - return the address of the denode for the
 *    created directory entry if depp != 0
 */
int
createde(dep, ndp, depp)
	struct denode *dep;
	struct nameidata *ndp;
	struct denode **depp;
{
	int bn;
	int error;
	u_long dirclust, diroffset;
	struct direntry *ndep;
	struct denode *ddep = VTODE(ndp->ni_dvp);	/* directory to add to */
	struct pcfsmount *pmp = dep->de_pmp;
	struct buf *bp;
#if defined(PCFSDEBUG)
printf("createde(dep %08x, ndp %08x, depp %08x)\n", dep, ndp, depp);
#endif /* defined(PCFSDEBUG) */

/*
 *  If no space left in the directory then allocate
 *  another cluster and chain it onto the end of the
 *  file.  There is one exception to this.  That is,
 *  if the root directory has no more space it can NOT
 *  be expanded.  extendfile() checks for and fails attempts to
 *  extend the root directory.  We just return an error
 *  in that case.
 */
	if (ndp->ni_pcfs.pcfs_count == 0) {
		if (error = extendfile(ddep, &bp, &dirclust))
			return error;
		ndep = (struct direntry *)bp->b_un.b_addr;
/*
 *  Let caller know where we put the directory entry.
 */
		ndp->ni_pcfs.pcfs_cluster = dirclust;
		ndp->ni_pcfs.pcfs_offset  = diroffset = 0;
	}

	else {
/*
 *  There is space in the existing directory.  So,
 *  we just read in the cluster with space.  Copy
 *  the new directory entry in.  Then write it to
 *  disk.
 *  NOTE:  DOS directories do not get smaller as
 *  clusters are emptied.
 */
		dirclust = ndp->ni_pcfs.pcfs_cluster;
		diroffset = ndp->ni_pcfs.pcfs_offset;

		error = readep(pmp, dirclust, diroffset, &bp, &ndep);
		if (error)
			return error;
	}
	*ndep = dep->de_de;
/*
 *  If they want us to return with the denode gotten.
 */
	if (depp) {
		error = deget(pmp, dirclust, diroffset, ndep, depp);
		if (error)
			return error;
	}
	if (error = bwrite(bp))
/*deput()?*/
		return error;
	return 0;
}

/*
 *  Read in a directory entry and mark it as being deleted.
 */
int
markdeleted(pmp, dirclust, diroffset)
	struct pcfsmount *pmp;
	u_long dirclust;
	u_long diroffset;
{
	int error;
	struct direntry *ep;
	struct buf *bp;

	error = readep(pmp, dirclust, diroffset, &bp, &ep);
	if (error)
		return error;
	ep->deName[0] = SLOT_DELETED;
	return bwrite(bp);
}

/*
 *  Remove a directory entry.
 *  At this point the file represented by the directory
 *  entry to be removed is still full length until no
 *  one has it open.  When the file no longer being
 *  used pcfs_inactive() is called and will truncate
 *  the file to 0 length.  When the vnode containing
 *  the denode is needed for some other purpose by 
 *  VFS it will call pcfs_reclaim() which will remove
 *  the denode from the denode cache.
 */
int
removede(ndp)
	struct nameidata *ndp;
{
	struct denode *dep = VTODE(ndp->ni_vp);	/* the file being removed */
	struct pcfsmount *pmp = dep->de_pmp;
	int error;

#if defined(PCFSDEBUG)
/*printf("removede(): filename %s\n", dep->de_Name);
printf("rmde(): dep %08x, ndpcluster %d, ndpoffset %d\n",
	dep, ndp->ni_pcfs.pcfs_cluster, ndp->ni_pcfs.pcfs_offset);*/
#endif /* defined(PCFSDEBUG) */

/*
 *  Read the directory block containing the directory
 *  entry we are to make free.  The nameidata structure
 *  holds the cluster number and directory entry index
 *  number of the entry to free.
 */
	error = markdeleted(pmp, ndp->ni_pcfs.pcfs_cluster,
		ndp->ni_pcfs.pcfs_offset);

	dep->de_refcnt--;
	return error;
}

/*
 *  Be sure a directory is empty except for "." and "..".
 *  Return 1 if empty, return 0 if not empty or error.
 */
int
dosdirempty(dep)
	struct denode *dep;
{
	int dei;
	int error;
	u_long cn;
	daddr_t bn;
	struct buf *bp;
	struct pcfsmount *pmp = dep->de_pmp;
	struct direntry *dentp;

/*
 *  Since the filesize field in directory entries for a directory
 *  is zero, we just have to feel our way through the directory
 *  until we hit end of file.
 */
	for (cn = 0;; cn++) {
		error = pcbmap(dep, cn, &bn, 0);
		if (error == E2BIG)
			return 1;	/* it's empty */
		error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED,
			&bp);
		if (error) {
			brelse(bp);
			return error;
		}
		dentp = (struct direntry *)bp->b_un.b_addr;
		for (dei = 0; dei < pmp->pm_depclust; dei++) {
			if (dentp->deName[0] != SLOT_DELETED) {
/*
 *  In dos directories an entry whose name starts with SLOT_EMPTY (0)
 *  starts the beginning of the unused part of the directory, so we
 *  can just return that it is empty.
 */
				if (dentp->deName[0] == SLOT_EMPTY) {
					brelse(bp);
					return 1;
				}
/*
 *  Any names other than "." and ".." in a directory mean
 *  it is not empty.
 */
				if (bcmp(dentp->deName, ".          ", 11)  &&
				    bcmp(dentp->deName, "..         ", 11)) {
					brelse(bp);
#if defined(PCFSDEBUG)
printf("dosdirempty(): entry %d found %02x, %02x\n", dei, dentp->deName[0],
	dentp->deName[1]);
#endif /* defined(PCFSDEBUG) */
					return 0;	/* not empty */
				}
			}
			dentp++;
		}
		brelse(bp);
	}
	/*NOTREACHED*/
}

/*
 *  Check to see if the directory described by target is
 *  in some subdirectory of source.  This prevents something
 *  like the following from succeeding and leaving a bunch
 *  or files and directories orphaned.
 *	mv /a/b/c /a/b/c/d/e/f
 *  Where c and f are directories.
 *  source - the inode for /a/b/c
 *  target - the inode for /a/b/c/d/e/f
 *  Returns 0 if target is NOT a subdirectory of source.
 *  Otherwise returns a non-zero error number.
 *  The target inode is always unlocked on return.
 */
int
doscheckpath(source, target)
	struct denode *source;
	struct denode *target;
{
	daddr_t scn;
	struct denode dummy;
	struct pcfsmount *pmp;
	struct direntry *ep;
	struct denode *dep;
	struct buf *bp = NULL;
	int error = 0;

	dep = target;
	if ((target->de_Attributes & ATTR_DIRECTORY) == 0  ||
	    (source->de_Attributes & ATTR_DIRECTORY) == 0) {
		error = ENOTDIR;
		goto out;
	}
	if (dep->de_StartCluster == source->de_StartCluster) {
		error = EEXIST;
		goto out;
	}
	if (dep->de_StartCluster == PCFSROOT)
		goto out;
	for (;;) {
		if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) {
			error = ENOTDIR;
			break;
		}
		pmp = dep->de_pmp;
		scn = dep->de_StartCluster;
		error = readep(pmp, scn, 1, &bp, &ep);
		if (error)
			break;
		if ((ep->deAttributes & ATTR_DIRECTORY) == 0  ||
		    bcmp(ep->deName, "..         ", 11) != 0) {
			/* Bad Directory */
			error = ENOTDIR;
			break;
		}
		if (ep->deStartCluster == source->de_StartCluster) {
			error = EINVAL;
			break;
		}
		if (ep->deStartCluster == PCFSROOT)
			break;
		deput(dep);
		/* NOTE: deget() clears dep on error */
		error = deget(pmp, ep->deStartCluster, 0, ep, &dep);
		brelse(bp);
		bp = NULL;
		if (error)
			break;
	}
out:;
	if (bp)
		brelse(bp);
	if (error == ENOTDIR)
		printf("doscheckpath(): .. not a directory?\n");
	if (dep != NULL)
		deput(dep);
	return error;
}

/*
 *  Read in the disk block containing the directory entry
 *  (dirclu, dirofs) and return the address of the buf header,
 *  and the address of the directory entry within the block.
 */
int
readep(pmp, dirclu, dirofs, bpp, epp)
	struct pcfsmount *pmp;
	u_long dirclu, dirofs;
	struct buf **bpp;
	struct direntry **epp;
{
	int error;
	daddr_t bn;

	bn = detobn(pmp, dirclu, dirofs);
	if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, bpp)) {
		brelse(*bpp);
		*bpp = NULL;
		return error;
	}
	if (epp)
		*epp = bptoep(pmp, *bpp, dirofs);
	return 0;
}


/*
 *  Read in the disk block containing the directory entry
 *  dep came from and return the address of the buf header,
 *  and the address of the directory entry within the block.
 */
int
readde(dep, bpp, epp)
	struct denode *dep;
	struct buf **bpp;
	struct direntry **epp;
{
	return readep(dep->de_pmp, dep->de_dirclust, dep->de_diroffset,
		      bpp, epp);
}