![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsys_ntfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs|
Return to fsys_ntfs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 ! root 1: /* vim: set sw=4 :*/ ! 2: /* ! 3: * GRUB -- GRand Unified Bootloader ! 4: * Copyright (C) 1999 Free Software Foundation, Inc. ! 5: * ! 6: * This program is free software; you can redistribute it and/or modify ! 7: * it under the terms of the GNU General Public License as published by ! 8: * the Free Software Foundation; either version 2 of the License, or ! 9: * (at your option) any later version. ! 10: * ! 11: * This program is distributed in the hope that it will be useful, ! 12: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: * GNU General Public License for more details. ! 15: * ! 16: * You should have received a copy of the GNU General Public License ! 17: * along with this program; if not, write to the Free Software ! 18: * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, ! 19: * MA 02110-1301, USA. ! 20: */ ! 21: ! 22: /* ! 23: * Samuel Leo <samuel@_.remove.me._szonline.net> ! 24: * Limitations: ! 25: * 1. Only 32 bit size support ! 26: * 2. don't support >1k MFT record size, >16k INDEX record size ! 27: * 3. don't support recursive at_attribute_list ! 28: * 4. don't support compressed attribute other than Datastream ! 29: * 5. all MFT's at_attribute_list must resident at first run list ! 30: * 6. don't support journaling ! 31: * 7. don't support EFS encryption ! 32: * 8. don't support mount point and junction ! 33: */ ! 34: #ifdef FSYS_NTFS ! 35: ! 36: //#define DEBUG_NTFS 1 ! 37: ! 38: /* ! 39: #define NO_ATTRIBUTE_LIST 1 ! 40: totally disable at_attribute_list support, ! 41: if no compressed/fragment file and MFT, ! 42: not recommended ! 43: #define NO_NON_RESIDENT_ATTRIBUTE_LIST 1 ! 44: disable non-resident at_attribute_list support, ! 45: if no huge compressed/fragment file and MFT ! 46: #define NO_NTFS_DECOMPRESSION 1 ! 47: disable ntfs compressed file support ! 48: #define NO_ALTERNATE_DATASTREAM 1 ! 49: disable ntfs alternate datastream support ! 50: */ ! 51: ! 52: #include "shared.h" ! 53: #include "filesys.h" ! 54: ! 55: #ifdef STAGE1_5 ! 56: /* safe turn off non-resident attribute list if MFT fragments < 4000 */ ! 57: //#define NO_NON_RESIDENT_ATTRIBUTE_LIST 1 ! 58: #define NO_NTFS_DECOMPRESSION 1 ! 59: #endif ! 60: ! 61: #define MAX_MFT_RECORD_SIZE 1024 ! 62: #define MAX_INDEX_RECORD_SIZE 16384 ! 63: #define MAX_INDEX_BITMAP_SIZE 4096 ! 64: #define DECOMP_DEST_BUFFER_SIZE 16384 ! 65: #define DECOMP_SOURCE_BUFFER_SIZE (8192+2) ! 66: #define MAX_DIR_DEPTH 64 ! 67: ! 68: /* sizes are always in bytes, BLOCK values are always in DEV_BSIZE (sectors) */ ! 69: #define DEV_BSIZE 512 ! 70: ! 71: /* include/linux/fs.h */ ! 72: #define BLOCK_SIZE 512 ! 73: ! 74: #define WHICH_SUPER 1 ! 75: #define SBLOCK (WHICH_SUPER * BLOCK_SIZE / DEV_BSIZE) /* = 2 */ ! 76: ! 77: /* include/asm-i386/type.h */ ! 78: typedef __signed__ char __s8; ! 79: typedef unsigned char __u8; ! 80: typedef __signed__ short __s16; ! 81: typedef unsigned short __u16; ! 82: typedef __signed__ int __s32; ! 83: typedef unsigned int __u32; ! 84: typedef __signed__ long long __s64; ! 85: typedef unsigned long long __u64; ! 86: ! 87: #define FILE_MFT 0 ! 88: #define FILE_MFTMIRR 1 ! 89: #define FILE_LOGFILE 2 ! 90: #define FILE_VOLUME 3 ! 91: #define FILE_ATTRDEF 4 ! 92: #define FILE_ROOT 5 ! 93: #define FILE_BITMAP 6 ! 94: #define FILE_BOOT 7 ! 95: #define FILE_BADCLUS 8 ! 96: #define FILE_QUOTA 9 ! 97: #define FILE_UPCASE 10 ! 98: ! 99: #define at_standard_information 0x10 ! 100: #define at_attribute_list 0x20 ! 101: #define at_filename 0x30 ! 102: #define at_security_descriptor 0x50 ! 103: #define at_data 0x80 ! 104: #define at_index_root 0x90 ! 105: #define at_index_allocation 0xa0 ! 106: #define at_bitmap 0xb0 ! 107: #define at_symlink 0xc0 ! 108: ! 109: #define NONAME "" ! 110: #define ATTR_NORMAL 0 ! 111: #define ATTR_COMPRESSED 1 ! 112: #define ATTR_RESIDENT 2 ! 113: #define ATTR_ENCRYPTED 16384 ! 114: #define ATTR_SPARSE 32768 ! 115: ! 116: typedef struct run_list { ! 117: char *start; ! 118: char *ptr; ! 119: int svcn; ! 120: int evcn; ! 121: int vcn; ! 122: int cnum0; ! 123: int cnum; ! 124: int clen; ! 125: } RUNL; ! 126: ! 127: typedef struct ntfs_mft_record { ! 128: char mft[MAX_MFT_RECORD_SIZE]; ! 129: char mft2[MAX_MFT_RECORD_SIZE]; ! 130: int attr_type; ! 131: char *attr_name; ! 132: int attr_flag; ! 133: int attr_size; ! 134: char *attr; ! 135: int attr_len; ! 136: RUNL runl; ! 137: char *attr_list; ! 138: int attr_list_len; ! 139: int attr_list_size; ! 140: int attr_list_off; ! 141: int attr_inited; ! 142: char attr_list_buf[2*BLOCK_SIZE]; ! 143: RUNL attr_list_runl; ! 144: } MFTR; ! 145: ! 146: ! 147: #define index_data ((char *)FSYS_BUF) ! 148: #define bitmap_data ((__u8 *)(FSYS_BUF+MAX_INDEX_RECORD_SIZE)) ! 149: #define dcdbuf ((__u8 *)index_data) ! 150: #define dcsbuf (bitmap_data) ! 151: #define dcend (dcsbuf+DECOMP_SOURCE_BUFFER_SIZE) ! 152: #define fnbuf ((char *)(bitmap_data+MAX_INDEX_BITMAP_SIZE)) ! 153: #define mmft ((MFTR *)dcend) ! 154: #define cmft ((MFTR *)(dcend+sizeof(MFTR))) ! 155: #define mft_run ((RUNL *)(dcend+2*sizeof(MFTR))) ! 156: #define path_ino ((int *)(dcend+2*sizeof(MFTR)+sizeof(RUNL))) ! 157: #define cluster16 (path_ino+MAX_DIR_DEPTH) ! 158: #define index16 cluster16[16] ! 159: #define blocksize cluster16[17] ! 160: #define clustersize cluster16[18] ! 161: #define mft_record_size cluster16[19] ! 162: #define index_record_size cluster16[20] ! 163: #define dcvcn cluster16[21] ! 164: #define dcoff cluster16[22] ! 165: #define dclen cluster16[23] ! 166: #define dcrem cluster16[24] ! 167: #define dcslen cluster16[25] ! 168: #define dcsptr ((__u8 *)cluster16[26]) ! 169: #define is_ads_completion cluster16[27] ! 170: ! 171: static int read_mft_record(int mftno, char *mft, int self); ! 172: static int read_attribute(MFTR *mftr, int offset, char *buf, int len, RUNL *from_rl); ! 173: static int get_next_run(RUNL *runl); ! 174: ! 175: static inline int ! 176: nsubstring (char *s1, char *s2) ! 177: { ! 178: while (tolower(*s1) == tolower(*s2)) ! 179: { ! 180: /* The strings match exactly. */ ! 181: if (! *(s1++)) ! 182: return 0; ! 183: s2 ++; ! 184: } ! 185: ! 186: /* S1 is a substring of S2. */ ! 187: if (*s1 == 0) ! 188: return -1; ! 189: ! 190: /* S1 isn't a substring. */ ! 191: return 1; ! 192: } ! 193: ! 194: static int fixup_record(char *record, char *magic, int size) ! 195: { ! 196: int start, count, offset; ! 197: __u16 fixup; ! 198: ! 199: if(*(int *)record != *(int *)magic) ! 200: return 0; ! 201: start=*(__u16 *)(record+4); ! 202: count=*(__u16 *)(record+6); ! 203: count--; ! 204: if(size && blocksize*count != size) ! 205: return 0; ! 206: fixup = *(__u16 *)(record+start); ! 207: start+=2; ! 208: offset=blocksize-2; ! 209: while(count--){ ! 210: if(*(__u16 *)(record+offset)!=fixup) ! 211: return 0; ! 212: *(__u16 *)(record+offset) = *(__u16 *)(record+start); ! 213: start+=2; ! 214: offset+=blocksize; ! 215: } ! 216: return 1; ! 217: } ! 218: ! 219: static void rewind_run_list( RUNL *runl) { ! 220: runl->vcn = runl->svcn; ! 221: runl->ptr = runl->start; ! 222: runl->cnum0 = 0; ! 223: runl->cnum = 0; ! 224: runl->clen = 0; ! 225: } ! 226: ! 227: static int get_next_run(RUNL *runl){ ! 228: int t, n, v; ! 229: ! 230: #ifdef DEBUG_NTFS ! 231: printf("get_next_run: s=%d e=%d c=%d start=%x ptr=%x\n", ! 232: runl->svcn, runl->evcn, runl->vcn, runl->start, runl->ptr); ! 233: #endif ! 234: ! 235: runl->vcn += runl->clen; ! 236: if(runl->vcn > runl->evcn) { ! 237: return 0; ! 238: } ! 239: ! 240: t = *(runl->ptr)++; ! 241: n = t&0xf; ! 242: runl->clen = 0; v = 1; ! 243: while(n--) { ! 244: runl->clen += v * *((__u8 *)runl->ptr)++; ! 245: v <<= 8; ! 246: } ! 247: n = (t>>4)&0xf; ! 248: if(n==0) ! 249: runl->cnum = 0; ! 250: else { ! 251: int c = 0; ! 252: v = 1; ! 253: while(n--) { ! 254: c += v * *((__u8 *)runl->ptr)++; ! 255: v <<= 8; ! 256: } ! 257: if(c & (v>>1)) c -= v; ! 258: runl->cnum0 += c; ! 259: runl->cnum = runl->cnum0; ! 260: } ! 261: #ifdef DEBUG_NTFS ! 262: printf("got_next_run: t=%x cluster %x len %x vcn=%x ecn=%x\n", ! 263: t, runl->cnum, runl->clen, runl->vcn, runl->evcn); ! 264: #endif ! 265: return 1; ! 266: } ! 267: ! 268: #ifndef NO_ATTRIBUTE_LIST ! 269: static void init_run_list(char *attr, int len, RUNL *runl, __u32 *initp) { ! 270: int allocated; ! 271: ! 272: runl->svcn = *(__u32 *)(attr+0x10); /* only support 32 bit */ ! 273: runl->evcn = *(__u32 *)(attr+0x18); /* only support 32 bit */ ! 274: runl->start = attr + *(__u16 *)(attr+0x20); ! 275: allocated = *(__u32 *)(attr+0x28); ! 276: if(initp) *initp = *(__u32 *)(attr+0x38); ! 277: if(!runl->evcn) runl->evcn = (allocated - 1) / clustersize; ! 278: #ifdef DEBUG_NTFS ! 279: printf("size %d allocated=%d inited=%d cegin=%x csize=%d vcn=%d-%d\n", ! 280: /*attr_size*/ *(__u32 *)(attr+0x30), ! 281: /*allocated*/ *(__u32 *)(attr+0x28), ! 282: /*attr_inited*/ *(__u32 *)(attr+0x38), ! 283: /*cengin*/ *(__u16 *)(attr+0x22), ! 284: /*csize*/ *(__u16 *)(attr+0x40), ! 285: runl->svcn, runl->evcn); ! 286: #endif ! 287: rewind_run_list(runl); ! 288: } ! 289: #endif ! 290: ! 291: ! 292: static int find_attribute(char *mft, int type, char *name, char **attr, int *size, int *len, int *flag) { ! 293: int t, l, r, n, i, namelen; ! 294: unsigned short *attr_name; ! 295: ! 296: n = strlen(name); ! 297: r = mft_record_size - *(__u16 *)(mft+0x14); ! 298: mft += *(__u16 *)(mft+0x14); ! 299: while( (t = *(__s32 *)mft) != -1 ) { ! 300: l = *(__u32 *)(mft+4); ! 301: if(l>r) break; ! 302: #ifdef DEBUG_NTFS ! 303: printf("type = %x len = %d namelen=%d resident=%d compresed=%d attrno=%d\n", ! 304: t, l, ! 305: /*namelen*/ *(mft+9), ! 306: //name = (__u16 *)(mft + *(__u16 *)(mft+10)), ! 307: /*resident */ (*(mft+8) == 0), ! 308: /*compressed*/ *(__u16 *)(mft+12), ! 309: /*attrno*/ *(__u16 *)(mft+14)); ! 310: #endif ! 311: namelen = *(mft+9); ! 312: if(t == type) { ! 313: #ifndef STAGE1_5 ! 314: #ifndef NO_ALTERNATE_DATASTREAM ! 315: if(is_ads_completion && type == at_data) { ! 316: if(namelen && namelen >= n && ! 317: (!*(mft+8)/*resident*/ || !*(__u32 *)(attr+0x10)/*svcn==0*/)) ! 318: { ! 319: for(i=0, attr_name=(__u16 *)(mft + *(__u16 *)(mft+10)); i < n; i++) ! 320: if(tolower(name[i]) != tolower(attr_name[i])) ! 321: break; ! 322: if(i >= n) { ! 323: for(; i < namelen; i++) ! 324: name[i] = attr_name[i]; ! 325: name[i] = '\0'; ! 326: if(print_possibilities > 0) ! 327: print_possibilities = -print_possibilities; ! 328: print_a_completion(fnbuf); ! 329: name[n] = '\0'; ! 330: } ! 331: } ! 332: } else ! 333: #endif ! 334: #endif ! 335: if(namelen == n) { ! 336: ! 337: for(i=0, attr_name=(__u16 *)(mft + *(__u16 *)(mft+10)); i<n; i++) ! 338: if(tolower(name[i]) != tolower(attr_name[i])) ! 339: break; ! 340: if(i>=n) { ! 341: if(flag) *flag = *(__u16 *)(mft+12); ! 342: if(*(mft+8) == 0) { ! 343: if(flag) *flag |= ATTR_RESIDENT; ! 344: #ifdef DEBUG_NTFS ! 345: printf("resident data at %x size %x indexed=%d\n", ! 346: /*data*/ *(__u16 *)(mft+0x14), ! 347: /*attr_size*/ *(__u16 *)(mft+0x10), ! 348: /*indexed*/ *(__u16 *)(mft+0x16)); ! 349: #endif ! 350: if(attr) *attr = mft + *(__u16 *)(mft+0x14); ! 351: if(size) *size = *(__u16 *)(mft+0x10); ! 352: if(len) *len = *(__u16 *)(mft+0x10); ! 353: } else { ! 354: if(attr) *attr = mft; ! 355: if(size) *size = *(__u32 *)(mft+0x30); ! 356: if(len) *len = l; ! 357: } ! 358: return 1; ! 359: } ! 360: } ! 361: } ! 362: mft += l; ! 363: r -= l; ! 364: } ! 365: return 0; ! 366: } ! 367: ! 368: #ifndef NO_ATTRIBUTE_LIST ! 369: static __u32 get_next_attribute_list(MFTR *mftr, int *size) { ! 370: int l, t, mftno; ! 371: #ifdef DEBUG_NTFS ! 372: printf("get_next_attribute_list: type=%x\n",mftr->attr_type); ! 373: #endif ! 374: again: ! 375: while(mftr->attr_list_len>0x14) { ! 376: t = *(__u32 *)(mftr->attr_list + 0); ! 377: l = *(__u16 *)(mftr->attr_list + 4); ! 378: #ifdef DEBUG_NTFS ! 379: printf("attr_list type=%x len=%x remain=%x\n", t, l, mftr->attr_list_len); ! 380: #endif ! 381: if(l==0 || l>mftr->attr_list_len) return 0; ! 382: mftno = *(__u32 *)(mftr->attr_list + 0x10); ! 383: mftr->attr_list_len -= l; ! 384: mftr->attr_list += l; ! 385: if(t==mftr->attr_type) ! 386: { ! 387: #ifdef DEBUG_NTFS ! 388: printf("attr_list mftno=%x\n", mftno); ! 389: #endif ! 390: if(read_mft_record(mftno, mftr->mft2, (mftr==mmft))==0) ! 391: break; ! 392: if(find_attribute(mftr->mft2, mftr->attr_type, mftr->attr_name, ! 393: &mftr->attr, size, &mftr->attr_len, &mftr->attr_flag)) ! 394: return 1; ! 395: } ! 396: } ! 397: #ifndef NO_NON_RESIDENT_ATTRIBUTE_LIST ! 398: if(mftr->attr_list_off < mftr->attr_list_size) { ! 399: int len = mftr->attr_list_size - mftr->attr_list_off; ! 400: if(len > BLOCK_SIZE) len = BLOCK_SIZE; ! 401: ! 402: if(mftr->attr_list_len) ! 403: memmove(mftr->attr_list_buf, mftr->attr_list, mftr->attr_list_len); ! 404: mftr->attr_list = mftr->attr_list_buf; ! 405: ! 406: if(read_attribute( NULL, mftr->attr_list_off, ! 407: mftr->attr_list_buf + mftr->attr_list_len, ! 408: len, &mftr->attr_list_runl) != len) ! 409: { ! 410: #ifdef DEBUG_NTFS ! 411: printf("CORRUPT NON-RESIDENT ATTRIBUTE_LIST\n"); ! 412: #endif ! 413: /* corrupt */ ! 414: errnum = ERR_FSYS_CORRUPT; ! 415: mftr->attr_list_size = 0; ! 416: mftr->attr_len = 0; ! 417: mftr->attr_list = NULL; ! 418: return 0; ! 419: } ! 420: ! 421: mftr->attr_list_len += len; ! 422: mftr->attr_list_off += len; ! 423: goto again; ! 424: } ! 425: #endif ! 426: mftr->attr_list = NULL; ! 427: return 0; ! 428: } ! 429: #endif ! 430: ! 431: static int search_attribute( MFTR *mftr, int type, char *name) ! 432: { ! 433: #ifdef DEBUG_NTFS ! 434: printf("searching attribute %x <%s>\n", type, name); ! 435: #endif ! 436: ! 437: mftr->attr_type = type; ! 438: mftr->attr_name = name; ! 439: mftr->attr_list = NULL; ! 440: mftr->attr_list_len = 0; ! 441: mftr->attr_list_size = 0; ! 442: mftr->attr_list_off = 0; ! 443: dcrem = dclen = 0; ! 444: ! 445: #ifndef NO_ATTRIBUTE_LIST ! 446: if(find_attribute(mftr->mft, at_attribute_list, NONAME, ! 447: &mftr->attr_list, &mftr->attr_list_size, ! 448: &mftr->attr_list_len, &mftr->attr_list_off)) { ! 449: if(mftr->attr_list_off&ATTR_RESIDENT) { ! 450: /* resident at_attribute_list */ ! 451: mftr->attr_list_size = 0; ! 452: #ifdef DEBUG_NTFS ! 453: printf("resident attribute_list len=%x\n", mftr->attr_list_len); ! 454: #endif ! 455: } else { ! 456: #ifdef DEBUG_NTFS ! 457: printf("non-resident attribute_list len=%x size=%x\n", ! 458: mftr->attr_list_len, mftr->attr_list_size); ! 459: #endif ! 460: #ifndef NO_NON_RESIDENT_ATTRIBUTE_LIST ! 461: init_run_list(mftr->attr_list, mftr->attr_list_len, &mftr->attr_list_runl, NULL); ! 462: if(get_next_run(&mftr->attr_list_runl)==0 || ! 463: mftr->attr_list_runl.cnum==0) ! 464: mftr->attr_list_size = 0; ! 465: #endif ! 466: mftr->attr_list = NULL; ! 467: mftr->attr_list_len = 0; ! 468: } ! 469: } ! 470: #endif ! 471: ! 472: if(find_attribute(mftr->mft, type, name, ! 473: &mftr->attr, &mftr->attr_size, &mftr->attr_len, ! 474: &mftr->attr_flag) ! 475: #ifndef NO_ATTRIBUTE_LIST ! 476: || get_next_attribute_list(mftr, &mftr->attr_size) ! 477: #endif ! 478: ) ! 479: { ! 480: #ifndef NO_ATTRIBUTE_LIST ! 481: if(!(mftr->attr_flag&ATTR_RESIDENT)){ ! 482: init_run_list(mftr->attr, mftr->attr_len, &mftr->runl, &mftr->attr_inited); ! 483: if(mftr->attr_inited > mftr->attr_size) ! 484: mftr->attr_inited = mftr->attr_size; ! 485: if(get_next_run(&mftr->runl)==0) { ! 486: mftr->attr_flag |= ATTR_RESIDENT; ! 487: mftr->attr_len = 0; ! 488: } ! 489: } else ! 490: mftr->attr_inited = mftr->attr_size; ! 491: #endif ! 492: ! 493: return 1; ! 494: } ! 495: ! 496: mftr->attr_type = 0; ! 497: return 0; ! 498: } ! 499: ! 500: static int get_run( RUNL *rl, int vcn, int *clp, int *lenp) { ! 501: if(rl->evcn < vcn) ! 502: return 0; ! 503: ! 504: if(rl->vcn > vcn) { ! 505: rewind_run_list(rl); ! 506: get_next_run(rl); ! 507: } ! 508: ! 509: while(rl->vcn+rl->clen <= vcn) ! 510: { ! 511: if(get_next_run(rl)==0) ! 512: return 0; ! 513: } ! 514: ! 515: if(clp) *clp = rl->cnum == 0 ? 0 : rl->cnum + vcn - rl->vcn; ! 516: if(lenp) *lenp = rl->clen - vcn + rl->vcn; ! 517: return 1; ! 518: } ! 519: ! 520: static int search_run(MFTR *mftr, int vcn) { ! 521: ! 522: if( mftr->attr==NULL && !search_attribute(mftr, mftr->attr_type, mftr->attr_name)) ! 523: return 0; ! 524: ! 525: if(mftr->runl.svcn > vcn) ! 526: search_attribute(mftr, mftr->attr_type, mftr->attr_name); ! 527: ! 528: #ifdef NO_ATTRIBUTE_LIST ! 529: if(mftr->runl.evcn < vcn) ! 530: return 0; ! 531: #else ! 532: while(mftr->runl.evcn < vcn) { ! 533: if(get_next_attribute_list(mftr, NULL)==0) { ! 534: mftr->attr = NULL; ! 535: return 0; ! 536: } ! 537: init_run_list(mftr->attr, mftr->attr_len, &mftr->runl, NULL); ! 538: if(get_next_run(&mftr->runl)==0) { ! 539: mftr->attr = NULL; ! 540: return 0; ! 541: } ! 542: } ! 543: #endif ! 544: ! 545: return 1; ! 546: } ! 547: ! 548: static int read_attribute(MFTR *mftr, int offset, char *buf, int len, RUNL *from_rl) { ! 549: int vcn; ! 550: int cnum, clen; ! 551: int done = 0; ! 552: int n; ! 553: RUNL *rl; ! 554: ! 555: if(!from_rl && (mftr->attr_flag & ATTR_RESIDENT)) { ! 556: /* resident attribute */ ! 557: if(offset > mftr->attr_len) ! 558: return 0; ! 559: if(offset+len > mftr->attr_len) ! 560: len = mftr->attr_len - offset; ! 561: memmove( buf, mftr->attr + offset, len); ! 562: return len; ! 563: } ! 564: ! 565: vcn = offset / clustersize; ! 566: offset %= clustersize; ! 567: ! 568: while(len>0) { ! 569: if(from_rl) ! 570: rl = from_rl; ! 571: else if(search_run(mftr, vcn) == 0) ! 572: break; ! 573: else ! 574: rl = &mftr->runl; ! 575: if(get_run(rl, vcn, &cnum, &clen) == 0) ! 576: break; ! 577: if(cnum==0 && from_rl) ! 578: break; ! 579: n = clen * clustersize - offset; ! 580: if(n > len) n = len; ! 581: if(cnum==0) { ! 582: memset( buf, 0, n); ! 583: } else if(!devread(cnum*(clustersize>>9)+(offset>>9), offset&0x1ff, n, buf)) ! 584: break; ! 585: ! 586: buf += n; ! 587: vcn += (offset+n)/clustersize; ! 588: done += n; ! 589: offset = 0; ! 590: len -= n; ! 591: } ! 592: return done; ! 593: } ! 594: ! 595: static int read_mft_record(int mftno, char *mft, int self){ ! 596: #ifdef DEBUG_NTFS ! 597: printf("Reading MFT record: mftno=%d\n", mftno); ! 598: #endif ! 599: if( read_attribute( mmft, mftno * mft_record_size, ! 600: mft, mft_record_size, self?mft_run:NULL) != mft_record_size) ! 601: return 0; ! 602: if(!fixup_record( mft, "FILE", mft_record_size)) ! 603: return 0; ! 604: return 1; ! 605: } ! 606: ! 607: #ifndef NO_NTFS_DECOMPRESSION ! 608: static int get_16_cluster(MFTR *mftr, int vcn) { ! 609: int n = 0, cnum, clen; ! 610: while(n < 16 && search_run(mftr, vcn) && get_run(&mftr->runl, vcn, &cnum, &clen) && cnum) { ! 611: if(clen > 16 - n) ! 612: clen = 16 - n; ! 613: vcn += clen; ! 614: while(clen--) ! 615: cluster16[n++] = cnum++; ! 616: } ! 617: cluster16[n] = 0; ! 618: return n; ! 619: } ! 620: ! 621: static inline int compressed_block_size( unsigned char *src ) { ! 622: return 3 + (*(__u16 *)src & 0xfff); ! 623: } ! 624: ! 625: static int decompress_block(unsigned char *dest, unsigned char *src) { ! 626: int head; ! 627: int copied=0; ! 628: unsigned char *last; ! 629: int bits; ! 630: int tag=0; ! 631: ! 632: /* high bit indicates that compression was performed */ ! 633: if(!(*(__u16 *)src & 0x8000)) { ! 634: memmove(dest,src+2,0x1000); ! 635: return 0x1000; ! 636: } ! 637: ! 638: if((head = *(__u16 *)src & 0xFFF)==0) ! 639: /* block is not used */ ! 640: return 0; ! 641: ! 642: src += 2; ! 643: last = src+head; ! 644: bits = 0; ! 645: ! 646: while(src<=last) ! 647: { ! 648: if(copied>4096) ! 649: { ! 650: #ifdef DEBUG_NTFS ! 651: printf("decompress error 1\n"); ! 652: #endif ! 653: errnum = ERR_FSYS_CORRUPT; ! 654: return 0; ! 655: } ! 656: if(!bits){ ! 657: tag=*(__u8 *)src; ! 658: bits=8; ! 659: src++; ! 660: if(src>last) ! 661: break; ! 662: } ! 663: if(tag & 1){ ! 664: int i,len,delta,code,lmask,dshift; ! 665: code = *(__u16 *)src; ! 666: src+=2; ! 667: if(!copied) ! 668: { ! 669: #ifdef DEBUG_NTFS ! 670: printf("decompress error 2\n"); ! 671: #endif ! 672: errnum = ERR_FSYS_CORRUPT; ! 673: return 0; ! 674: } ! 675: for(i=copied-1,lmask=0xFFF,dshift=12;i>=0x10;i>>=1) ! 676: { ! 677: lmask >>= 1; ! 678: dshift--; ! 679: } ! 680: delta = code >> dshift; ! 681: len = (code & lmask) + 3; ! 682: for(i=0; i<len; i++) ! 683: { ! 684: dest[copied]=dest[copied-delta-1]; ! 685: copied++; ! 686: } ! 687: } else ! 688: dest[copied++]=*(__u8 *)src++; ! 689: tag>>=1; ! 690: bits--; ! 691: } ! 692: ! 693: return copied; ! 694: } ! 695: #endif ! 696: ! 697: int ntfs_read(char *buf, int len){ ! 698: int ret; ! 699: #ifdef STAGE1_5 ! 700: /* stage2 can't be resident/compressed/encrypted files, ! 701: * but does sparse flag, cause stage2 never sparsed ! 702: */ ! 703: if((cmft->attr_flag&~ATTR_SPARSE) != ATTR_NORMAL) ! 704: return 0; ! 705: disk_read_func = disk_read_hook; ! 706: ret = read_attribute(cmft, filepos, buf, len, 0); ! 707: disk_read_func = NULL; ! 708: filepos += ret; ! 709: #else ! 710: ! 711: #ifndef NO_NTFS_DECOMPRESSION ! 712: int off; ! 713: int vcn; ! 714: int size; ! 715: int len0; ! 716: #endif ! 717: ! 718: if(len<=0 || filepos >= cmft->attr_size || (cmft->attr_flag&ATTR_ENCRYPTED)) ! 719: return 0; ! 720: ! 721: if(filepos+len > cmft->attr_size) ! 722: len = cmft->attr_size - filepos; ! 723: if(filepos >= cmft->attr_inited) { ! 724: #ifdef DEBUG_NTFS ! 725: printf("reading uninitialized data 1\n"); ! 726: #endif ! 727: memset(buf, 0, len); ! 728: return len; ! 729: } else if(filepos+len > cmft->attr_inited) { ! 730: len0 = len; ! 731: len = cmft->attr_inited - filepos; ! 732: len0 -= len; ! 733: } else ! 734: len0 = 0; ! 735: #ifdef DEBUG_NTFS ! 736: printf("read filepos=%x filemax=%x inited=%x len=%x len0=%x\n",filepos,filemax,cmft->attr_inited,len,len0); ! 737: #endif ! 738: ! 739: if((cmft->attr_flag&(ATTR_COMPRESSED|ATTR_RESIDENT)) != ATTR_COMPRESSED) { ! 740: if(cmft->attr_flag==ATTR_NORMAL) ! 741: disk_read_func = disk_read_hook; ! 742: ret = read_attribute(cmft, filepos, buf, len, 0); ! 743: if(cmft->attr_flag==ATTR_NORMAL) ! 744: disk_read_func = NULL; ! 745: filepos += ret; ! 746: if(ret==len && len0) { ! 747: memset(buf+len, 0, len0); ! 748: filepos += len0; ! 749: ret += len0; ! 750: } ! 751: return ret; ! 752: } ! 753: ! 754: ret = 0; ! 755: ! 756: #ifndef NO_NTFS_DECOMPRESSION ! 757: /* NTFS don't support compression if cluster size > 4k */ ! 758: if(clustersize > 4096) { ! 759: errnum = ERR_FSYS_CORRUPT; ! 760: return 0; ! 761: } ! 762: ! 763: while(len > 0){ ! 764: #ifdef DEBUG_NTFS ! 765: printf("Reading filepos=%x len=%x\n", filepos, len); ! 766: #endif ! 767: if(filepos >= dcoff && filepos < (dcoff+dclen)) { ! 768: #ifdef DEBUG_NTFS ! 769: printf("decompress cache %x+%x\n", dcoff, dclen); ! 770: #endif ! 771: size = dcoff + dclen - filepos; ! 772: if(size > len) size = len; ! 773: memmove( buf, dcdbuf + filepos - dcoff, size); ! 774: filepos += size; ! 775: len -= size; ! 776: ret += size; ! 777: buf += size; ! 778: if(len==0) { ! 779: if(len0) { ! 780: #ifdef DEBUG_NTFS ! 781: printf("reading uninitialized data 2\n"); ! 782: #endif ! 783: memset(buf, 0, len0); ! 784: filepos += len0; ! 785: ret += len0; ! 786: } ! 787: return ret; ! 788: } ! 789: } ! 790: ! 791: vcn = filepos / clustersize / 16; ! 792: vcn *= 16; ! 793: off = filepos % (16 * clustersize); ! 794: if( dcvcn != vcn || filepos < dcoff) ! 795: dcrem = 0; ! 796: ! 797: #ifdef DEBUG_NTFS ! 798: printf("vcn %x off %x dcrem %x\n", vcn, off, dcrem); ! 799: #endif ! 800: if(dcrem) { ! 801: int head; ! 802: ! 803: /* reading source */ ! 804: if(dcslen < 2 || compressed_block_size(dcsptr) > dcslen) { ! 805: if(cluster16[index16]==0) { ! 806: errnum = ERR_FSYS_CORRUPT; ! 807: return ret; ! 808: } ! 809: if(dcslen) ! 810: memmove(dcsbuf, dcsptr, dcslen); ! 811: dcsptr = dcsbuf; ! 812: while((dcslen+clustersize) < DECOMP_SOURCE_BUFFER_SIZE) { ! 813: if(cluster16[index16]==0) ! 814: break; ! 815: #ifdef DEBUG_NTFS ! 816: printf("reading dcslen=%x cluster %x\n", dcslen, cluster16[index16]); ! 817: #endif ! 818: if(!devread(cluster16[index16]*(clustersize>>9), 0, clustersize, dcsbuf+dcslen)) ! 819: return ret; ! 820: dcslen += clustersize; ! 821: index16++; ! 822: } ! 823: } ! 824: /* flush destination */ ! 825: dcoff += dclen; ! 826: dclen = 0; ! 827: ! 828: while(dcrem && dclen < DECOMP_DEST_BUFFER_SIZE && ! 829: dcslen >= 2 && (head=compressed_block_size(dcsptr)) <= dcslen) { ! 830: size = decompress_block(dcdbuf+dclen, dcsptr); ! 831: if(dcrem>=0x1000 && size!=0x1000) { ! 832: errnum = ERR_FSYS_CORRUPT; ! 833: return ret; ! 834: } ! 835: dcrem -= size; ! 836: dclen += size; ! 837: dcsptr += head; ! 838: dcslen -= head; ! 839: } ! 840: continue; ! 841: } ! 842: dclen = dcrem = 0; ! 843: #ifdef DEBUG_NTFS ! 844: printf("get next 16 clusters\n"); ! 845: #endif ! 846: switch(get_16_cluster(cmft, vcn)) { ! 847: case 0: ! 848: #ifdef DEBUG_NTFS ! 849: printf("sparse\n"); ! 850: #endif ! 851: /* sparse */ ! 852: size = 16 * clustersize - off; ! 853: if( len < size ) ! 854: size = len; ! 855: #ifndef STAGE1_5 ! 856: memset( buf, 0, size); ! 857: #endif ! 858: filepos += size; ! 859: len -= size; ! 860: ret += size; ! 861: buf += size; ! 862: break; ! 863: ! 864: case 16: ! 865: #ifdef DEBUG_NTFS ! 866: printf("uncompressed\n"); ! 867: #endif ! 868: /* uncompressed */ ! 869: index16 = off / clustersize; ! 870: off %= clustersize; ! 871: while(index16 < 16) { ! 872: size = clustersize - off; ! 873: if( len < size ) ! 874: size = len; ! 875: if(!devread(cluster16[index16]*(clustersize>>9)+(off>>9), off&0x1ff, size, buf)) ! 876: return ret; ! 877: filepos += size; ! 878: len -= size; ! 879: ret += size; ! 880: if(len==0) ! 881: return ret; ! 882: off = 0; ! 883: buf += size; ! 884: index16++; ! 885: } ! 886: break; ! 887: ! 888: default: ! 889: #ifdef DEBUG_NTFS ! 890: printf("compressed\n"); ! 891: #endif ! 892: index16 = 0; ! 893: dcvcn = vcn; ! 894: dcoff = vcn * clustersize; ! 895: dcrem = cmft->attr_inited - dcoff; ! 896: if(dcrem > 16 * clustersize) ! 897: dcrem = 16 * clustersize; ! 898: dcsptr = dcsbuf; ! 899: dcslen = 0; ! 900: } ! 901: } ! 902: if(len0) { ! 903: #ifdef DEBUG_NTFS ! 904: printf("reading uninitialized data 3\n"); ! 905: #endif ! 906: memset(buf, 0, len0); ! 907: filepos += len0; ! 908: ret += len0; ! 909: } ! 910: #else ! 911: errnum = FSYS_CORRUPT; ! 912: #endif /*NO_NTFS_DECOMPRESSION*/ ! 913: #endif /*STAGE1_5*/ ! 914: return ret; ! 915: } ! 916: ! 917: int ntfs_mount (void) ! 918: { ! 919: char *sb = (char *)FSYS_BUF; ! 920: int mft_record; ! 921: int spc; ! 922: ! 923: if (((current_drive & 0x80) || (current_slice != 0)) ! 924: && (current_slice != /*PC_SLICE_TYPE_NTFS*/7) ! 925: && (current_slice != /*PC_SLICE_TYPE_NTFS*/0x17)) ! 926: return 0; ! 927: ! 928: if (!devread (0, 0, 512, (char *) FSYS_BUF)) ! 929: return 0; /* Cannot read superblock */ ! 930: ! 931: if(sb[3]!='N' || sb[4]!='T' || sb[5]!='F' || sb[6]!='S') ! 932: return 0; ! 933: blocksize = *(__u16 *)(sb+0xb); ! 934: spc = *(unsigned char *)(sb+0xd); ! 935: clustersize = spc * blocksize; ! 936: mft_record_size = *(char *)(sb+0x40); ! 937: index_record_size = *(char *)(sb+0x44); ! 938: if(mft_record_size>0) ! 939: mft_record_size *= clustersize; ! 940: else ! 941: mft_record_size = 1 << (-mft_record_size); ! 942: ! 943: index_record_size *= clustersize; ! 944: mft_record = *(__u32 *)(sb+0x30); /* only support 32 bit */ ! 945: spc = clustersize / 512; ! 946: ! 947: if(mft_record_size > MAX_MFT_RECORD_SIZE || index_record_size > MAX_INDEX_RECORD_SIZE) { ! 948: /* only support 1k MFT record, 4k INDEX record */ ! 949: return 0; ! 950: } ! 951: ! 952: #ifdef DEBUG_NTFS ! 953: printf("spc=%x mft_record=%x:%x\n", spc, *(__s64 *)(sb+0x30)); ! 954: #endif ! 955: ! 956: if (!devread (mft_record*spc, 0, mft_record_size, mmft->mft)) ! 957: return 0; /* Cannot read superblock */ ! 958: ! 959: if(!fixup_record( mmft->mft, "FILE", mft_record_size)) ! 960: return 0; ! 961: ! 962: #ifndef NO_ALTERNATE_DATASTREAM ! 963: is_ads_completion = 0; ! 964: #endif ! 965: if(!search_attribute(mmft, at_data, NONAME)) return 0; ! 966: ! 967: *mft_run = mmft->runl; ! 968: ! 969: *path_ino = FILE_ROOT; ! 970: ! 971: return 1; ! 972: } ! 973: ! 974: int ! 975: ntfs_dir (char *dirname) ! 976: { ! 977: char *rest, ch; ! 978: int namelen; ! 979: int depth = 0; ! 980: int chk_sfn = 1; ! 981: int flag = 0; ! 982: int record_offset; ! 983: int my_index_record_size; ! 984: unsigned char *index_entry = 0, *entry, *index_end; ! 985: int i; ! 986: ! 987: /* main loop to find desired directory entry */ ! 988: loop: ! 989: ! 990: #ifdef DEBUG_NTFS ! 991: printf("dirname=%s\n", dirname); ! 992: #endif ! 993: if(!read_mft_record(path_ino[depth], cmft->mft, 0)) ! 994: { ! 995: #ifdef DEBUG_NTFS ! 996: printf("MFT error 1\n"); ! 997: #endif ! 998: errnum = ERR_FSYS_CORRUPT; ! 999: return 0; ! 1000: } ! 1001: ! 1002: /* if we have a real file (and we're not just printing possibilities), ! 1003: then this is where we want to exit */ ! 1004: ! 1005: if (!*dirname || isspace (*dirname) || *dirname==':') ! 1006: { ! 1007: #ifndef STAGE1_5 ! 1008: #ifndef NO_ALTERNATE_DATASTREAM ! 1009: if (*dirname==':' && print_possibilities) { ! 1010: char *tmp; ! 1011: ! 1012: /* preparing ADS name completion */ ! 1013: for(tmp = dirname; *tmp != '/'; tmp--); ! 1014: for(tmp++, rest=fnbuf; *tmp && !isspace(*tmp); *rest++ = *tmp++) ! 1015: if(*tmp==':') dirname = rest; ! 1016: *rest++ = '\0'; ! 1017: ! 1018: is_ads_completion = 1; ! 1019: search_attribute(cmft, at_data, dirname+1); ! 1020: is_ads_completion = 0; ! 1021: ! 1022: if(errnum==0) { ! 1023: if(print_possibilities < 0) ! 1024: return 1; ! 1025: errnum = ERR_FILE_NOT_FOUND; ! 1026: } ! 1027: return 0; ! 1028: } ! 1029: #endif ! 1030: #endif ! 1031: ! 1032: if (*dirname==':') dirname++; ! 1033: for (rest = dirname; (ch = *rest) && !isspace (ch); rest++); ! 1034: *rest = 0; ! 1035: ! 1036: #ifdef DEBUG_NTFS ! 1037: printf("got file: search at_data\n"); ! 1038: #endif ! 1039: ! 1040: if (!search_attribute(cmft, at_data, dirname)) { ! 1041: errnum = *(dirname-1)==':'?ERR_FILE_NOT_FOUND:ERR_BAD_FILETYPE; ! 1042: *rest = ch; ! 1043: return 0; ! 1044: } ! 1045: *rest = ch; ! 1046: ! 1047: filemax = cmft->attr_size; ! 1048: #ifdef DEBUG_NTFS ! 1049: printf("filemax=%x\n", filemax); ! 1050: #endif ! 1051: return 1; ! 1052: } ! 1053: ! 1054: if(depth >= (MAX_DIR_DEPTH-1)) { ! 1055: errnum = ERR_FSYS_CORRUPT; ! 1056: return 0; ! 1057: } ! 1058: ! 1059: /* continue with the file/directory name interpretation */ ! 1060: ! 1061: while (*dirname == '/') ! 1062: dirname++; ! 1063: ! 1064: for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/' && ch != ':'; rest++); ! 1065: ! 1066: *rest = 0; ! 1067: ! 1068: if (!search_attribute(cmft, at_index_root, "$I30")) ! 1069: { ! 1070: errnum = ERR_BAD_FILETYPE; ! 1071: return 0; ! 1072: } ! 1073: ! 1074: read_attribute(cmft, 0, fnbuf, 16, 0); ! 1075: my_index_record_size = *(__u32 *)(fnbuf+8); ! 1076: ! 1077: if(my_index_record_size > MAX_INDEX_RECORD_SIZE) { ! 1078: errnum = ERR_FSYS_CORRUPT; ! 1079: return 0; ! 1080: } ! 1081: ! 1082: #ifdef DEBUG_NTFS ! 1083: printf("index_record_size=%x\n", my_index_record_size); ! 1084: #endif ! 1085: ! 1086: if(cmft->attr_size > MAX_INDEX_RECORD_SIZE) { ! 1087: errnum = ERR_FSYS_CORRUPT; ! 1088: return 0; ! 1089: } ! 1090: read_attribute(cmft, 0, index_data, cmft->attr_size, 0); ! 1091: index_end = index_data + cmft->attr_size; ! 1092: index_entry = index_data + 0x20; ! 1093: record_offset = -1; ! 1094: ! 1095: #ifndef STAGE1_5 ! 1096: if (print_possibilities && ch != '/' && ch != ':' && !*dirname) ! 1097: { ! 1098: print_possibilities = -print_possibilities; ! 1099: /* fake '.' for empty directory */ ! 1100: print_a_completion ("."); ! 1101: } ! 1102: #endif ! 1103: ! 1104: if (search_attribute(cmft, at_bitmap, "$I30")) { ! 1105: if(cmft->attr_size > MAX_INDEX_BITMAP_SIZE) { ! 1106: errnum = ERR_FSYS_CORRUPT; ! 1107: return 0; ! 1108: } ! 1109: ! 1110: read_attribute(cmft, 0, bitmap_data, cmft->attr_size, 0); ! 1111: ! 1112: if (search_attribute(cmft, at_index_allocation, "$I30")==0) { ! 1113: errnum = ERR_FSYS_CORRUPT; ! 1114: return 0; ! 1115: } ! 1116: ! 1117: for(record_offset = 0; record_offset*my_index_record_size<cmft->attr_size; record_offset++){ ! 1118: int bit = 1 << (record_offset&3); ! 1119: int byte = record_offset>>3; ! 1120: #ifdef DEBUG_NTFS ! 1121: printf("record_offset=%x\n", record_offset); ! 1122: #endif ! 1123: if((bitmap_data[byte]&bit)) ! 1124: break; ! 1125: } ! 1126: ! 1127: if(record_offset*my_index_record_size>=cmft->attr_size) record_offset = -1; ! 1128: } ! 1129: ! 1130: do ! 1131: { ! 1132: entry = index_entry; index_entry += *(__u16 *)(entry+8); ! 1133: if(entry+0x50>=index_entry||entry>=index_end|| ! 1134: index_entry>=index_end||(entry[0x12]&2)){ ! 1135: if(record_offset < 0 || ! 1136: !read_attribute(cmft, record_offset*my_index_record_size, index_data, my_index_record_size, 0)){ ! 1137: if (!errnum) ! 1138: { ! 1139: if (print_possibilities < 0) ! 1140: { ! 1141: #if 0 ! 1142: putchar ('\n'); ! 1143: #endif ! 1144: return 1; ! 1145: } ! 1146: ! 1147: errnum = ERR_FILE_NOT_FOUND; ! 1148: *rest = ch; ! 1149: } ! 1150: ! 1151: return 0; ! 1152: } ! 1153: if(!fixup_record( index_data, "INDX", my_index_record_size)) ! 1154: { ! 1155: #ifdef DEBUG_NTFS ! 1156: printf("index error\n"); ! 1157: #endif ! 1158: errnum = ERR_FSYS_CORRUPT; ! 1159: return 0; ! 1160: } ! 1161: entry = index_data + 0x18 + *(__u16 *)(index_data+0x18); ! 1162: index_entry = entry + *(__u16 *)(entry+8); ! 1163: index_end = index_data + my_index_record_size - 0x52; ! 1164: for(record_offset++; record_offset*my_index_record_size<cmft->attr_size; record_offset++){ ! 1165: int bit = 1 << (record_offset&3); ! 1166: int byte = record_offset>>3; ! 1167: if((bitmap_data[byte]&bit)) break; ! 1168: } ! 1169: if(record_offset*my_index_record_size>=cmft->attr_size) record_offset = -1; ! 1170: #ifdef DEBUG_NTFS ! 1171: printf("record_offset=%x\n", record_offset); ! 1172: #endif ! 1173: } ! 1174: flag = entry[0x51]; ! 1175: path_ino[depth+1] = *(__u32 *)entry; ! 1176: if(path_ino[depth+1] < 16) ! 1177: continue; ! 1178: namelen = entry[0x50]; ! 1179: //if(index_data[0x48]&2) printf("hidden file\n"); ! 1180: #ifndef STAGE1_5 ! 1181: /* skip short file name */ ! 1182: if( flag == 2 && print_possibilities && ch != '/' && ch != ':' ) ! 1183: continue; ! 1184: #endif ! 1185: ! 1186: for( i = 0, entry+=0x52; i < namelen; i++, entry+=2 ) ! 1187: { ! 1188: int c = *(__u16 *)entry; ! 1189: if(c==' '||c>=0x100) ! 1190: fnbuf[i] = '_'; ! 1191: else ! 1192: fnbuf[i] = c; ! 1193: } ! 1194: fnbuf[namelen] = 0; ! 1195: #ifdef DEBUG_NTFS ! 1196: printf("FLAG: %d NAME: %s inum=%d\n", flag,fnbuf,path_ino[depth+1]); ! 1197: #endif ! 1198: ! 1199: //uncntrl(fnbuf); ! 1200: ! 1201: chk_sfn = nsubstring(dirname,fnbuf); ! 1202: #ifndef STAGE1_5 ! 1203: if (print_possibilities && ch != '/' && ch != ':' ! 1204: && (!*dirname || chk_sfn <= 0)) ! 1205: { ! 1206: if (print_possibilities > 0) ! 1207: print_possibilities = -print_possibilities; ! 1208: print_a_completion (fnbuf); ! 1209: } ! 1210: #endif /* STAGE1_5 */ ! 1211: } ! 1212: while (chk_sfn != 0 || ! 1213: (print_possibilities && ch != '/' && ch != ':')); ! 1214: ! 1215: *(dirname = rest) = ch; ! 1216: ! 1217: depth++; ! 1218: ! 1219: /* go back to main loop at top of function */ ! 1220: goto loop; ! 1221: } ! 1222: ! 1223: #ifdef DEBUG_NTFS ! 1224: int dump_block(char *msg, char *buf, int size){ ! 1225: int l = (size+15)/16; ! 1226: int off; ! 1227: int i, j; ! 1228: int c; ! 1229: printf("----- %s -----\n", msg); ! 1230: for( i = 0, off = 0; i < l; i++, off+=16) ! 1231: { ! 1232: if(off<16) ! 1233: printf("000%x:", off); ! 1234: else if(off<256) ! 1235: printf("00%x:", off); ! 1236: else ! 1237: printf("0%x:", off); ! 1238: for(j=0;j<16;j++) ! 1239: { ! 1240: c = buf[off+j]&0xff; ! 1241: if( c >= 16 ) ! 1242: printf("%c%x",j==8?'-':' ',c); ! 1243: else ! 1244: printf("%c0%x",j==8?'-':' ',c); ! 1245: } ! 1246: printf(" "); ! 1247: for(j=0;j<16;j++) { ! 1248: char c = buf[off+j]; ! 1249: printf("%c",c<' '||c>='\x7f'?'.':c); ! 1250: } ! 1251: printf("\n"); ! 1252: } ! 1253: } ! 1254: #endif ! 1255: #endif /* FSYS_NTFS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.