File:  [DragonFly] / src / sys / vfs / ntfs / ntfs_subr.c
Revision 1.12: download - view: text, annotated - select for diffs
Tue Apr 20 19:59:30 2004 UTC (10 years, 4 months ago) by cpressey
Branches: MAIN
CVS tags: HEAD
Style(9) cleanup to src/sys/vfs, stage 11/21: ntfs.

- Convert K&R-style function definitions to ANSI style.

Submitted-by: Andre Nathan <andre@digirati.com.br>
Additional-reformatting-by: cpressey

    1: /*	$NetBSD: ntfs_subr.c,v 1.23 1999/10/31 19:45:26 jdolecek Exp $	*/
    2: 
    3: /*-
    4:  * Copyright (c) 1998, 1999 Semen Ustimenko (semenu@FreeBSD.org)
    5:  * All rights reserved.
    6:  *
    7:  * Redistribution and use in source and binary forms, with or without
    8:  * modification, are permitted provided that the following conditions
    9:  * are met:
   10:  * 1. Redistributions of source code must retain the above copyright
   11:  *    notice, this list of conditions and the following disclaimer.
   12:  * 2. Redistributions in binary form must reproduce the above copyright
   13:  *    notice, this list of conditions and the following disclaimer in the
   14:  *    documentation and/or other materials provided with the distribution.
   15:  *
   16:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26:  * SUCH DAMAGE.
   27:  *
   28:  * $FreeBSD: src/sys/ntfs/ntfs_subr.c,v 1.7.2.4 2001/10/12 22:08:49 semenu Exp $
   29:  * $DragonFly: src/sys/vfs/ntfs/ntfs_subr.c,v 1.12 2004/04/20 19:59:30 cpressey Exp $
   30:  */
   31: 
   32: #include <sys/param.h>
   33: #include <sys/types.h>
   34: #include <sys/systm.h>
   35: #include <sys/proc.h>
   36: #include <sys/namei.h>
   37: #include <sys/kernel.h>
   38: #include <sys/vnode.h>
   39: #include <sys/mount.h>
   40: #include <sys/buf.h>
   41: #include <sys/file.h>
   42: #include <sys/malloc.h>
   43: #include <sys/lock.h>
   44: 
   45: #if defined(__NetBSD__)
   46: #include <miscfs/specfs/specdev.h>
   47: #endif
   48: 
   49: /* #define NTFS_DEBUG 1 */
   50: #include "ntfs.h"
   51: #include "ntfsmount.h"
   52: #include "ntfs_inode.h"
   53: #include "ntfs_vfsops.h"
   54: #include "ntfs_subr.h"
   55: #include "ntfs_compr.h"
   56: #include "ntfs_ihash.h"
   57: 
   58: #if defined(__DragonFly__)
   59: MALLOC_DEFINE(M_NTFSNTVATTR, "NTFS vattr", "NTFS file attribute information");
   60: MALLOC_DEFINE(M_NTFSRDATA, "NTFS res data", "NTFS resident data");
   61: MALLOC_DEFINE(M_NTFSRUN, "NTFS vrun", "NTFS vrun storage");
   62: MALLOC_DEFINE(M_NTFSDECOMP, "NTFS decomp", "NTFS decompression temporary");
   63: #endif
   64: 
   65: static int ntfs_ntlookupattr (struct ntfsmount *, const char *, int, int *, char **);
   66: static int ntfs_findvattr (struct ntfsmount *, struct ntnode *, struct ntvattr **, struct ntvattr **, u_int32_t, const char *, size_t, cn_t);
   67: static int ntfs_uastricmp (struct ntfsmount *, const wchar *, size_t, const char *, size_t);
   68: static int ntfs_uastrcmp (struct ntfsmount *, const wchar *, size_t, const char *, size_t);
   69: 
   70: /* table for mapping Unicode chars into uppercase; it's filled upon first
   71:  * ntfs mount, freed upon last ntfs umount */
   72: static wchar *ntfs_toupper_tab;
   73: #define NTFS_TOUPPER(ch)	(ntfs_toupper_tab[(ch)])
   74: static struct lock ntfs_toupper_lock;
   75: static signed int ntfs_toupper_usecount;
   76: 
   77: /* support macro for ntfs_ntvattrget() */
   78: #define NTFS_AALPCMP(aalp,type,name,namelen) (				\
   79:   (aalp->al_type == type) && (aalp->al_namelen == namelen) &&		\
   80:   !NTFS_UASTRCMP(aalp->al_name,aalp->al_namelen,name,namelen) )
   81: 
   82: /*
   83:  * 
   84:  */
   85: int
   86: ntfs_ntvattrrele(struct ntvattr *vap)
   87: {
   88: 	dprintf(("ntfs_ntvattrrele: ino: %d, type: 0x%x\n",
   89: 		 vap->va_ip->i_number, vap->va_type));
   90: 
   91: 	ntfs_ntrele(vap->va_ip);
   92: 
   93: 	return (0);
   94: }
   95: 
   96: /*
   97:  * find the attribute in the ntnode
   98:  */
   99: static int
  100: ntfs_findvattr(struct ntfsmount *ntmp, struct ntnode *ip,
  101: 	       struct ntvattr **lvapp, struct ntvattr **vapp, u_int32_t type,
  102: 	       const char *name, size_t namelen, cn_t vcn)
  103: {
  104: 	int error;
  105: 	struct ntvattr *vap;
  106: 
  107: 	if((ip->i_flag & IN_LOADED) == 0) {
  108: 		dprintf(("ntfs_findvattr: node not loaded, ino: %d\n",
  109: 		       ip->i_number));
  110: 		error = ntfs_loadntnode(ntmp,ip);
  111: 		if (error) {
  112: 			printf("ntfs_findvattr: FAILED TO LOAD INO: %d\n",
  113: 			       ip->i_number);
  114: 			return (error);
  115: 		}
  116: 	}
  117: 
  118: 	*lvapp = NULL;
  119: 	*vapp = NULL;
  120: 	for (vap = ip->i_valist.lh_first; vap; vap = vap->va_list.le_next) {
  121: 		ddprintf(("ntfs_findvattr: type: 0x%x, vcn: %d - %d\n", \
  122: 			  vap->va_type, (u_int32_t) vap->va_vcnstart, \
  123: 			  (u_int32_t) vap->va_vcnend));
  124: 		if ((vap->va_type == type) &&
  125: 		    (vap->va_vcnstart <= vcn) && (vap->va_vcnend >= vcn) &&
  126: 		    (vap->va_namelen == namelen) &&
  127: 		    (strncmp(name, vap->va_name, namelen) == 0)) {
  128: 			*vapp = vap;
  129: 			ntfs_ntref(vap->va_ip);
  130: 			return (0);
  131: 		}
  132: 		if (vap->va_type == NTFS_A_ATTRLIST)
  133: 			*lvapp = vap;
  134: 	}
  135: 
  136: 	return (-1);
  137: }
  138: 
  139: /*
  140:  * Search attribute specifed in ntnode (load ntnode if nessecary).
  141:  * If not found but ATTR_A_ATTRLIST present, read it in and search throught.
  142:  * VOP_VGET node needed, and lookup througth it's ntnode (load if nessesary).
  143:  *
  144:  * ntnode should be locked
  145:  */
  146: int
  147: ntfs_ntvattrget(struct ntfsmount *ntmp, struct ntnode *ip, u_int32_t type,
  148: 		const char *name, cn_t vcn, struct ntvattr **vapp)
  149: {
  150: 	struct ntvattr *lvap = NULL;
  151: 	struct attr_attrlist *aalp;
  152: 	struct attr_attrlist *nextaalp;
  153: 	struct vnode   *newvp;
  154: 	struct ntnode  *newip;
  155: 	caddr_t         alpool;
  156: 	size_t		namelen, len;
  157: 	int             error;
  158: 
  159: 	*vapp = NULL;
  160: 
  161: 	if (name) {
  162: 		dprintf(("ntfs_ntvattrget: " \
  163: 			 "ino: %d, type: 0x%x, name: %s, vcn: %d\n", \
  164: 			 ip->i_number, type, name, (u_int32_t) vcn));
  165: 		namelen = strlen(name);
  166: 	} else {
  167: 		dprintf(("ntfs_ntvattrget: " \
  168: 			 "ino: %d, type: 0x%x, vcn: %d\n", \
  169: 			 ip->i_number, type, (u_int32_t) vcn));
  170: 		name = "";
  171: 		namelen = 0;
  172: 	}
  173: 
  174: 	error = ntfs_findvattr(ntmp, ip, &lvap, vapp, type, name, namelen, vcn);
  175: 	if (error >= 0)
  176: 		return (error);
  177: 
  178: 	if (!lvap) {
  179: 		dprintf(("ntfs_ntvattrget: UNEXISTED ATTRIBUTE: " \
  180: 		       "ino: %d, type: 0x%x, name: %s, vcn: %d\n", \
  181: 		       ip->i_number, type, name, (u_int32_t) vcn));
  182: 		return (ENOENT);
  183: 	}
  184: 	/* Scan $ATTRIBUTE_LIST for requested attribute */
  185: 	len = lvap->va_datalen;
  186: 	MALLOC(alpool, caddr_t, len, M_TEMP, M_WAITOK);
  187: 	error = ntfs_readntvattr_plain(ntmp, ip, lvap, 0, len, alpool, &len,
  188: 			NULL);
  189: 	if (error)
  190: 		goto out;
  191: 
  192: 	aalp = (struct attr_attrlist *) alpool;
  193: 	nextaalp = NULL;
  194: 
  195: 	for(; len > 0; aalp = nextaalp) {
  196: 		dprintf(("ntfs_ntvattrget: " \
  197: 			 "attrlist: ino: %d, attr: 0x%x, vcn: %d\n", \
  198: 			 aalp->al_inumber, aalp->al_type, \
  199: 			 (u_int32_t) aalp->al_vcnstart));
  200: 
  201: 		if (len > aalp->reclen) {
  202: 			nextaalp = NTFS_NEXTREC(aalp, struct attr_attrlist *);
  203: 		} else {
  204: 			nextaalp = NULL;
  205: 		}
  206: 		len -= aalp->reclen;
  207: 
  208: 		if (!NTFS_AALPCMP(aalp, type, name, namelen) ||
  209: 		    (nextaalp && (nextaalp->al_vcnstart <= vcn) &&
  210: 		     NTFS_AALPCMP(nextaalp, type, name, namelen)))
  211: 			continue;
  212: 
  213: 		dprintf(("ntfs_ntvattrget: attribute in ino: %d\n",
  214: 				 aalp->al_inumber));
  215: 
  216: 		/* this is not a main record, so we can't use just plain
  217: 		   vget() */
  218: 		error = ntfs_vgetex(ntmp->ntm_mountp, aalp->al_inumber,
  219: 				NTFS_A_DATA, NULL, LK_EXCLUSIVE,
  220: 				VG_EXT, curthread, &newvp);
  221: 		if (error) {
  222: 			printf("ntfs_ntvattrget: CAN'T VGET INO: %d\n",
  223: 			       aalp->al_inumber);
  224: 			goto out;
  225: 		}
  226: 		newip = VTONT(newvp);
  227: 		/* XXX have to lock ntnode */
  228: 		error = ntfs_findvattr(ntmp, newip, &lvap, vapp,
  229: 				type, name, namelen, vcn);
  230: 		vput(newvp);
  231: 		if (error == 0)
  232: 			goto out;
  233: 		printf("ntfs_ntvattrget: ATTRLIST ERROR.\n");
  234: 		break;
  235: 	}
  236: 	error = ENOENT;
  237: 
  238: 	dprintf(("ntfs_ntvattrget: UNEXISTED ATTRIBUTE: " \
  239: 	       "ino: %d, type: 0x%x, name: %.*s, vcn: %d\n", \
  240: 	       ip->i_number, type, (int) namelen, name, (u_int32_t) vcn));
  241: out:
  242: 	FREE(alpool, M_TEMP);
  243: 	return (error);
  244: }
  245: 
  246: /*
  247:  * Read ntnode from disk, make ntvattr list.
  248:  *
  249:  * ntnode should be locked
  250:  */
  251: int
  252: ntfs_loadntnode(struct ntfsmount *ntmp, struct ntnode *ip)
  253: {
  254: 	struct filerec  *mfrp;
  255: 	daddr_t         bn;
  256: 	int		error,off;
  257: 	struct attr    *ap;
  258: 	struct ntvattr *nvap;
  259: 
  260: 	dprintf(("ntfs_loadntnode: loading ino: %d\n",ip->i_number));
  261: 
  262: 	MALLOC(mfrp, struct filerec *, ntfs_bntob(ntmp->ntm_bpmftrec),
  263: 	       M_TEMP, M_WAITOK);
  264: 
  265: 	if (ip->i_number < NTFS_SYSNODESNUM) {
  266: 		struct buf     *bp;
  267: 
  268: 		dprintf(("ntfs_loadntnode: read system node\n"));
  269: 
  270: 		bn = ntfs_cntobn(ntmp->ntm_mftcn) +
  271: 			ntmp->ntm_bpmftrec * ip->i_number;
  272: 
  273: 		error = bread(ntmp->ntm_devvp,
  274: 			      bn, ntfs_bntob(ntmp->ntm_bpmftrec), &bp);
  275: 		if (error) {
  276: 			printf("ntfs_loadntnode: BREAD FAILED\n");
  277: 			brelse(bp);
  278: 			goto out;
  279: 		}
  280: 		memcpy(mfrp, bp->b_data, ntfs_bntob(ntmp->ntm_bpmftrec));
  281: 		bqrelse(bp);
  282: 	} else {
  283: 		struct vnode   *vp;
  284: 
  285: 		vp = ntmp->ntm_sysvn[NTFS_MFTINO];
  286: 		error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
  287: 			       ip->i_number * ntfs_bntob(ntmp->ntm_bpmftrec),
  288: 			       ntfs_bntob(ntmp->ntm_bpmftrec), mfrp, NULL);
  289: 		if (error) {
  290: 			printf("ntfs_loadntnode: ntfs_readattr failed\n");
  291: 			goto out;
  292: 		}
  293: 	}
  294: 
  295: 	/* Check if magic and fixups are correct */
  296: 	error = ntfs_procfixups(ntmp, NTFS_FILEMAGIC, (caddr_t)mfrp,
  297: 				ntfs_bntob(ntmp->ntm_bpmftrec));
  298: 	if (error) {
  299: 		printf("ntfs_loadntnode: BAD MFT RECORD %d\n",
  300: 		       (u_int32_t) ip->i_number);
  301: 		goto out;
  302: 	}
  303: 
  304: 	dprintf(("ntfs_loadntnode: load attrs for ino: %d\n",ip->i_number));
  305: 	off = mfrp->fr_attroff;
  306: 	ap = (struct attr *) ((caddr_t)mfrp + off);
  307: 
  308: 	LIST_INIT(&ip->i_valist);
  309: 	
  310: 	while (ap->a_hdr.a_type != -1) {
  311: 		error = ntfs_attrtontvattr(ntmp, &nvap, ap);
  312: 		if (error)
  313: 			break;
  314: 		nvap->va_ip = ip;
  315: 
  316: 		LIST_INSERT_HEAD(&ip->i_valist, nvap, va_list);
  317: 
  318: 		off += ap->a_hdr.reclen;
  319: 		ap = (struct attr *) ((caddr_t)mfrp + off);
  320: 	}
  321: 	if (error) {
  322: 		printf("ntfs_loadntnode: failed to load attr ino: %d\n",
  323: 		       ip->i_number);
  324: 		goto out;
  325: 	}
  326: 
  327: 	ip->i_mainrec = mfrp->fr_mainrec;
  328: 	ip->i_nlink = mfrp->fr_nlink;
  329: 	ip->i_frflag = mfrp->fr_flags;
  330: 
  331: 	ip->i_flag |= IN_LOADED;
  332: 
  333: out:
  334: 	FREE(mfrp, M_TEMP);
  335: 	return (error);
  336: }
  337: 		
  338: /*
  339:  * Routine locks ntnode and increase usecount, just opposite of
  340:  * ntfs_ntput().
  341:  */
  342: int
  343: ntfs_ntget(struct ntnode *ip)
  344: {
  345: 	lwkt_tokref ilock;
  346: 
  347: 	dprintf(("ntfs_ntget: get ntnode %d: %p, usecount: %d\n",
  348: 		ip->i_number, ip, ip->i_usecount));
  349: 
  350: 	ip->i_usecount++;	/* ZZZ */
  351: 	lwkt_gettoken(&ilock, &ip->i_interlock);
  352: 	LOCKMGR(&ip->i_lock, LK_EXCLUSIVE | LK_INTERLOCK, &ilock);
  353: 
  354: 	return 0;
  355: }
  356: 
  357: /*
  358:  * Routine search ntnode in hash, if found: lock, inc usecount and return.
  359:  * If not in hash allocate structure for ntnode, prefill it, lock,
  360:  * inc count and return.
  361:  *
  362:  * ntnode returned locked
  363:  */
  364: int
  365: ntfs_ntlookup(struct ntfsmount *ntmp, ino_t ino, struct ntnode **ipp)
  366: {
  367: 	struct ntnode  *ip;
  368: 
  369: 	dprintf(("ntfs_ntlookup: looking for ntnode %d\n", ino));
  370: 
  371: 	do {
  372: 		if ((ip = ntfs_nthashlookup(ntmp->ntm_dev, ino)) != NULL) {
  373: 			ntfs_ntget(ip);
  374: 			dprintf(("ntfs_ntlookup: ntnode %d: %p, usecount: %d\n",
  375: 				ino, ip, ip->i_usecount));
  376: 			*ipp = ip;
  377: 			return (0);
  378: 		}
  379: 	} while (LOCKMGR(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL));
  380: 
  381: 	MALLOC(ip, struct ntnode *, sizeof(struct ntnode),
  382: 	       M_NTFSNTNODE, M_WAITOK);
  383: 	ddprintf(("ntfs_ntlookup: allocating ntnode: %d: %p\n", ino, ip));
  384: 	bzero((caddr_t) ip, sizeof(struct ntnode));
  385: 
  386: 	/* Generic initialization */
  387: 	ip->i_devvp = ntmp->ntm_devvp;
  388: 	ip->i_dev = ntmp->ntm_dev;
  389: 	ip->i_number = ino;
  390: 	ip->i_mp = ntmp;
  391: 
  392: 	LIST_INIT(&ip->i_fnlist);
  393: 	VREF(ip->i_devvp);
  394: 
  395: 	/* init lock and lock the newborn ntnode */
  396: 	lockinit(&ip->i_lock, 0, "ntnode", 0, LK_EXCLUSIVE);
  397: 	lwkt_token_init(&ip->i_interlock);
  398: 	ntfs_ntget(ip);
  399: 
  400: 	ntfs_nthashins(ip);
  401: 
  402: 	LOCKMGR(&ntfs_hashlock, LK_RELEASE, NULL);
  403: 
  404: 	*ipp = ip;
  405: 
  406: 	dprintf(("ntfs_ntlookup: ntnode %d: %p, usecount: %d\n",
  407: 		ino, ip, ip->i_usecount));
  408: 
  409: 	return (0);
  410: }
  411: 
  412: /*
  413:  * Decrement usecount of ntnode and unlock it, if usecount reach zero,
  414:  * deallocate ntnode.
  415:  *
  416:  * ntnode should be locked on entry, and unlocked on return.
  417:  */
  418: void
  419: ntfs_ntput(struct ntnode *ip)
  420: {
  421: 	struct ntvattr *vap;
  422: 	lwkt_tokref ilock;
  423: 
  424: 	dprintf(("ntfs_ntput: rele ntnode %d: %p, usecount: %d\n",
  425: 		ip->i_number, ip, ip->i_usecount));
  426: 
  427: 	lwkt_gettoken(&ilock, &ip->i_interlock);
  428: 	ip->i_usecount--;
  429: 
  430: #ifdef DIAGNOSTIC
  431: 	if (ip->i_usecount < 0) {
  432: 		panic("ntfs_ntput: ino: %d usecount: %d \n",
  433: 		      ip->i_number,ip->i_usecount);
  434: 	}
  435: #endif
  436: 
  437: 	if (ip->i_usecount > 0) {
  438: 		LOCKMGR(&ip->i_lock, LK_RELEASE|LK_INTERLOCK, &ilock);
  439: 		return;
  440: 	}
  441: 
  442: 	dprintf(("ntfs_ntput: deallocating ntnode: %d\n", ip->i_number));
  443: 
  444: 	if (ip->i_fnlist.lh_first)
  445: 		panic("ntfs_ntput: ntnode has fnodes\n");
  446: 
  447: 	ntfs_nthashrem(ip);
  448: 
  449: 	while ((vap = LIST_FIRST(&ip->i_valist)) != NULL) {
  450: 		LIST_REMOVE(vap,va_list);
  451: 		ntfs_freentvattr(vap);
  452: 	}
  453: 	lwkt_reltoken(&ilock);
  454: 	vrele(ip->i_devvp);
  455: 	FREE(ip, M_NTFSNTNODE);
  456: }
  457: 
  458: /*
  459:  * increment usecount of ntnode 
  460:  */
  461: void
  462: ntfs_ntref(struct ntnode *ip)
  463: {
  464: 	ip->i_usecount++;
  465: 
  466: 	dprintf(("ntfs_ntref: ino %d, usecount: %d\n",
  467: 		ip->i_number, ip->i_usecount));
  468: 			
  469: }
  470: 
  471: /*
  472:  * Decrement usecount of ntnode.
  473:  */
  474: void
  475: ntfs_ntrele(struct ntnode *ip)
  476: {
  477: 	lwkt_tokref ilock;
  478: 
  479: 	dprintf(("ntfs_ntrele: rele ntnode %d: %p, usecount: %d\n",
  480: 		ip->i_number, ip, ip->i_usecount));
  481: 
  482: 	lwkt_gettoken(&ilock, &ip->i_interlock);
  483: 	ip->i_usecount--;
  484: 
  485: 	if (ip->i_usecount < 0) {
  486: 		panic("ntfs_ntrele: ino: %d usecount: %d \n",
  487: 		      ip->i_number,ip->i_usecount);
  488: 	}
  489: 	lwkt_reltoken(&ilock);
  490: }
  491: 
  492: /*
  493:  * Deallocate all memory allocated for ntvattr
  494:  */
  495: void
  496: ntfs_freentvattr(struct ntvattr *vap)
  497: {
  498: 	if (vap->va_flag & NTFS_AF_INRUN) {
  499: 		if (vap->va_vruncn)
  500: 			FREE(vap->va_vruncn, M_NTFSRUN);
  501: 		if (vap->va_vruncl)
  502: 			FREE(vap->va_vruncl, M_NTFSRUN);
  503: 	} else {
  504: 		if (vap->va_datap)
  505: 			FREE(vap->va_datap, M_NTFSRDATA);
  506: 	}
  507: 	FREE(vap, M_NTFSNTVATTR);
  508: }
  509: 
  510: /*
  511:  * Convert disk image of attribute into ntvattr structure,
  512:  * runs are expanded also.
  513:  */
  514: int
  515: ntfs_attrtontvattr(struct ntfsmount *ntmp, struct ntvattr **rvapp,
  516: 		   struct attr *rap)
  517: {
  518: 	int             error, i;
  519: 	struct ntvattr *vap;
  520: 
  521: 	error = 0;
  522: 	*rvapp = NULL;
  523: 
  524: 	MALLOC(vap, struct ntvattr *, sizeof(struct ntvattr),
  525: 		M_NTFSNTVATTR, M_WAITOK);
  526: 	bzero(vap, sizeof(struct ntvattr));
  527: 	vap->va_ip = NULL;
  528: 	vap->va_flag = rap->a_hdr.a_flag;
  529: 	vap->va_type = rap->a_hdr.a_type;
  530: 	vap->va_compression = rap->a_hdr.a_compression;
  531: 	vap->va_index = rap->a_hdr.a_index;
  532: 
  533: 	ddprintf(("type: 0x%x, index: %d", vap->va_type, vap->va_index));
  534: 
  535: 	vap->va_namelen = rap->a_hdr.a_namelen;
  536: 	if (rap->a_hdr.a_namelen) {
  537: 		wchar *unp = (wchar *) ((caddr_t) rap + rap->a_hdr.a_nameoff);
  538: 		ddprintf((", name:["));
  539: 		for (i = 0; i < vap->va_namelen; i++) {
  540: 			vap->va_name[i] = unp[i];
  541: 			ddprintf(("%c", vap->va_name[i]));
  542: 		}
  543: 		ddprintf(("]"));
  544: 	}
  545: 	if (vap->va_flag & NTFS_AF_INRUN) {
  546: 		ddprintf((", nonres."));
  547: 		vap->va_datalen = rap->a_nr.a_datalen;
  548: 		vap->va_allocated = rap->a_nr.a_allocated;
  549: 		vap->va_vcnstart = rap->a_nr.a_vcnstart;
  550: 		vap->va_vcnend = rap->a_nr.a_vcnend;
  551: 		vap->va_compressalg = rap->a_nr.a_compressalg;
  552: 		error = ntfs_runtovrun(&(vap->va_vruncn), &(vap->va_vruncl),
  553: 				       &(vap->va_vruncnt),
  554: 				       (caddr_t) rap + rap->a_nr.a_dataoff);
  555: 	} else {
  556: 		vap->va_compressalg = 0;
  557: 		ddprintf((", res."));
  558: 		vap->va_datalen = rap->a_r.a_datalen;
  559: 		vap->va_allocated = rap->a_r.a_datalen;
  560: 		vap->va_vcnstart = 0;
  561: 		vap->va_vcnend = ntfs_btocn(vap->va_allocated);
  562: 		MALLOC(vap->va_datap, caddr_t, vap->va_datalen,
  563: 		       M_NTFSRDATA, M_WAITOK);
  564: 		memcpy(vap->va_datap, (caddr_t) rap + rap->a_r.a_dataoff,
  565: 		       rap->a_r.a_datalen);
  566: 	}
  567: 	ddprintf((", len: %d", vap->va_datalen));
  568: 
  569: 	if (error)
  570: 		FREE(vap, M_NTFSNTVATTR);
  571: 	else
  572: 		*rvapp = vap;
  573: 
  574: 	ddprintf(("\n"));
  575: 
  576: 	return (error);
  577: }
  578: 
  579: /*
  580:  * Expand run into more utilizable and more memory eating format.
  581:  */
  582: int
  583: ntfs_runtovrun(cn_t **rcnp, cn_t **rclp, u_long *rcntp, u_int8_t *run)
  584: {
  585: 	u_int32_t       off;
  586: 	u_int32_t       sz, i;
  587: 	cn_t           *cn;
  588: 	cn_t           *cl;
  589: 	u_long		cnt;
  590: 	cn_t		prev;
  591: 	cn_t		tmp;
  592: 
  593: 	off = 0;
  594: 	cnt = 0;
  595: 	i = 0;
  596: 	while (run[off]) {
  597: 		off += (run[off] & 0xF) + ((run[off] >> 4) & 0xF) + 1;
  598: 		cnt++;
  599: 	}
  600: 	MALLOC(cn, cn_t *, cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
  601: 	MALLOC(cl, cn_t *, cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
  602: 
  603: 	off = 0;
  604: 	cnt = 0;
  605: 	prev = 0;
  606: 	while (run[off]) {
  607: 
  608: 		sz = run[off++];
  609: 		cl[cnt] = 0;
  610: 
  611: 		for (i = 0; i < (sz & 0xF); i++)
  612: 			cl[cnt] += (u_int32_t) run[off++] << (i << 3);
  613: 
  614: 		sz >>= 4;
  615: 		if (run[off + sz - 1] & 0x80) {
  616: 			tmp = ((u_int64_t) - 1) << (sz << 3);
  617: 			for (i = 0; i < sz; i++)
  618: 				tmp |= (u_int64_t) run[off++] << (i << 3);
  619: 		} else {
  620: 			tmp = 0;
  621: 			for (i = 0; i < sz; i++)
  622: 				tmp |= (u_int64_t) run[off++] << (i << 3);
  623: 		}
  624: 		if (tmp)
  625: 			prev = cn[cnt] = prev + tmp;
  626: 		else
  627: 			cn[cnt] = tmp;
  628: 
  629: 		cnt++;
  630: 	}
  631: 	*rcnp = cn;
  632: 	*rclp = cl;
  633: 	*rcntp = cnt;
  634: 	return (0);
  635: }
  636: 
  637: /*
  638:  * Compare unicode and ascii string case insens.
  639:  */
  640: static int
  641: ntfs_uastricmp(struct ntfsmount *ntmp, const wchar *ustr, size_t ustrlen,
  642: 	       const char *astr, size_t astrlen)
  643: {
  644: 	size_t             i;
  645: 	int             res;
  646: 
  647: 	/*
  648: 	 * XXX We use NTFS_82U(NTFS_U28(c)) to get rid of unicode
  649: 	 * symbols not covered by translation table
  650: 	 */
  651: 	for (i = 0; i < ustrlen && i < astrlen; i++) {
  652: 		res = ((int) NTFS_TOUPPER(NTFS_82U(NTFS_U28(ustr[i])))) -
  653: 			((int)NTFS_TOUPPER(NTFS_82U(astr[i])));
  654: 		if (res)
  655: 			return res;
  656: 	}
  657: 	return (ustrlen - astrlen);
  658: }
  659: 
  660: /*
  661:  * Compare unicode and ascii string case sens.
  662:  */
  663: static int
  664: ntfs_uastrcmp(struct ntfsmount *ntmp, const wchar *ustr, size_t ustrlen,
  665: 	      const char *astr, size_t astrlen)
  666: {
  667: 	size_t             i;
  668: 	int             res;
  669: 
  670: 	for (i = 0; (i < ustrlen) && (i < astrlen); i++) {
  671: 		res = (int) (((char)NTFS_U28(ustr[i])) - astr[i]);
  672: 		if (res)
  673: 			return res;
  674: 	}
  675: 	return (ustrlen - astrlen);
  676: }
  677: 
  678: /* 
  679:  * Search fnode in ntnode, if not found allocate and preinitialize.
  680:  *
  681:  * ntnode should be locked on entry.
  682:  */
  683: int
  684: ntfs_fget(struct ntfsmount *ntmp, struct ntnode *ip, int attrtype,
  685: 	  char *attrname, struct fnode **fpp)
  686: {
  687: 	struct fnode *fp;
  688: 
  689: 	dprintf(("ntfs_fget: ino: %d, attrtype: 0x%x, attrname: %s\n",
  690: 		ip->i_number,attrtype, attrname?attrname:""));
  691: 	*fpp = NULL;
  692: 	for (fp = ip->i_fnlist.lh_first; fp != NULL; fp = fp->f_fnlist.le_next){
  693: 		dprintf(("ntfs_fget: fnode: attrtype: %d, attrname: %s\n",
  694: 			fp->f_attrtype, fp->f_attrname?fp->f_attrname:""));
  695: 
  696: 		if ((attrtype == fp->f_attrtype) && 
  697: 		    ((!attrname && !fp->f_attrname) ||
  698: 		     (attrname && fp->f_attrname &&
  699: 		      !strcmp(attrname,fp->f_attrname)))){
  700: 			dprintf(("ntfs_fget: found existed: %p\n",fp));
  701: 			*fpp = fp;
  702: 		}
  703: 	}
  704: 
  705: 	if (*fpp)
  706: 		return (0);
  707: 
  708: 	MALLOC(fp, struct fnode *, sizeof(struct fnode), M_NTFSFNODE, M_WAITOK);
  709: 	bzero(fp, sizeof(struct fnode));
  710: 	dprintf(("ntfs_fget: allocating fnode: %p\n",fp));
  711: 
  712: 	fp->f_ip = ip;
  713: 	if (attrname) {
  714: 		fp->f_flag |= FN_AATTRNAME;
  715: 		MALLOC(fp->f_attrname, char *, strlen(attrname)+1, M_TEMP, M_WAITOK);
  716: 		strcpy(fp->f_attrname, attrname);
  717: 	} else
  718: 		fp->f_attrname = NULL;
  719: 	fp->f_attrtype = attrtype;
  720: 
  721: 	ntfs_ntref(ip);
  722: 
  723: 	LIST_INSERT_HEAD(&ip->i_fnlist, fp, f_fnlist);
  724: 
  725: 	*fpp = fp;
  726: 
  727: 	return (0);
  728: }
  729: 
  730: /*
  731:  * Deallocate fnode, remove it from ntnode's fnode list.
  732:  *
  733:  * ntnode should be locked.
  734:  */
  735: void
  736: ntfs_frele(struct fnode *fp)
  737: {
  738: 	struct ntnode *ip = FTONT(fp);
  739: 
  740: 	dprintf(("ntfs_frele: fnode: %p for %d: %p\n", fp, ip->i_number, ip));
  741: 
  742: 	dprintf(("ntfs_frele: deallocating fnode\n"));
  743: 	LIST_REMOVE(fp,f_fnlist);
  744: 	if (fp->f_flag & FN_AATTRNAME)
  745: 		FREE(fp->f_attrname, M_TEMP);
  746: 	if (fp->f_dirblbuf)
  747: 		FREE(fp->f_dirblbuf, M_NTFSDIR);
  748: 	FREE(fp, M_NTFSFNODE);
  749: 	ntfs_ntrele(ip);
  750: }
  751: 
  752: /*
  753:  * Lookup attribute name in format: [[:$ATTR_TYPE]:$ATTR_NAME], 
  754:  * $ATTR_TYPE is searched in attrdefs read from $AttrDefs.
  755:  * If $ATTR_TYPE nott specifed, ATTR_A_DATA assumed.
  756:  */
  757: static int
  758: ntfs_ntlookupattr(struct ntfsmount *ntmp, const char *name, int namelen,
  759: 		  int *attrtype, char **attrname)
  760: {
  761: 	const char *sys;
  762: 	size_t syslen, i;
  763: 	struct ntvattrdef *adp;
  764: 
  765: 	if (namelen == 0)
  766: 		return (0);
  767: 
  768: 	if (name[0] == '$') {
  769: 		sys = name;
  770: 		for (syslen = 0; syslen < namelen; syslen++) {
  771: 			if(sys[syslen] == ':') {
  772: 				name++;
  773: 				namelen--;
  774: 				break;
  775: 			}
  776: 		}
  777: 		name += syslen;
  778: 		namelen -= syslen;
  779: 
  780: 		adp = ntmp->ntm_ad;
  781: 		for (i = 0; i < ntmp->ntm_adnum; i++, adp++){
  782: 			if (syslen != adp->ad_namelen || 
  783: 			   strncmp(sys, adp->ad_name, syslen) != 0)
  784: 				continue;
  785: 
  786: 			*attrtype = adp->ad_type;
  787: 			goto out;
  788: 		}
  789: 		return (ENOENT);
  790: 	} else
  791: 		*attrtype = NTFS_A_DATA;
  792: 
  793:     out:
  794: 	if (namelen) {
  795: 		MALLOC((*attrname), char *, namelen, M_TEMP, M_WAITOK);
  796: 		memcpy((*attrname), name, namelen);
  797: 		(*attrname)[namelen] = '\0';
  798: 	}
  799: 
  800: 	return (0);
  801: }
  802: 
  803: /*
  804:  * Lookup specifed node for filename, matching cnp,
  805:  * return fnode filled.
  806:  */
  807: int
  808: ntfs_ntlookupfile(struct ntfsmount *ntmp, struct vnode *vp,
  809: 	          struct componentname *cnp, struct vnode **vpp)
  810: {
  811: 	struct fnode   *fp = VTOF(vp);
  812: 	struct ntnode  *ip = FTONT(fp);
  813: 	struct ntvattr *vap;	/* Root attribute */
  814: 	cn_t            cn;	/* VCN in current attribute */
  815: 	caddr_t         rdbuf;	/* Buffer to read directory's blocks  */
  816: 	u_int32_t       blsize;
  817: 	u_int32_t       rdsize;	/* Length of data to read from current block */
  818: 	struct attr_indexentry *iep;
  819: 	int             error, res, anamelen, fnamelen;
  820: 	const char     *fname,*aname;
  821: 	u_int32_t       aoff;
  822: 	int attrtype = NTFS_A_DATA;
  823: 	char *attrname = NULL;
  824: 	struct fnode   *nfp;
  825: 	struct vnode   *nvp;
  826: 	enum vtype	f_type;
  827: 
  828: 	error = ntfs_ntget(ip);
  829: 	if (error)
  830: 		return (error);
  831: 
  832: 	error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXROOT, "$I30", 0, &vap);
  833: 	if (error || (vap->va_flag & NTFS_AF_INRUN))
  834: 		return (ENOTDIR);
  835: 
  836: 	blsize = vap->va_a_iroot->ir_size;
  837: 	rdsize = vap->va_datalen;
  838: 
  839: 	/*
  840: 	 * Divide file name into: foofilefoofilefoofile[:attrspec]
  841: 	 * Store like this:       fname:fnamelen       [aname:anamelen]
  842: 	 */
  843: 	fname = cnp->cn_nameptr;
  844: 	aname = NULL;
  845: 	anamelen = 0;
  846: 	for (fnamelen = 0; fnamelen < cnp->cn_namelen; fnamelen++)
  847: 		if(fname[fnamelen] == ':') {
  848: 			aname = fname + fnamelen + 1;
  849: 			anamelen = cnp->cn_namelen - fnamelen - 1;
  850: 			dprintf(("ntfs_ntlookupfile: %s (%d), attr: %s (%d)\n",
  851: 				fname, fnamelen, aname, anamelen));
  852: 			break;
  853: 		}
  854: 
  855: 	dprintf(("ntfs_ntlookupfile: blksz: %d, rdsz: %d\n", blsize, rdsize));
  856: 
  857: 	MALLOC(rdbuf, caddr_t, blsize, M_TEMP, M_WAITOK);
  858: 
  859: 	error = ntfs_readattr(ntmp, ip, NTFS_A_INDXROOT, "$I30",
  860: 			       0, rdsize, rdbuf, NULL);
  861: 	if (error)
  862: 		goto fail;
  863: 
  864: 	aoff = sizeof(struct attr_indexroot);
  865: 
  866: 	do {
  867: 		iep = (struct attr_indexentry *) (rdbuf + aoff);
  868: 
  869: 		for (; !(iep->ie_flag & NTFS_IEFLAG_LAST) && (rdsize > aoff);
  870: 			aoff += iep->reclen,
  871: 			iep = (struct attr_indexentry *) (rdbuf + aoff))
  872: 		{
  873: 			ddprintf(("scan: %d, %d\n",
  874: 				  (u_int32_t) iep->ie_number,
  875: 				  (u_int32_t) iep->ie_fnametype));
  876: 
  877: 			/* check the name - the case-insensitible check
  878: 			 * has to come first, to break from this for loop
  879: 			 * if needed, so we can dive correctly */
  880: 			res = NTFS_UASTRICMP(iep->ie_fname, iep->ie_fnamelen,
  881: 				fname, fnamelen);
  882: 			if (res > 0) break;
  883: 			if (res < 0) continue;
  884: 
  885: 			if (iep->ie_fnametype == 0 ||
  886: 			    !(ntmp->ntm_flag & NTFS_MFLAG_CASEINS))
  887: 			{
  888: 				res = NTFS_UASTRCMP(iep->ie_fname,
  889: 					iep->ie_fnamelen, fname, fnamelen);
  890: 				if (res != 0) continue;
  891: 			}
  892: 
  893: 			if (aname) {
  894: 				error = ntfs_ntlookupattr(ntmp,
  895: 					aname, anamelen,
  896: 					&attrtype, &attrname);
  897: 				if (error)
  898: 					goto fail;
  899: 			}
  900: 
  901: 			/* Check if we've found ourself */
  902: 			if ((iep->ie_number == ip->i_number) &&
  903: 			    (attrtype == fp->f_attrtype) &&
  904: 			    ((!attrname && !fp->f_attrname) ||
  905: 			     (attrname && fp->f_attrname &&
  906: 			      !strcmp(attrname, fp->f_attrname))))
  907: 			{
  908: 				VREF(vp);
  909: 				*vpp = vp;
  910: 				error = 0;
  911: 				goto fail;
  912: 			}
  913: 
  914: 			/* vget node, but don't load it */
  915: 			error = ntfs_vgetex(ntmp->ntm_mountp,
  916: 				   iep->ie_number, attrtype, attrname,
  917: 				   LK_EXCLUSIVE, VG_DONTLOADIN | VG_DONTVALIDFN,
  918: 				   curthread, &nvp);
  919: 
  920: 			/* free the buffer returned by ntfs_ntlookupattr() */
  921: 			if (attrname) {
  922: 				FREE(attrname, M_TEMP);
  923: 				attrname = NULL;
  924: 			}
  925: 
  926: 			if (error)
  927: 				goto fail;
  928: 
  929: 			nfp = VTOF(nvp);
  930: 
  931: 			if (nfp->f_flag & FN_VALID) {
  932: 				*vpp = nvp;
  933: 				goto fail;
  934: 			}
  935: 
  936: 			nfp->f_fflag = iep->ie_fflag;
  937: 			nfp->f_pnumber = iep->ie_fpnumber;
  938: 			nfp->f_times = iep->ie_ftimes;
  939: 
  940: 			if((nfp->f_fflag & NTFS_FFLAG_DIR) &&
  941: 			   (nfp->f_attrtype == NTFS_A_DATA) &&
  942: 			   (nfp->f_attrname == NULL))
  943: 				f_type = VDIR;	
  944: 			else
  945: 				f_type = VREG;	
  946: 
  947: 			nvp->v_type = f_type;
  948: 
  949: 			if ((nfp->f_attrtype == NTFS_A_DATA) &&
  950: 			    (nfp->f_attrname == NULL))
  951: 			{
  952: 				/* Opening default attribute */
  953: 				nfp->f_size = iep->ie_fsize;
  954: 				nfp->f_allocated = iep->ie_fallocated;
  955: 				nfp->f_flag |= FN_PRELOADED;
  956: 			} else {
  957: 				error = ntfs_filesize(ntmp, nfp,
  958: 					    &nfp->f_size, &nfp->f_allocated);
  959: 				if (error) {
  960: 					vput(nvp);
  961: 					goto fail;
  962: 				}
  963: 			}
  964: 
  965: 			nfp->f_flag &= ~FN_VALID;
  966: 			*vpp = nvp;
  967: 			goto fail;
  968: 		}
  969: 
  970: 		/* Dive if possible */
  971: 		if (iep->ie_flag & NTFS_IEFLAG_SUBNODE) {
  972: 			dprintf(("ntfs_ntlookupfile: diving\n"));
  973: 
  974: 			cn = *(cn_t *) (rdbuf + aoff +
  975: 					iep->reclen - sizeof(cn_t));
  976: 			rdsize = blsize;
  977: 
  978: 			error = ntfs_readattr(ntmp, ip, NTFS_A_INDX, "$I30",
  979: 					ntfs_cntob(cn), rdsize, rdbuf, NULL);
  980: 			if (error)
  981: 				goto fail;
  982: 
  983: 			error = ntfs_procfixups(ntmp, NTFS_INDXMAGIC,
  984: 						rdbuf, rdsize);
  985: 			if (error)
  986: 				goto fail;
  987: 
  988: 			aoff = (((struct attr_indexalloc *) rdbuf)->ia_hdrsize +
  989: 				0x18);
  990: 		} else {
  991: 			dprintf(("ntfs_ntlookupfile: nowhere to dive :-(\n"));
  992: 			error = ENOENT;
  993: 			break;
  994: 		}
  995: 	} while (1);
  996: 
  997: 	dprintf(("finish\n"));
  998: 
  999: fail:
 1000: 	if (attrname) FREE(attrname, M_TEMP);
 1001: 	ntfs_ntvattrrele(vap);
 1002: 	ntfs_ntput(ip);
 1003: 	FREE(rdbuf, M_TEMP);
 1004: 	return (error);
 1005: }
 1006: 
 1007: /*
 1008:  * Check if name type is permitted to show.
 1009:  */
 1010: int
 1011: ntfs_isnamepermitted(struct ntfsmount *ntmp, struct attr_indexentry *iep)
 1012: {
 1013: 	if (ntmp->ntm_flag & NTFS_MFLAG_ALLNAMES)
 1014: 		return 1;
 1015: 
 1016: 	switch (iep->ie_fnametype) {
 1017: 	case 2:
 1018: 		ddprintf(("ntfs_isnamepermitted: skiped DOS name\n"));
 1019: 		return 0;
 1020: 	case 0: case 1: case 3:
 1021: 		return 1;
 1022: 	default:
 1023: 		printf("ntfs_isnamepermitted: " \
 1024: 		       "WARNING! Unknown file name type: %d\n",
 1025: 		       iep->ie_fnametype);
 1026: 		break;
 1027: 	}
 1028: 	return 0;
 1029: }
 1030: 
 1031: /*
 1032:  * Read ntfs dir like stream of attr_indexentry, not like btree of them.
 1033:  * This is done by scaning $BITMAP:$I30 for busy clusters and reading them.
 1034:  * Ofcouse $INDEX_ROOT:$I30 is read before. Last read values are stored in
 1035:  * fnode, so we can skip toward record number num almost immediatly.
 1036:  * Anyway this is rather slow routine. The problem is that we don't know
 1037:  * how many records are there in $INDEX_ALLOCATION:$I30 block.
 1038:  */
 1039: int
 1040: ntfs_ntreaddir(struct ntfsmount *ntmp, struct fnode *fp,
 1041: 	       u_int32_t num, struct attr_indexentry **riepp)
 1042: {
 1043: 	struct ntnode  *ip = FTONT(fp);
 1044: 	struct ntvattr *vap = NULL;	/* IndexRoot attribute */
 1045: 	struct ntvattr *bmvap = NULL;	/* BitMap attribute */
 1046: 	struct ntvattr *iavap = NULL;	/* IndexAllocation attribute */
 1047: 	caddr_t         rdbuf;		/* Buffer to read directory's blocks  */
 1048: 	u_char         *bmp = NULL;	/* Bitmap */
 1049: 	u_int32_t       blsize;		/* Index allocation size (2048) */
 1050: 	u_int32_t       rdsize;		/* Length of data to read */
 1051: 	u_int32_t       attrnum;	/* Current attribute type */
 1052: 	u_int32_t       cpbl = 1;	/* Clusters per directory block */
 1053: 	u_int32_t       blnum;
 1054: 	struct attr_indexentry *iep;
 1055: 	int             error = ENOENT;
 1056: 	u_int32_t       aoff, cnum;
 1057: 
 1058: 	dprintf(("ntfs_ntreaddir: read ino: %d, num: %d\n", ip->i_number, num));
 1059: 	error = ntfs_ntget(ip);
 1060: 	if (error)
 1061: 		return (error);
 1062: 
 1063: 	error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXROOT, "$I30", 0, &vap);
 1064: 	if (error)
 1065: 		return (ENOTDIR);
 1066: 
 1067: 	if (fp->f_dirblbuf == NULL) {
 1068: 		fp->f_dirblsz = vap->va_a_iroot->ir_size;
 1069: 		MALLOC(fp->f_dirblbuf, caddr_t,
 1070: 		       max(vap->va_datalen,fp->f_dirblsz), M_NTFSDIR, M_WAITOK);
 1071: 	}
 1072: 
 1073: 	blsize = fp->f_dirblsz;
 1074: 	rdbuf = fp->f_dirblbuf;
 1075: 
 1076: 	dprintf(("ntfs_ntreaddir: rdbuf: 0x%p, blsize: %d\n", rdbuf, blsize));
 1077: 
 1078: 	if (vap->va_a_iroot->ir_flag & NTFS_IRFLAG_INDXALLOC) {
 1079: 		error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXBITMAP, "$I30",
 1080: 					0, &bmvap);
 1081: 		if (error) {
 1082: 			error = ENOTDIR;
 1083: 			goto fail;
 1084: 		}
 1085: 		MALLOC(bmp, u_char *, bmvap->va_datalen, M_TEMP, M_WAITOK);
 1086: 		error = ntfs_readattr(ntmp, ip, NTFS_A_INDXBITMAP, "$I30", 0,
 1087: 				       bmvap->va_datalen, bmp, NULL);
 1088: 		if (error)
 1089: 			goto fail;
 1090: 
 1091: 		error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDX, "$I30",
 1092: 					0, &iavap);
 1093: 		if (error) {
 1094: 			error = ENOTDIR;
 1095: 			goto fail;
 1096: 		}
 1097: 		cpbl = ntfs_btocn(blsize + ntfs_cntob(1) - 1);
 1098: 		dprintf(("ntfs_ntreaddir: indexalloc: %d, cpbl: %d\n",
 1099: 			 iavap->va_datalen, cpbl));
 1100: 	} else {
 1101: 		dprintf(("ntfs_ntreadidir: w/o BitMap and IndexAllocation\n"));
 1102: 		iavap = bmvap = NULL;
 1103: 		bmp = NULL;
 1104: 	}
 1105: 
 1106: 	/* Try use previous values */
 1107: 	if ((fp->f_lastdnum < num) && (fp->f_lastdnum != 0)) {
 1108: 		attrnum = fp->f_lastdattr;
 1109: 		aoff = fp->f_lastdoff;
 1110: 		blnum = fp->f_lastdblnum;
 1111: 		cnum = fp->f_lastdnum;
 1112: 	} else {
 1113: 		attrnum = NTFS_A_INDXROOT;
 1114: 		aoff = sizeof(struct attr_indexroot);
 1115: 		blnum = 0;
 1116: 		cnum = 0;
 1117: 	}
 1118: 
 1119: 	do {
 1120: 		dprintf(("ntfs_ntreaddir: scan: 0x%x, %d, %d, %d, %d\n",
 1121: 			 attrnum, (u_int32_t) blnum, cnum, num, aoff));
 1122: 		rdsize = (attrnum == NTFS_A_INDXROOT) ? vap->va_datalen : blsize;
 1123: 		error = ntfs_readattr(ntmp, ip, attrnum, "$I30",
 1124: 				ntfs_cntob(blnum * cpbl), rdsize, rdbuf, NULL);
 1125: 		if (error)
 1126: 			goto fail;
 1127: 
 1128: 		if (attrnum == NTFS_A_INDX) {
 1129: 			error = ntfs_procfixups(ntmp, NTFS_INDXMAGIC,
 1130: 						rdbuf, rdsize);
 1131: 			if (error)
 1132: 				goto fail;
 1133: 		}
 1134: 		if (aoff == 0)
 1135: 			aoff = (attrnum == NTFS_A_INDX) ?
 1136: 				(0x18 + ((struct attr_indexalloc *) rdbuf)->ia_hdrsize) :
 1137: 				sizeof(struct attr_indexroot);
 1138: 
 1139: 		iep = (struct attr_indexentry *) (rdbuf + aoff);
 1140: 		for (; !(iep->ie_flag & NTFS_IEFLAG_LAST) && (rdsize > aoff);
 1141: 			aoff += iep->reclen,
 1142: 			iep = (struct attr_indexentry *) (rdbuf + aoff))
 1143: 		{
 1144: 			if (!ntfs_isnamepermitted(ntmp, iep)) continue;
 1145: 
 1146: 			if (cnum >= num) {
 1147: 				fp->f_lastdnum = cnum;
 1148: 				fp->f_lastdoff = aoff;
 1149: 				fp->f_lastdblnum = blnum;
 1150: 				fp->f_lastdattr = attrnum;
 1151: 
 1152: 				*riepp = iep;
 1153: 
 1154: 				error = 0;
 1155: 				goto fail;
 1156: 			}
 1157: 			cnum++;
 1158: 		}
 1159: 
 1160: 		if (iavap) {
 1161: 			if (attrnum == NTFS_A_INDXROOT)
 1162: 				blnum = 0;
 1163: 			else
 1164: 				blnum++;
 1165: 
 1166: 			while (ntfs_cntob(blnum * cpbl) < iavap->va_datalen) {
 1167: 				if (bmp[blnum >> 3] & (1 << (blnum & 3)))
 1168: 					break;
 1169: 				blnum++;
 1170: 			}
 1171: 
 1172: 			attrnum = NTFS_A_INDX;
 1173: 			aoff = 0;
 1174: 			if (ntfs_cntob(blnum * cpbl) >= iavap->va_datalen)
 1175: 				break;
 1176: 			dprintf(("ntfs_ntreaddir: blnum: %d\n", (u_int32_t) blnum));
 1177: 		}
 1178: 	} while (iavap);
 1179: 
 1180: 	*riepp = NULL;
 1181: 	fp->f_lastdnum = 0;
 1182: 
 1183: fail:
 1184: 	if (vap)
 1185: 		ntfs_ntvattrrele(vap);
 1186: 	if (bmvap)
 1187: 		ntfs_ntvattrrele(bmvap);
 1188: 	if (iavap)
 1189: 		ntfs_ntvattrrele(iavap);
 1190: 	if (bmp)
 1191: 		FREE(bmp, M_TEMP);
 1192: 	ntfs_ntput(ip);
 1193: 	return (error);
 1194: }
 1195: 
 1196: /*
 1197:  * Convert NTFS times that are in 100 ns units and begins from
 1198:  * 1601 Jan 1 into unix times.
 1199:  */
 1200: struct timespec
 1201: ntfs_nttimetounix(u_int64_t nt)
 1202: {
 1203: 	struct timespec t;
 1204: 
 1205: 	/* WindowNT times are in 100 ns and from 1601 Jan 1 */
 1206: 	t.tv_nsec = (nt % (1000 * 1000 * 10)) * 100;
 1207: 	t.tv_sec = nt / (1000 * 1000 * 10) -
 1208: 		369LL * 365LL * 24LL * 60LL * 60LL -
 1209: 		89LL * 1LL * 24LL * 60LL * 60LL;
 1210: 	return (t);
 1211: }
 1212: 
 1213: /*
 1214:  * Get file times from NTFS_A_NAME attribute.
 1215:  */
 1216: int
 1217: ntfs_times(struct ntfsmount *ntmp, struct ntnode *ip, ntfs_times_t *tm)
 1218: {
 1219: 	struct ntvattr *vap;
 1220: 	int             error;
 1221: 
 1222: 	dprintf(("ntfs_times: ino: %d...\n", ip->i_number));
 1223: 
 1224: 	error = ntfs_ntget(ip);
 1225: 	if (error)
 1226: 		return (error);
 1227: 
 1228: 	error = ntfs_ntvattrget(ntmp, ip, NTFS_A_NAME, NULL, 0, &vap);
 1229: 	if (error) {
 1230: 		ntfs_ntput(ip);
 1231: 		return (error);
 1232: 	}
 1233: 	*tm = vap->va_a_name->n_times;
 1234: 	ntfs_ntvattrrele(vap);
 1235: 	ntfs_ntput(ip);
 1236: 
 1237: 	return (0);
 1238: }
 1239: 
 1240: /*
 1241:  * Get file sizes from corresponding attribute. 
 1242:  * 
 1243:  * ntnode under fnode should be locked.
 1244:  */
 1245: int
 1246: ntfs_filesize(struct ntfsmount *ntmp, struct fnode *fp, u_int64_t *size,
 1247: 	      u_int64_t *bytes)
 1248: {
 1249: 	struct ntvattr *vap;
 1250: 	struct ntnode *ip = FTONT(fp);
 1251: 	u_int64_t       sz, bn;
 1252: 	int             error;
 1253: 
 1254: 	dprintf(("ntfs_filesize: ino: %d\n", ip->i_number));
 1255: 
 1256: 	error = ntfs_ntvattrget(ntmp, ip,
 1257: 		fp->f_attrtype, fp->f_attrname, 0, &vap);
 1258: 	if (error)
 1259: 		return (error);
 1260: 
 1261: 	bn = vap->va_allocated;
 1262: 	sz = vap->va_datalen;
 1263: 
 1264: 	dprintf(("ntfs_filesize: %d bytes (%d bytes allocated)\n",
 1265: 		(u_int32_t) sz, (u_int32_t) bn));
 1266: 
 1267: 	if (size)
 1268: 		*size = sz;
 1269: 	if (bytes)
 1270: 		*bytes = bn;
 1271: 
 1272: 	ntfs_ntvattrrele(vap);
 1273: 
 1274: 	return (0);
 1275: }
 1276: 
 1277: /*
 1278:  * This is one of write routine.
 1279:  */
 1280: int
 1281: ntfs_writeattr_plain(struct ntfsmount *ntmp, struct ntnode *ip,
 1282: 		     u_int32_t attrnum, char *attrname,	off_t roff,
 1283: 		     size_t rsize, void *rdata,	size_t *initp,
 1284: 		     struct uio *uio)
 1285: {
 1286: 	size_t          init;
 1287: 	int             error = 0;
 1288: 	off_t           off = roff, left = rsize, towrite;
 1289: 	caddr_t         data = rdata;
 1290: 	struct ntvattr *vap;
 1291: 	*initp = 0;
 1292: 
 1293: 	while (left) {
 1294: 		error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname,
 1295: 					ntfs_btocn(off), &vap);
 1296: 		if (error)
 1297: 			return (error);
 1298: 		towrite = min(left, ntfs_cntob(vap->va_vcnend + 1) - off);
 1299: 		ddprintf(("ntfs_writeattr_plain: o: %d, s: %d (%d - %d)\n",
 1300: 			 (u_int32_t) off, (u_int32_t) towrite,
 1301: 			 (u_int32_t) vap->va_vcnstart,
 1302: 			 (u_int32_t) vap->va_vcnend));
 1303: 		error = ntfs_writentvattr_plain(ntmp, ip, vap,
 1304: 					 off - ntfs_cntob(vap->va_vcnstart),
 1305: 					 towrite, data, &init, uio);
 1306: 		if (error) {
 1307: 			printf("ntfs_writeattr_plain: " \
 1308: 			       "ntfs_writentvattr_plain failed: o: %d, s: %d\n",
 1309: 			       (u_int32_t) off, (u_int32_t) towrite);
 1310: 			printf("ntfs_writeattr_plain: attrib: %d - %d\n",
 1311: 			       (u_int32_t) vap->va_vcnstart, 
 1312: 			       (u_int32_t) vap->va_vcnend);
 1313: 			ntfs_ntvattrrele(vap);
 1314: 			break;
 1315: 		}
 1316: 		ntfs_ntvattrrele(vap);
 1317: 		left -= towrite;
 1318: 		off += towrite;
 1319: 		data = data + towrite;
 1320: 		*initp += init;
 1321: 	}
 1322: 
 1323: 	return (error);
 1324: }
 1325: 
 1326: /*
 1327:  * This is one of write routine.
 1328:  *
 1329:  * ntnode should be locked.
 1330:  */
 1331: int
 1332: ntfs_writentvattr_plain(struct ntfsmount *ntmp,	struct ntnode *ip,
 1333: 			struct ntvattr *vap, off_t roff, size_t rsize,
 1334: 			void *rdata, size_t *initp, struct uio *uio)
 1335: {
 1336: 	int             error = 0;
 1337: 	int             off;
 1338: 	int             cnt;
 1339: 	cn_t            ccn, ccl, cn, left, cl;
 1340: 	caddr_t         data = rdata;
 1341: 	struct buf     *bp;
 1342: 	size_t          tocopy;
 1343: 
 1344: 	*initp = 0;
 1345: 
 1346: 	if ((vap->va_flag & NTFS_AF_INRUN) == 0) {
 1347: 		printf("ntfs_writevattr_plain: CAN'T WRITE RES. ATTRIBUTE\n");
 1348: 		return ENOTTY;
 1349: 	}
 1350: 
 1351: 	ddprintf(("ntfs_writentvattr_plain: data in run: %ld chains\n",
 1352: 		 vap->va_vruncnt));
 1353: 
 1354: 	off = roff;
 1355: 	left = rsize;
 1356: 	ccl = 0;
 1357: 	ccn = 0;
 1358: 	cnt = 0;
 1359: 	for (; left && (cnt < vap->va_vruncnt); cnt++) {
 1360: 		ccn = vap->va_vruncn[cnt];
 1361: 		ccl = vap->va_vruncl[cnt];
 1362: 
 1363: 		ddprintf(("ntfs_writentvattr_plain: " \
 1364: 			 "left %d, cn: 0x%x, cl: %d, off: %d\n", \
 1365: 			 (u_int32_t) left, (u_int32_t) ccn, \
 1366: 			 (u_int32_t) ccl, (u_int32_t) off));
 1367: 
 1368: 		if (ntfs_cntob(ccl) < off) {
 1369: 			off -= ntfs_cntob(ccl);
 1370: 			cnt++;
 1371: 			continue;
 1372: 		}
 1373: 		if (!ccn && ip->i_number != NTFS_BOOTINO)
 1374: 			continue; /* XXX */
 1375: 
 1376: 		ccl -= ntfs_btocn(off);
 1377: 		cn = ccn + ntfs_btocn(off);
 1378: 		off = ntfs_btocnoff(off);
 1379: 
 1380: 		while (left && ccl) {
 1381: #if defined(__DragonFly__)
 1382: 			tocopy = min(left,
 1383: 				  min(ntfs_cntob(ccl) - off, MAXBSIZE - off));
 1384: #else
 1385: 			/* under NetBSD, bread() can read
 1386: 			 * maximum one block worth of data */
 1387: 			tocopy = min(left, ntmp->ntm_bps - off);
 1388: #endif
 1389: 			cl = ntfs_btocl(tocopy + off);
 1390: 			ddprintf(("ntfs_writentvattr_plain: write: " \
 1391: 				"cn: 0x%x cl: %d, off: %d len: %d, left: %d\n",
 1392: 				(u_int32_t) cn, (u_int32_t) cl, 
 1393: 				(u_int32_t) off, (u_int32_t) tocopy, 
 1394: 				(u_int32_t) left));
 1395: 			if ((off == 0) && (tocopy == ntfs_cntob(cl)))
 1396: 			{
 1397: 				bp = getblk(ntmp->ntm_devvp, ntfs_cntobn(cn),
 1398: 					    ntfs_cntob(cl), 0, 0);
 1399: 				clrbuf(bp);
 1400: 			} else {
 1401: 				error = bread(ntmp->ntm_devvp, ntfs_cntobn(cn),
 1402: 					      ntfs_cntob(cl), &bp);
 1403: 				if (error) {
 1404: 					brelse(bp);
 1405: 					return (error);
 1406: 				}
 1407: 			}
 1408: 			if (uio)
 1409: 				uiomove(bp->b_data + off, tocopy, uio);
 1410: 			else
 1411: 				memcpy(bp->b_data + off, data, tocopy);
 1412: 			bawrite(bp);
 1413: 			data = data + tocopy;
 1414: 			*initp += tocopy;
 1415: 			off = 0;
 1416: 			left -= tocopy;
 1417: 			cn += cl;
 1418: 			ccl -= cl;
 1419: 		}
 1420: 	}
 1421: 
 1422: 	if (left) {
 1423: 		printf("ntfs_writentvattr_plain: POSSIBLE RUN ERROR\n");
 1424: 		error = EINVAL;
 1425: 	}
 1426: 
 1427: 	return (error);
 1428: }
 1429: 
 1430: /*
 1431:  * This is one of read routines.
 1432:  *
 1433:  * ntnode should be locked.
 1434:  */
 1435: int
 1436: ntfs_readntvattr_plain(struct ntfsmount *ntmp, struct ntnode *ip,
 1437: 		       struct ntvattr *vap, off_t roff, size_t rsize,
 1438: 		       void *rdata, size_t *initp, struct uio *uio)
 1439: {
 1440: 	int             error = 0;
 1441: 	int             off;
 1442: 
 1443: 	*initp = 0;
 1444: 	if (vap->va_flag & NTFS_AF_INRUN) {
 1445: 		int             cnt;
 1446: 		cn_t            ccn, ccl, cn, left, cl;
 1447: 		caddr_t         data = rdata;
 1448: 		struct buf     *bp;
 1449: 		size_t          tocopy;
 1450: 
 1451: 		ddprintf(("ntfs_readntvattr_plain: data in run: %ld chains\n",
 1452: 			 vap->va_vruncnt));
 1453: 
 1454: 		off = roff;
 1455: 		left = rsize;
 1456: 		ccl = 0;
 1457: 		ccn = 0;
 1458: 		cnt = 0;
 1459: 		while (left && (cnt < vap->va_vruncnt)) {
 1460: 			ccn = vap->va_vruncn[cnt];
 1461: 			ccl = vap->va_vruncl[cnt];
 1462: 
 1463: 			ddprintf(("ntfs_readntvattr_plain: " \
 1464: 				 "left %d, cn: 0x%x, cl: %d, off: %d\n", \
 1465: 				 (u_int32_t) left, (u_int32_t) ccn, \
 1466: 				 (u_int32_t) ccl, (u_int32_t) off));
 1467: 
 1468: 			if (ntfs_cntob(ccl) < off) {
 1469: 				off -= ntfs_cntob(ccl);
 1470: 				cnt++;
 1471: 				continue;
 1472: 			}
 1473: 			if (ccn || ip->i_number == NTFS_BOOTINO) {
 1474: 				ccl -= ntfs_btocn(off);
 1475: 				cn = ccn + ntfs_btocn(off);
 1476: 				off = ntfs_btocnoff(off);
 1477: 
 1478: 				while (left && ccl) {
 1479: #if defined(__DragonFly__)
 1480: 					tocopy = min(left,
 1481: 						  min(ntfs_cntob(ccl) - off,
 1482: 						      MAXBSIZE - off));
 1483: #else
 1484: 					/* under NetBSD, bread() can read
 1485: 					 * maximum one block worth of data */
 1486: 					tocopy = min(left,
 1487: 						ntmp->ntm_bps - off);
 1488: #endif
 1489: 					cl = ntfs_btocl(tocopy + off);
 1490: 					ddprintf(("ntfs_readntvattr_plain: " \
 1491: 						"read: cn: 0x%x cl: %d, " \
 1492: 						"off: %d len: %d, left: %d\n",
 1493: 						(u_int32_t) cn, 
 1494: 						(u_int32_t) cl, 
 1495: 						(u_int32_t) off, 
 1496: 						(u_int32_t) tocopy, 
 1497: 						(u_int32_t) left));
 1498: 					error = bread(ntmp->ntm_devvp,
 1499: 						      ntfs_cntobn(cn),
 1500: 						      ntfs_cntob(cl),
 1501: 						      &bp);
 1502: 					if (error) {
 1503: 						brelse(bp);
 1504: 						return (error);
 1505: 					}
 1506: 					if (uio) {
 1507: 						uiomove(bp->b_data + off,
 1508: 							tocopy, uio);
 1509: 					} else {
 1510: 						memcpy(data, bp->b_data + off,
 1511: 							tocopy);
 1512: 					}
 1513: 					brelse(bp);
 1514: 					data = data + tocopy;
 1515: 					*initp += tocopy;
 1516: 					off = 0;
 1517: 					left -= tocopy;
 1518: 					cn += cl;
 1519: 					ccl -= cl;
 1520: 				}
 1521: 			} else {
 1522: 				tocopy = min(left, ntfs_cntob(ccl) - off);
 1523: 				ddprintf(("ntfs_readntvattr_plain: "
 1524: 					"hole: ccn: 0x%x ccl: %d, off: %d, " \
 1525: 					" len: %d, left: %d\n", 
 1526: 					(u_int32_t) ccn, (u_int32_t) ccl, 
 1527: 					(u_int32_t) off, (u_int32_t) tocopy, 
 1528: 					(u_int32_t) left));
 1529: 				left -= tocopy;
 1530: 				off = 0;
 1531: 				if (uio) {
 1532: 					size_t remains = tocopy;
 1533: 					for(; remains; remains++)
 1534: 						uiomove("", 1, uio);
 1535: 				} else 
 1536: 					bzero(data, tocopy);
 1537: 				data = data + tocopy;
 1538: 			}
 1539: 			cnt++;
 1540: 		}
 1541: 		if (left) {
 1542: 			printf("ntfs_readntvattr_plain: POSSIBLE RUN ERROR\n");
 1543: 			error = E2BIG;
 1544: 		}
 1545: 	} else {
 1546: 		ddprintf(("ntfs_readnvattr_plain: data is in mft record\n"));
 1547: 		if (uio) 
 1548: 			uiomove(vap->va_datap + roff, rsize, uio);
 1549: 		else
 1550: 			memcpy(rdata, vap->va_datap + roff, rsize);
 1551: 		*initp += rsize;
 1552: 	}
 1553: 
 1554: 	return (error);
 1555: }
 1556: 
 1557: /*
 1558:  * This is one of read routines.
 1559:  */
 1560: int
 1561: ntfs_readattr_plain(struct ntfsmount *ntmp, struct ntnode *ip,
 1562: 		    u_int32_t attrnum, char *attrname, off_t roff,
 1563: 		    size_t rsize, void *rdata, size_t * initp,
 1564: 		    struct uio *uio)
 1565: {
 1566: 	size_t          init;
 1567: 	int             error = 0;
 1568: 	off_t           off = roff, left = rsize, toread;
 1569: 	caddr_t         data = rdata;
 1570: 	struct ntvattr *vap;
 1571: 	*initp = 0;
 1572: 
 1573: 	while (left) {
 1574: 		error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname,
 1575: 					ntfs_btocn(off), &vap);
 1576: 		if (error)
 1577: 			return (error);
 1578: 		toread = min(left, ntfs_cntob(vap->va_vcnend + 1) - off);
 1579: 		ddprintf(("ntfs_readattr_plain: o: %d, s: %d (%d - %d)\n",
 1580: 			 (u_int32_t) off, (u_int32_t) toread,
 1581: 			 (u_int32_t) vap->va_vcnstart,
 1582: 			 (u_int32_t) vap->va_vcnend));
 1583: 		error = ntfs_readntvattr_plain(ntmp, ip, vap,
 1584: 					 off - ntfs_cntob(vap->va_vcnstart),
 1585: 					 toread, data, &init, uio);
 1586: 		if (error) {
 1587: 			printf("ntfs_readattr_plain: " \
 1588: 			       "ntfs_readntvattr_plain failed: o: %d, s: %d\n",
 1589: 			       (u_int32_t) off, (u_int32_t) toread);
 1590: 			printf("ntfs_readattr_plain: attrib: %d - %d\n",
 1591: 			       (u_int32_t) vap->va_vcnstart, 
 1592: 			       (u_int32_t) vap->va_vcnend);
 1593: 			ntfs_ntvattrrele(vap);
 1594: 			break;
 1595: 		}
 1596: 		ntfs_ntvattrrele(vap);
 1597: 		left -= toread;
 1598: 		off += toread;
 1599: 		data = data + toread;
 1600: 		*initp += init;
 1601: 	}
 1602: 
 1603: 	return (error);
 1604: }
 1605: 
 1606: /*
 1607:  * This is one of read routines.
 1608:  */
 1609: int
 1610: ntfs_readattr(struct ntfsmount *ntmp, struct ntnode *ip, u_int32_t attrnum,
 1611: 	      char *attrname, off_t roff, size_t rsize, void *rdata,
 1612: 	      struct uio *uio)
 1613: {
 1614: 	int             error = 0;
 1615: 	struct ntvattr *vap;
 1616: 	size_t          init;
 1617: 
 1618: 	ddprintf(("ntfs_readattr: reading %d: 0x%x, from %d size %d bytes\n",
 1619: 	       ip->i_number, attrnum, (u_int32_t) roff, (u_int32_t) rsize));
 1620: 
 1621: 	error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname, 0, &vap);
 1622: 	if (error)
 1623: 		return (error);
 1624: 
 1625: 	if ((roff > vap->va_datalen) ||
 1626: 	    (roff + rsize > vap->va_datalen)) {
 1627: 		ddprintf(("ntfs_readattr: offset too big\n"));
 1628: 		ntfs_ntvattrrele(vap);
 1629: 		return (E2BIG);
 1630: 	}
 1631: 	if (vap->va_compression && vap->va_compressalg) {
 1632: 		u_int8_t       *cup;
 1633: 		u_int8_t       *uup;
 1634: 		off_t           off = roff, left = rsize, tocopy;
 1635: 		caddr_t         data = rdata;
 1636: 		cn_t            cn;
 1637: 
 1638: 		ddprintf(("ntfs_ntreadattr: compression: %d\n",
 1639: 			 vap->va_compressalg));
 1640: 
 1641: 		MALLOC(cup, u_int8_t *, ntfs_cntob(NTFS_COMPUNIT_CL),
 1642: 		       M_NTFSDECOMP, M_WAITOK);
 1643: 		MALLOC(uup, u_int8_t *, ntfs_cntob(NTFS_COMPUNIT_CL),
 1644: 		       M_NTFSDECOMP, M_WAITOK);
 1645: 
 1646: 		cn = (ntfs_btocn(roff)) & (~(NTFS_COMPUNIT_CL - 1));
 1647: 		off = roff - ntfs_cntob(cn);
 1648: 
 1649: 		while (left) {
 1650: 			error = ntfs_readattr_plain(ntmp, ip, attrnum,
 1651: 						  attrname, ntfs_cntob(cn),
 1652: 					          ntfs_cntob(NTFS_COMPUNIT_CL),
 1653: 						  cup, &init, NULL);
 1654: 			if (error)
 1655: 				break;
 1656: 
 1657: 			tocopy = min(left, ntfs_cntob(NTFS_COMPUNIT_CL) - off);
 1658: 
 1659: 			if (init == ntfs_cntob(NTFS_COMPUNIT_CL)) {
 1660: 				if (uio)
 1661: 					uiomove(cup + off, tocopy, uio);
 1662: 				else
 1663: 					memcpy(data, cup + off, tocopy);
 1664: 			} else if (init == 0) {
 1665: 				if (uio) {
 1666: 					size_t remains = tocopy;
 1667: 					for(; remains; remains--)
 1668: 						uiomove("", 1, uio);
 1669: 				}
 1670: 				else
 1671: 					bzero(data, tocopy);
 1672: 			} else {
 1673: 				error = ntfs_uncompunit(ntmp, uup, cup);
 1674: 				if (error)
 1675: 					break;
 1676: 				if (uio)
 1677: 					uiomove(uup + off, tocopy, uio);
 1678: 				else
 1679: 					memcpy(data, uup + off, tocopy);
 1680: 			}
 1681: 
 1682: 			left -= tocopy;
 1683: 			data = data + tocopy;
 1684: 			off += tocopy - ntfs_cntob(NTFS_COMPUNIT_CL);
 1685: 			cn += NTFS_COMPUNIT_CL;
 1686: 		}
 1687: 
 1688: 		FREE(uup, M_NTFSDECOMP);
 1689: 		FREE(cup, M_NTFSDECOMP);
 1690: 	} else
 1691: 		error = ntfs_readattr_plain(ntmp, ip, attrnum, attrname,
 1692: 					     roff, rsize, rdata, &init, uio);
 1693: 	ntfs_ntvattrrele(vap);
 1694: 	return (error);
 1695: }
 1696: 
 1697: #if UNUSED_CODE
 1698: int
 1699: ntfs_parserun(cn_t *cn, cn_t *cl, u_int8_t *run, u_long len, u_long *off)
 1700: {
 1701: 	u_int8_t        sz;
 1702: 	int             i;
 1703: 
 1704: 	if (NULL == run) {
 1705: 		printf("ntfs_parsetun: run == NULL\n");
 1706: 		return (EINVAL);
 1707: 	}
 1708: 	sz = run[(*off)++];
 1709: 	if (0 == sz) {
 1710: 		printf("ntfs_parserun: trying to go out of run\n");
 1711: 		return (E2BIG);
 1712: 	}
 1713: 	*cl = 0;
 1714: 	if ((sz & 0xF) > 8 || (*off) + (sz & 0xF) > len) {
 1715: 		printf("ntfs_parserun: " \
 1716: 		       "bad run: length too big: sz: 0x%02x (%ld < %ld + sz)\n",
 1717: 		       sz, len, *off);
 1718: 		return (EINVAL);
 1719: 	}
 1720: 	for (i = 0; i < (sz & 0xF); i++)
 1721: 		*cl += (u_int32_t) run[(*off)++] << (i << 3);
 1722: 
 1723: 	sz >>= 4;
 1724: 	if ((sz & 0xF) > 8 || (*off) + (sz & 0xF) > len) {
 1725: 		printf("ntfs_parserun: " \
 1726: 		       "bad run: length too big: sz: 0x%02x (%ld < %ld + sz)\n",
 1727: 		       sz, len, *off);
 1728: 		return (EINVAL);
 1729: 	}
 1730: 	for (i = 0; i < (sz & 0xF); i++)
 1731: 		*cn += (u_int32_t) run[(*off)++] << (i << 3);
 1732: 
 1733: 	return (0);
 1734: }
 1735: #endif
 1736: 
 1737: /*
 1738:  * Process fixup routine on given buffer.
 1739:  */
 1740: int
 1741: ntfs_procfixups(struct ntfsmount *ntmp, u_int32_t magic, caddr_t buf,
 1742: 		size_t len)
 1743: {
 1744: 	struct fixuphdr *fhp = (struct fixuphdr *) buf;
 1745: 	int             i;
 1746: 	u_int16_t       fixup;
 1747: 	u_int16_t      *fxp;
 1748: 	u_int16_t      *cfxp;
 1749: 
 1750: 	if (fhp->fh_magic != magic) {
 1751: 		printf("ntfs_procfixups: magic doesn't match: %08x != %08x\n",
 1752: 		       fhp->fh_magic, magic);
 1753: 		return (EINVAL);
 1754: 	}
 1755: 	if ((fhp->fh_fnum - 1) * ntmp->ntm_bps != len) {
 1756: 		printf("ntfs_procfixups: " \
 1757: 		       "bad fixups number: %d for %ld bytes block\n", 
 1758: 		       fhp->fh_fnum, (long)len);	/* XXX printf kludge */
 1759: 		return (EINVAL);
 1760: 	}
 1761: 	if (fhp->fh_foff >= ntmp->ntm_spc * ntmp->ntm_mftrecsz * ntmp->ntm_bps) {
 1762: 		printf("ntfs_procfixups: invalid offset: %x", fhp->fh_foff);
 1763: 		return (EINVAL);
 1764: 	}
 1765: 	fxp = (u_int16_t *) (buf + fhp->fh_foff);
 1766: 	cfxp = (u_int16_t *) (buf + ntmp->ntm_bps - 2);
 1767: 	fixup = *fxp++;
 1768: 	for (i = 1; i < fhp->fh_fnum; i++, fxp++) {
 1769: 		if (*cfxp != fixup) {
 1770: 			printf("ntfs_procfixups: fixup %d doesn't match\n", i);
 1771: 			return (EINVAL);
 1772: 		}
 1773: 		*cfxp = *fxp;
 1774: 		((caddr_t) cfxp) += ntmp->ntm_bps;
 1775: 	}
 1776: 	return (0);
 1777: }
 1778: 
 1779: #if UNUSED_CODE
 1780: int
 1781: ntfs_runtocn(cn_t *cn,	struct ntfsmount *ntmp, u_int8_t *run, u_long len,
 1782: 	     cn_t vcn)
 1783: {
 1784: 	cn_t            ccn = 0;
 1785: 	cn_t            ccl = 0;
 1786: 	u_long          off = 0;
 1787: 	int             error = 0;
 1788: 
 1789: #if NTFS_DEBUG
 1790: 	int             i;
 1791: 	printf("ntfs_runtocn: run: 0x%p, %ld bytes, vcn:%ld\n",
 1792: 		run, len, (u_long) vcn);
 1793: 	printf("ntfs_runtocn: run: ");
 1794: 	for (i = 0; i < len; i++)
 1795: 		printf("0x%02x ", run[i]);
 1796: 	printf("\n");
 1797: #endif
 1798: 
 1799: 	if (NULL == run) {
 1800: 		printf("ntfs_runtocn: run == NULL\n");
 1801: 		return (EINVAL);
 1802: 	}
 1803: 	do {
 1804: 		if (run[off] == 0) {
 1805: 			printf("ntfs_runtocn: vcn too big\n");
 1806: 			return (E2BIG);
 1807: 		}
 1808: 		vcn -= ccl;
 1809: 		error = ntfs_parserun(&ccn, &ccl, run, len, &off);
 1810: 		if (error) {
 1811: 			printf("ntfs_runtocn: ntfs_parserun failed\n");
 1812: 			return (error);
 1813: 		}
 1814: 	} while (ccl <= vcn);
 1815: 	*cn = ccn + vcn;
 1816: 	return (0);
 1817: }
 1818: #endif
 1819: 
 1820: /*
 1821:  * this initializes toupper table & dependant variables to be ready for
 1822:  * later work
 1823:  */
 1824: void
 1825: ntfs_toupper_init(void)
 1826: {
 1827: 	ntfs_toupper_tab = (wchar *) NULL;
 1828: 	lockinit(&ntfs_toupper_lock, 0, "ntfs_toupper", 0, 0);
 1829: 	ntfs_toupper_usecount = 0;
 1830: }
 1831: 
 1832: /*
 1833:  * if the ntfs_toupper_tab[] is filled already, just raise use count;
 1834:  * otherwise read the data from the filesystem we are currently mounting
 1835:  */
 1836: int
 1837: ntfs_toupper_use(struct mount *mp, struct ntfsmount *ntmp)
 1838: {
 1839: 	int error = 0;
 1840: 	struct vnode *vp;
 1841: 
 1842: 	/* get exclusive access */
 1843: 	LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
 1844: 	
 1845: 	/* only read the translation data from a file if it hasn't been
 1846: 	 * read already */
 1847: 	if (ntfs_toupper_tab)
 1848: 		goto out;
 1849: 
 1850: 	/*
 1851: 	 * Read in Unicode lowercase -> uppercase translation file.
 1852: 	 * XXX for now, just the first 256 entries are used anyway,
 1853: 	 * so don't bother reading more
 1854: 	 */
 1855: 	MALLOC(ntfs_toupper_tab, wchar *, 65536 * sizeof(wchar),
 1856: 		M_NTFSRDATA, M_WAITOK);
 1857: 
 1858: 	if ((error = VFS_VGET(mp, NTFS_UPCASEINO, &vp)))
 1859: 		goto out;
 1860: 	error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
 1861: 			0, 65536*sizeof(wchar), (char *) ntfs_toupper_tab, NULL);
 1862: 	vput(vp);
 1863: 
 1864:     out:
 1865: 	ntfs_toupper_usecount++;
 1866: 	LOCKMGR(&ntfs_toupper_lock, LK_RELEASE, NULL);
 1867: 	return (error);
 1868: }
 1869: 
 1870: /*
 1871:  * lower the use count and if it reaches zero, free the memory
 1872:  * tied by toupper table
 1873:  */
 1874: void
 1875: ntfs_toupper_unuse(void)
 1876: {
 1877: 	/* get exclusive access */
 1878: 	LOCKMGR(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
 1879: 
 1880: 	ntfs_toupper_usecount--;
 1881: 	if (ntfs_toupper_usecount == 0) {
 1882: 		FREE(ntfs_toupper_tab, M_NTFSRDATA);
 1883: 		ntfs_toupper_tab = NULL;
 1884: 	}
 1885: #ifdef DIAGNOSTIC
 1886: 	else if (ntfs_toupper_usecount < 0) {
 1887: 		panic("ntfs_toupper_unuse(): use count negative: %d\n",
 1888: 			ntfs_toupper_usecount);
 1889: 	}
 1890: #endif
 1891: 	
 1892: 	/* release the lock */
 1893: 	LOCKMGR(&ntfs_toupper_lock, LK_RELEASE, NULL);
 1894: } 
 1895: 
 1896: int
 1897: ntfs_u28_init(struct ntfsmount *ntmp, wchar *u2w)
 1898: {
 1899: 	char ** u28;
 1900: 	int i, j, h, l;
 1901: 
 1902: 	MALLOC(u28, char **, 256 * sizeof(char*), M_TEMP, M_WAITOK | M_ZERO);
 1903: 
 1904: 	for (i=0; i<256; i++) {
 1905: 		h = (u2w[i] >> 8) & 0xFF;
 1906: 		l = (u2w[i]) &0xFF;
 1907: 
 1908: 		if (u28[h] == NULL) {
 1909: 			MALLOC(u28[h], char *, 256 * sizeof(char), M_TEMP, M_WAITOK);
 1910: 			for (j=0; j<256; j++)
 1911: 				u28[h][j] = '_';
 1912: 		}
 1913: 
 1914: 		u28[h][l] = i & 0xFF;
 1915: 	}
 1916: 
 1917: 	ntmp->ntm_u28 = u28;
 1918: 
 1919: 	return (0);
 1920: }
 1921: 
 1922: int
 1923: ntfs_u28_uninit(struct ntfsmount *ntmp)
 1924: {
 1925: 	char ** u28;
 1926: 	int i;
 1927: 
 1928: 	if (ntmp->ntm_u28 == NULL)
 1929: 		return (0);
 1930: 
 1931: 	u28 = ntmp->ntm_u28;
 1932: 
 1933: 	for (i=0; i<256; i++)
 1934: 		if (u28[i] != NULL)
 1935: 			FREE(u28[i], M_TEMP);
 1936: 
 1937: 	FREE(u28, M_TEMP);
 1938: 
 1939: 	return (0);
 1940: }
 1941: 
 1942: int
 1943: ntfs_82u_init(struct ntfsmount *ntmp, u_int16_t *u2w)
 1944: {
 1945: 	wchar * _82u;
 1946: 	int i;
 1947: 
 1948: 	MALLOC(_82u, wchar *, 256 * sizeof(wchar), M_TEMP, M_WAITOK);
 1949: 
 1950: 	if (u2w == NULL) {
 1951: 		for (i=0; i<256; i++)
 1952: 			_82u[i] = i;
 1953: 	} else {
 1954: 		for (i=0; i<128; i++)
 1955: 			_82u[i] = i;
 1956: 		for (i=0; i<128; i++)
 1957: 			_82u[i+128] = u2w[i];
 1958: 	}
 1959: 
 1960: 	ntmp->ntm_82u = _82u;
 1961: 
 1962: 	return (0);
 1963: }
 1964: 
 1965: int
 1966: ntfs_82u_uninit(struct ntfsmount *ntmp)
 1967: {
 1968: 	FREE(ntmp->ntm_82u, M_TEMP);
 1969: 	return (0);
 1970: }
 1971: 
 1972: /*
 1973:  * maps the Unicode char to 8bit equivalent
 1974:  * XXX currently only gets lower 8bit from the Unicode char
 1975:  * and substitutes a '_' for it if the result would be '\0';
 1976:  * something better has to be definitely though out
 1977:  */
 1978: char
 1979: ntfs_u28(struct ntfsmount *ntmp, wchar wc)
 1980: {
 1981: 	char * p;
 1982: 
 1983: 	p = ntmp->ntm_u28[(wc>>8)&0xFF];
 1984: 	if (p == NULL)
 1985: 		return ('_');
 1986: 	return (p[wc&0xFF]);
 1987: }
 1988: