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