fs/ntfs.c

   1 /* ntfs.c - NTFS filesystem */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2007,2008 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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/file.h>
  21 #include <grub/mm.h>
  22 #include <grub/misc.h>
  23 #include <grub/disk.h>
  24 #include <grub/dl.h>
  25 #include <grub/fshelp.h>
  26 #include <grub/ntfs.h>
  27
  28 static grub_dl_t my_mod;
  29
  30 ntfscomp_func_t grub_ntfscomp_func;
  31
  32 static grub_err_t
  33 fixup (struct grub_ntfs_data *data, char *buf, int len, char *magic)
  34 {
  35   int ss;
  36   char *pu;
  37   grub_uint16_t us;
  38
  39   if (grub_memcmp (buf, magic, 4))
  40     return grub_error (GRUB_ERR_BAD_FS, "%s label not found", magic);
  41
  42   ss = u16at (buf, 6) - 1;
  43   if (ss * (int) data->blocksize != len * GRUB_DISK_SECTOR_SIZE)
  44     return grub_error (GRUB_ERR_BAD_FS, "Size not match",
  45                        ss * (int) data->blocksize,
  46                        len * GRUB_DISK_SECTOR_SIZE);
  47   pu = buf + u16at (buf, 4);
  48   us = u16at (pu, 0);
  49   buf -= 2;
  50   while (ss > 0)
  51     {
  52       buf += data->blocksize;
  53       pu += 2;
  54       if (u16at (buf, 0) != us)
  55         return grub_error (GRUB_ERR_BAD_FS, "Fixup signature not match");
  56       v16at (buf, 0) = v16at (pu, 0);
  57       ss--;
  58     }
  59
  60   return 0;
  61 }
  62
  63 static grub_err_t read_mft (struct grub_ntfs_data *data, char *buf,
  64                             grub_uint32_t mftno);
  65 static grub_err_t read_attr (struct grub_ntfs_attr *at, char *dest,
  66                              grub_uint32_t ofs, grub_uint32_t len,
  67                              int cached,
  68                              void
  69                              NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t
  70                                                             sector,
  71                                                             unsigned offset,
  72                                                             unsigned length));
  73
  74 static grub_err_t read_data (struct grub_ntfs_attr *at, char *pa, char *dest,
  75                              grub_uint32_t ofs, grub_uint32_t len,
  76                              int cached,
  77                              void
  78                              NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t
  79                                                             sector,
  80                                                             unsigned offset,
  81                                                             unsigned length));
  82
  83 static void
  84 init_attr (struct grub_ntfs_attr *at, struct grub_ntfs_file *mft)
  85 {
  86   at->mft = mft;
  87   at->flags = (mft == &mft->data->mmft) ? AF_MMFT : 0;
  88   at->attr_nxt = mft->buf + u16at (mft->buf, 0x14);
  89   at->attr_end = at->emft_buf = at->edat_buf = at->sbuf = NULL;
  90 }
  91
  92 static void
  93 free_attr (struct grub_ntfs_attr *at)
  94 {
  95   grub_free (at->emft_buf);
  96   grub_free (at->edat_buf);
  97   grub_free (at->sbuf);
  98 }
  99
 100 static char *
 101 find_attr (struct grub_ntfs_attr *at, unsigned char attr)
 102 {
 103   if (at->flags & AF_ALST)
 104     {
 105     retry:
 106       while (at->attr_nxt < at->attr_end)
 107         {
 108           at->attr_cur = at->attr_nxt;
 109           at->attr_nxt += u16at (at->attr_cur, 4);
 110           if (((unsigned char) *at->attr_cur == attr) || (attr == 0))
 111             {
 112               char *new_pos;
 113
 114               if (at->flags & AF_MMFT)
 115                 {
 116                   if ((grub_disk_read
 117                        (at->mft->data->disk, v32at (at->attr_cur, 0x10), 0,
 118                         512, at->emft_buf))
 119                       ||
 120                       (grub_disk_read
 121                        (at->mft->data->disk, v32at (at->attr_cur, 0x14), 0,
 122                         512, at->emft_buf + 512)))
 123                     return NULL;
 124
 125                   if (fixup
 126                       (at->mft->data, at->emft_buf, at->mft->data->mft_size,
 127                        "FILE"))
 128                     return NULL;
 129                 }
 130               else
 131                 {
 132                   if (read_mft (at->mft->data, at->emft_buf,
 133                                 u32at (at->attr_cur, 0x10)))
 134                     return NULL;
 135                 }
 136
 137               new_pos = &at->emft_buf[u16at (at->emft_buf, 0x14)];
 138               while ((unsigned char) *new_pos != 0xFF)
 139                 {
 140                   if (((unsigned char) *new_pos ==
 141                        (unsigned char) *at->attr_cur)
 142                       && (u16at (new_pos, 0xE) == u16at (at->attr_cur, 0x18)))
 143                     {
 144                       return new_pos;
 145                     }
 146                   new_pos += u16at (new_pos, 4);
 147                 }
 148               grub_error (GRUB_ERR_BAD_FS,
 149                           "Can\'t find 0x%X in attribute list",
 150                           (unsigned char) *at->attr_cur);
 151               return NULL;
 152             }
 153         }
 154       return NULL;
 155     }
 156   at->attr_cur = at->attr_nxt;
 157   while ((unsigned char) *at->attr_cur != 0xFF)
 158     {
 159       at->attr_nxt += u16at (at->attr_cur, 4);
 160       if ((unsigned char) *at->attr_cur == AT_ATTRIBUTE_LIST)
 161         at->attr_end = at->attr_cur;
 162       if (((unsigned char) *at->attr_cur == attr) || (attr == 0))
 163         return at->attr_cur;
 164       at->attr_cur = at->attr_nxt;
 165     }
 166   if (at->attr_end)
 167     {
 168       char *pa;
 169
 170       at->emft_buf = grub_malloc (at->mft->data->mft_size << BLK_SHR);
 171       if (at->emft_buf == NULL)
 172         return NULL;
 173
 174       pa = at->attr_end;
 175       if (pa[8])
 176         {
 177           int n;
 178
 179           n = ((u32at (pa, 0x30) + GRUB_DISK_SECTOR_SIZE - 1)
 180                & (~(GRUB_DISK_SECTOR_SIZE - 1)));
 181           at->attr_cur = at->attr_end;
 182           at->edat_buf = grub_malloc (n);
 183           if (!at->edat_buf)
 184             return NULL;
 185           if (read_data (at, pa, at->edat_buf, 0, n, 0, 0))
 186             {
 187               grub_error (GRUB_ERR_BAD_FS,
 188                           "Fail to read non-resident attribute list");
 189               return NULL;
 190             }
 191           at->attr_nxt = at->edat_buf;
 192           at->attr_end = at->edat_buf + u32at (pa, 0x30);
 193         }
 194       else
 195         {
 196           at->attr_nxt = at->attr_end + u16at (pa, 0x14);
 197           at->attr_end = at->attr_end + u32at (pa, 4);
 198         }
 199       at->flags |= AF_ALST;
 200       while (at->attr_nxt < at->attr_end)
 201         {
 202           if (((unsigned char) *at->attr_nxt == attr) || (attr == 0))
 203             break;
 204           at->attr_nxt += u16at (at->attr_nxt, 4);
 205         }
 206       if (at->attr_nxt >= at->attr_end)
 207         return NULL;
 208
 209       if ((at->flags & AF_MMFT) && (attr == AT_DATA))
 210         {
 211           at->flags |= AF_GPOS;
 212           at->attr_cur = at->attr_nxt;
 213           pa = at->attr_cur;
 214           v32at (pa, 0x10) = at->mft->data->mft_start;
 215           v32at (pa, 0x14) = at->mft->data->mft_start + 1;
 216           pa = at->attr_nxt + u16at (pa, 4);
 217           while (pa < at->attr_end)
 218             {
 219               if ((unsigned char) *pa != attr)
 220                 break;
 221               if (read_attr
 222                   (at, pa + 0x10,
 223                    u32at (pa, 0x10) * (at->mft->data->mft_size << BLK_SHR),
 224                    at->mft->data->mft_size << BLK_SHR, 0, 0))
 225                 return NULL;
 226               pa += u16at (pa, 4);
 227             }
 228           at->attr_nxt = at->attr_cur;
 229           at->flags &= ~AF_GPOS;
 230         }
 231       goto retry;
 232     }
 233   return NULL;
 234 }
 235
 236 static char *
 237 locate_attr (struct grub_ntfs_attr *at, struct grub_ntfs_file *mft,
 238              unsigned char attr)
 239 {
 240   char *pa;
 241
 242   init_attr (at, mft);
 243   if ((pa = find_attr (at, attr)) == NULL)
 244     return NULL;
 245   if ((at->flags & AF_ALST) == 0)
 246     {
 247       while (1)
 248         {
 249           if ((pa = find_attr (at, attr)) == NULL)
 250             break;
 251           if (at->flags & AF_ALST)
 252             return pa;
 253         }
 254       grub_errno = GRUB_ERR_NONE;
 255       free_attr (at);
 256       init_attr (at, mft);
 257       pa = find_attr (at, attr);
 258     }
 259   return pa;
 260 }
 261
 262 static char *
 263 read_run_data (char *run, int nn, grub_uint32_t * val, int sig)
 264 {
 265   grub_uint32_t r, v;
 266
 267   r = 0;
 268   v = 1;
 269
 270   while (nn--)
 271     {
 272       r += v * (*(unsigned char *) (run++));
 273       v <<= 8;
 274     }
 275
 276   if ((sig) && (r & (v >> 1)))
 277     r -= v;
 278
 279   *val = r;
 280   return run;
 281 }
 282
 283 grub_err_t
 284 grub_ntfs_read_run_list (struct grub_ntfs_rlst * ctx)
 285 {
 286   int c1, c2;
 287   grub_uint32_t val;
 288   char *run;
 289
 290   run = ctx->cur_run;
 291 retry:
 292   c1 = ((unsigned char) (*run) & 0xF);
 293   c2 = ((unsigned char) (*run) >> 4);
 294   if (!c1)
 295     {
 296       if ((ctx->attr) && (ctx->attr->flags & AF_ALST))
 297         {
 298           void NESTED_FUNC_ATTR (*save_hook) (grub_disk_addr_t sector,
 299                                               unsigned offset,
 300                                               unsigned length);
 301
 302           save_hook = ctx->comp.disk->read_hook;
 303           ctx->comp.disk->read_hook = 0;
 304           run = find_attr (ctx->attr, (unsigned char) *ctx->attr->attr_cur);
 305           ctx->comp.disk->read_hook = save_hook;
 306           if (run)
 307             {
 308               if (run[8] == 0)
 309                 return grub_error (GRUB_ERR_BAD_FS,
 310                                    "$DATA should be non-resident");
 311
 312               run += u16at (run, 0x20);
 313               ctx->curr_lcn = 0;
 314               goto retry;
 315             }
 316         }
 317       return grub_error (GRUB_ERR_BAD_FS, "Run list overflown");
 318     }
 319   run = read_run_data (run + 1, c1, &val, 0);   /* length of current VCN */
 320   ctx->curr_vcn = ctx->next_vcn;
 321   ctx->next_vcn += val;
 322   run = read_run_data (run, c2, &val, 1);       /* offset to previous LCN */
 323   ctx->curr_lcn += val;
 324   if (val == 0)
 325     ctx->flags |= RF_BLNK;
 326   else
 327     ctx->flags &= ~RF_BLNK;
 328   ctx->cur_run = run;
 329   return 0;
 330 }
 331
 332 static grub_disk_addr_t
 333 grub_ntfs_read_block (grub_fshelp_node_t node, grub_disk_addr_t block)
 334 {
 335   struct grub_ntfs_rlst *ctx;
 336
 337   ctx = (struct grub_ntfs_rlst *) node;
 338   if ((grub_uint32_t) block >= ctx->next_vcn)
 339     {
 340       if (grub_ntfs_read_run_list (ctx))
 341         return -1;
 342       return ctx->curr_lcn;
 343     }
 344   else
 345     return (ctx->flags & RF_BLNK) ? 0 : ((grub_uint32_t) block -
 346                                          ctx->curr_vcn + ctx->curr_lcn);
 347 }
 348
 349 static grub_err_t
 350 read_data (struct grub_ntfs_attr *at, char *pa, char *dest, grub_uint32_t ofs,
 351            grub_uint32_t len, int cached,
 352            void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
 353                                                unsigned offset,
 354                                                unsigned length))
 355 {
 356   grub_uint32_t vcn;
 357   struct grub_ntfs_rlst cc, *ctx;
 358
 359   if (len == 0)
 360     return 0;
 361
 362   grub_memset (&cc, 0, sizeof (cc));
 363   ctx = &cc;
 364   ctx->attr = at;
 365   ctx->comp.spc = at->mft->data->spc;
 366   ctx->comp.disk = at->mft->data->disk;
 367
 368   if (pa[8] == 0)
 369     {
 370       if (ofs + len > u32at (pa, 0x10))
 371         return grub_error (GRUB_ERR_BAD_FS, "Read out of range");
 372       grub_memcpy (dest, pa + u32at (pa, 0x14) + ofs, len);
 373       return 0;
 374     }
 375
 376   if (u16at (pa, 0xC) & FLAG_COMPRESSED)
 377     ctx->flags |= RF_COMP;
 378   else
 379     ctx->flags &= ~RF_COMP;
 380   ctx->cur_run = pa + u16at (pa, 0x20);
 381
 382   if (ctx->flags & RF_COMP)
 383     {
 384       if (!cached)
 385         return grub_error (GRUB_ERR_BAD_FS, "Attribute can\'t be compressed");
 386
 387       if (at->sbuf)
 388         {
 389           if ((ofs & (~(COM_LEN - 1))) == at->save_pos)
 390             {
 391               grub_uint32_t n;
 392
 393               n = COM_LEN - (ofs - at->save_pos);
 394               if (n > len)
 395                 n = len;
 396
 397               grub_memcpy (dest, at->sbuf + ofs - at->save_pos, n);
 398               if (n == len)
 399                 return 0;
 400
 401               dest += n;
 402               len -= n;
 403               ofs += n;
 404             }
 405         }
 406       else
 407         {
 408           at->sbuf = grub_malloc (COM_LEN);
 409           if (at->sbuf == NULL)
 410             return grub_errno;
 411           at->save_pos = 1;
 412         }
 413
 414       vcn = ctx->target_vcn = (ofs / COM_LEN) * (COM_SEC / ctx->comp.spc);
 415       ctx->target_vcn &= ~0xF;
 416     }
 417   else
 418     vcn = ctx->target_vcn = (ofs >> BLK_SHR) / ctx->comp.spc;
 419
 420   ctx->next_vcn = u32at (pa, 0x10);
 421   ctx->curr_lcn = 0;
 422   while (ctx->next_vcn <= ctx->target_vcn)
 423     {
 424       if (grub_ntfs_read_run_list (ctx))
 425         return grub_errno;
 426     }
 427
 428   if (at->flags & AF_GPOS)
 429     {
 430       grub_uint32_t st0, st1;
 431
 432       st0 =
 433         (ctx->target_vcn - ctx->curr_vcn + ctx->curr_lcn) * ctx->comp.spc +
 434         ((ofs >> BLK_SHR) % ctx->comp.spc);
 435       st1 = st0 + 1;
 436       if (st1 ==
 437           (ctx->next_vcn - ctx->curr_vcn + ctx->curr_lcn) * ctx->comp.spc)
 438         {
 439           if (grub_ntfs_read_run_list (ctx))
 440             return grub_errno;
 441           st1 = ctx->curr_lcn * ctx->comp.spc;
 442         }
 443       v32at (dest, 0) = st0;
 444       v32at (dest, 4) = st1;
 445       return 0;
 446     }
 447
 448   if (!(ctx->flags & RF_COMP))
 449     {
 450       unsigned int pow;
 451
 452       if (!grub_fshelp_log2blksize (ctx->comp.spc, &pow))
 453         grub_fshelp_read_file (ctx->comp.disk, (grub_fshelp_node_t) ctx,
 454                                read_hook, ofs, len, dest,
 455                                grub_ntfs_read_block, ofs + len, pow);
 456       return grub_errno;
 457     }
 458
 459   return (grub_ntfscomp_func) ? grub_ntfscomp_func (at, dest, ofs, len, ctx,
 460                                                     vcn) :
 461     grub_error (GRUB_ERR_BAD_FS, "ntfscomp module not loaded");
 462 }
 463
 464 static grub_err_t
 465 read_attr (struct grub_ntfs_attr *at, char *dest, grub_uint32_t ofs,
 466            grub_uint32_t len, int cached,
 467            void NESTED_FUNC_ATTR (*read_hook) (grub_disk_addr_t sector,
 468                                                unsigned offset,
 469                                                unsigned length))
 470 {
 471   char *save_cur;
 472   unsigned char attr;
 473   char *pp;
 474   grub_err_t ret;
 475
 476   save_cur = at->attr_cur;
 477   at->attr_nxt = at->attr_cur;
 478   attr = (unsigned char) *at->attr_nxt;
 479   if (at->flags & AF_ALST)
 480     {
 481       char *pa;
 482       grub_uint32_t vcn;
 483
 484       vcn = ofs / (at->mft->data->spc << BLK_SHR);
 485       pa = at->attr_nxt + u16at (at->attr_nxt, 4);
 486       while (pa < at->attr_end)
 487         {
 488           if ((unsigned char) *pa != attr)
 489             break;
 490           if (u32at (pa, 8) > vcn)
 491             break;
 492           at->attr_nxt = pa;
 493           pa += u16at (pa, 4);
 494         }
 495     }
 496   pp = find_attr (at, attr);
 497   if (pp)
 498     ret = read_data (at, pp, dest, ofs, len, cached, read_hook);
 499   else
 500     ret =
 501       (grub_errno) ? grub_errno : grub_error (GRUB_ERR_BAD_FS,
 502                                               "Attribute not found");
 503   at->attr_cur = save_cur;
 504   return ret;
 505 }
 506
 507 static grub_err_t
 508 read_mft (struct grub_ntfs_data *data, char *buf, grub_uint32_t mftno)
 509 {
 510   if (read_attr
 511       (&data->mmft.attr, buf, mftno * (data->mft_size << BLK_SHR),
 512        data->mft_size << BLK_SHR, 0, 0))
 513     return grub_error (GRUB_ERR_BAD_FS, "Read MFT 0x%X fails", mftno);
 514   return fixup (data, buf, data->mft_size, "FILE");
 515 }
 516
 517 static grub_err_t
 518 init_file (struct grub_ntfs_file *mft, grub_uint32_t mftno)
 519 {
 520   unsigned short flag;
 521
 522   mft->inode_read = 1;
 523
 524   mft->buf = grub_malloc (mft->data->mft_size << BLK_SHR);
 525   if (mft->buf == NULL)
 526     return grub_errno;
 527
 528   if (read_mft (mft->data, mft->buf, mftno))
 529     return grub_errno;
 530
 531   flag = u16at (mft->buf, 0x16);
 532   if ((flag & 1) == 0)
 533     return grub_error (GRUB_ERR_BAD_FS, "MFT 0x%X is not in use", mftno);
 534
 535   if ((flag & 2) == 0)
 536     {
 537       char *pa;
 538
 539       pa = locate_attr (&mft->attr, mft, AT_DATA);
 540       if (pa == NULL)
 541         return grub_error (GRUB_ERR_BAD_FS, "No $DATA in MFT 0x%X", mftno);
 542
 543       if (!pa[8])
 544         mft->size = u32at (pa, 0x10);
 545       else
 546         mft->size = u32at (pa, 0x30);
 547
 548       if ((mft->attr.flags & AF_ALST) == 0)
 549         mft->attr.attr_end = 0; /*  Don't jump to attribute list */
 550     }
 551   else
 552     init_attr (&mft->attr, mft);
 553
 554   return 0;
 555 }
 556
 557 static void
 558 free_file (struct grub_ntfs_file *mft)
 559 {
 560   free_attr (&mft->attr);
 561   grub_free (mft->buf);
 562 }
 563
 564 static int
 565 list_file (struct grub_ntfs_file *diro, char *pos,
 566            int NESTED_FUNC_ATTR
 567            (*hook) (const char *filename,
 568                     enum grub_fshelp_filetype filetype,
 569                     grub_fshelp_node_t node))
 570 {
 571   char *np;
 572   int ns;
 573
 574   while (1)
 575     {
 576       char *ustr, namespace;
 577
 578       if (pos[0xC] & 2)         /* end signature */
 579         break;
 580
 581       np = pos + 0x50;
 582       ns = (unsigned char) *(np++);
 583       namespace = *(np++);
 584
 585       /*
 586        *  Ignore files in DOS namespace, as they will reappear as Win32
 587        *  names.
 588        */
 589       if ((ns) && (namespace != 2))
 590         {
 591           enum grub_fshelp_filetype type;
 592           struct grub_ntfs_file *fdiro;
 593
 594           if (u16at (pos, 4))
 595             {
 596               grub_error (GRUB_ERR_BAD_FS, "64-bit MFT number");
 597               return 0;
 598             }
 599
 600           type =
 601             (u32at (pos, 0x48) & ATTR_DIRECTORY) ? GRUB_FSHELP_DIR :
 602             GRUB_FSHELP_REG;
 603
 604           fdiro = grub_malloc (sizeof (struct grub_ntfs_file));
 605           if (!fdiro)
 606             return 0;
 607
 608           grub_memset (fdiro, 0, sizeof (*fdiro));
 609           fdiro->data = diro->data;
 610           fdiro->ino = u32at (pos, 0);
 611
 612           ustr = grub_malloc (ns * 4 + 1);
 613           if (ustr == NULL)
 614             return 0;
 615           *grub_utf16_to_utf8 ((grub_uint8_t *) ustr, (grub_uint16_t *) np,
 616                                ns) = '\0';
 617
 618           if (namespace)
 619             type |= GRUB_FSHELP_CASE_INSENSITIVE;
 620
 621           if (hook (ustr, type, fdiro))
 622             {
 623               grub_free (ustr);
 624               return 1;
 625             }
 626
 627           grub_free (ustr);
 628         }
 629       pos += u16at (pos, 8);
 630     }
 631   return 0;
 632 }
 633
 634 static int
 635 grub_ntfs_iterate_dir (grub_fshelp_node_t dir,
 636                        int NESTED_FUNC_ATTR
 637                        (*hook) (const char *filename,
 638                                 enum grub_fshelp_filetype filetype,
 639                                 grub_fshelp_node_t node))
 640 {
 641   unsigned char *bitmap;
 642   struct grub_ntfs_attr attr, *at;
 643   char *cur_pos, *indx, *bmp;
 644   int bitmap_len, ret = 0;
 645   struct grub_ntfs_file *mft;
 646
 647   mft = (struct grub_ntfs_file *) dir;
 648
 649   if (!mft->inode_read)
 650     {
 651       if (init_file (mft, mft->ino))
 652         return 0;
 653     }
 654
 655   indx = NULL;
 656   bmp = NULL;
 657
 658   at = &attr;
 659   init_attr (at, mft);
 660   while (1)
 661     {
 662       if ((cur_pos = find_attr (at, AT_INDEX_ROOT)) == NULL)
 663         {
 664           grub_error (GRUB_ERR_BAD_FS, "No $INDEX_ROOT");
 665           goto done;
 666         }
 667
 668       /* Resident, Namelen=4, Offset=0x18, Flags=0x00, Name="$I30" */
 669       if ((u32at (cur_pos, 8) != 0x180400) ||
 670           (u32at (cur_pos, 0x18) != 0x490024) ||
 671           (u32at (cur_pos, 0x1C) != 0x300033))
 672         continue;
 673       cur_pos += u16at (cur_pos, 0x14);
 674       if (*cur_pos != 0x30)     /* Not filename index */
 675         continue;
 676       break;
 677     }
 678
 679   cur_pos += 0x10;              /* Skip index root */
 680   ret = list_file (mft, cur_pos + u16at (cur_pos, 0), hook);
 681   if (ret)
 682     goto done;
 683
 684   bitmap = NULL;
 685   bitmap_len = 0;
 686   free_attr (at);
 687   init_attr (at, mft);
 688   while ((cur_pos = find_attr (at, AT_BITMAP)) != NULL)
 689     {
 690       int ofs;
 691
 692       ofs = (unsigned char) cur_pos[0xA];
 693       /* Namelen=4, Name="$I30" */
 694       if ((cur_pos[9] == 4) &&
 695           (u32at (cur_pos, ofs) == 0x490024) &&
 696           (u32at (cur_pos, ofs + 4) == 0x300033))
 697         {
 698           int is_resident = (cur_pos[8] == 0);
 699
 700           bitmap_len = ((is_resident) ? u32at (cur_pos, 0x10) :
 701                         u32at (cur_pos, 0x28));
 702
 703           bmp = grub_malloc (bitmap_len);
 704           if (bmp == NULL)
 705             goto done;
 706
 707           if (is_resident)
 708             {
 709               grub_memcpy (bmp, (char *) (cur_pos + u16at (cur_pos, 0x14)),
 710                            bitmap_len);
 711             }
 712           else
 713             {
 714               if (read_data (at, cur_pos, bmp, 0, bitmap_len, 0, 0))
 715                 {
 716                   grub_error (GRUB_ERR_BAD_FS,
 717                               "Fails to read non-resident $BITMAP");
 718                   goto done;
 719                 }
 720               bitmap_len = u32at (cur_pos, 0x30);
 721             }
 722
 723           bitmap = (unsigned char *) bmp;
 724           break;
 725         }
 726     }
 727
 728   free_attr (at);
 729   cur_pos = locate_attr (at, mft, AT_INDEX_ALLOCATION);
 730   while (cur_pos != NULL)
 731     {
 732       /* Non-resident, Namelen=4, Offset=0x40, Flags=0, Name="$I30" */
 733       if ((u32at (cur_pos, 8) == 0x400401) &&
 734           (u32at (cur_pos, 0x40) == 0x490024) &&
 735           (u32at (cur_pos, 0x44) == 0x300033))
 736         break;
 737       cur_pos = find_attr (at, AT_INDEX_ALLOCATION);
 738     }
 739
 740   if ((!cur_pos) && (bitmap))
 741     {
 742       grub_error (GRUB_ERR_BAD_FS, "$BITMAP without $INDEX_ALLOCATION");
 743       goto done;
 744     }
 745
 746   if (bitmap)
 747     {
 748       grub_uint32_t v, i;
 749
 750       indx = grub_malloc (mft->data->idx_size << BLK_SHR);
 751       if (indx == NULL)
 752         goto done;
 753
 754       v = 1;
 755       for (i = 0; i < (grub_uint32_t) bitmap_len * 8; i++)
 756         {
 757           if (*bitmap & v)
 758             {
 759               if ((read_attr
 760                    (at, indx, i * (mft->data->idx_size << BLK_SHR),
 761                     (mft->data->idx_size << BLK_SHR), 0, 0))
 762                   || (fixup (mft->data, indx, mft->data->idx_size, "INDX")))
 763                 goto done;
 764               ret = list_file (mft, &indx[0x18 + u16at (indx, 0x18)], hook);
 765               if (ret)
 766                 goto done;
 767             }
 768           v <<= 1;
 769           if (v >= 0x100)
 770             {
 771               v = 1;
 772               bitmap++;
 773             }
 774         }
 775     }
 776
 777 done:
 778   free_attr (at);
 779   grub_free (indx);
 780   grub_free (bmp);
 781
 782   return ret;
 783 }
 784
 785 static struct grub_ntfs_data *
 786 grub_ntfs_mount (grub_disk_t disk)
 787 {
 788   struct grub_ntfs_bpb bpb;
 789   struct grub_ntfs_data *data = 0;
 790
 791   if (!disk)
 792     goto fail;
 793
 794   data = (struct grub_ntfs_data *) grub_malloc (sizeof (*data));
 795   if (!data)
 796     goto fail;
 797
 798   grub_memset (data, 0, sizeof (*data));
 799
 800   data->disk = disk;
 801
 802   /* Read the BPB.  */
 803   if (grub_disk_read (disk, 0, 0, sizeof (bpb), &bpb))
 804     goto fail;
 805
 806   if (grub_memcmp ((char *) &bpb.oem_name, "NTFS", 4))
 807     goto fail;
 808
 809   data->blocksize = grub_le_to_cpu16 (bpb.bytes_per_sector);
 810   data->spc = bpb.sectors_per_cluster * (data->blocksize >> BLK_SHR);
 811
 812   if (bpb.clusters_per_mft > 0)
 813     data->mft_size = data->spc * bpb.clusters_per_mft;
 814   else
 815     data->mft_size = 1 << (-bpb.clusters_per_mft - BLK_SHR);
 816
 817   if (bpb.clusters_per_index > 0)
 818     data->idx_size = data->spc * bpb.clusters_per_index;
 819   else
 820     data->idx_size = 1 << (-bpb.clusters_per_index - BLK_SHR);
 821
 822   data->mft_start = grub_le_to_cpu64 (bpb.mft_lcn) * data->spc;
 823
 824   if ((data->mft_size > MAX_MFT) || (data->idx_size > MAX_IDX))
 825     goto fail;
 826
 827   data->mmft.data = data;
 828   data->cmft.data = data;
 829
 830   data->mmft.buf = grub_malloc (data->mft_size << BLK_SHR);
 831   if (!data->mmft.buf)
 832     goto fail;
 833
 834   if (grub_disk_read
 835       (disk, data->mft_start, 0, data->mft_size << BLK_SHR, data->mmft.buf))
 836     goto fail;
 837
 838   data->uuid = grub_le_to_cpu64 (bpb.num_serial);
 839
 840   if (fixup (data, data->mmft.buf, data->mft_size, "FILE"))
 841     goto fail;
 842
 843   if (!locate_attr (&data->mmft.attr, &data->mmft, AT_DATA))
 844     goto fail;
 845
 846   if (init_file (&data->cmft, FILE_ROOT))
 847     goto fail;
 848
 849   return data;
 850
 851 fail:
 852   grub_error (GRUB_ERR_BAD_FS, "not an ntfs filesystem");
 853
 854   if (data)
 855     {
 856       free_file (&data->mmft);
 857       free_file (&data->cmft);
 858       grub_free (data);
 859     }
 860   return 0;
 861 }
 862
 863 static grub_err_t
 864 grub_ntfs_dir (grub_device_t device, const char *path,
 865                int (*hook) (const char *filename,
 866                             const struct grub_dirhook_info *info))
 867 {
 868   struct grub_ntfs_data *data = 0;
 869   struct grub_fshelp_node *fdiro = 0;
 870
 871   auto int NESTED_FUNC_ATTR iterate (const char *filename,
 872                                      enum grub_fshelp_filetype filetype,
 873                                      grub_fshelp_node_t node);
 874
 875   int NESTED_FUNC_ATTR iterate (const char *filename,
 876                                 enum grub_fshelp_filetype filetype,
 877                                 grub_fshelp_node_t node)
 878   {
 879       struct grub_dirhook_info info;
 880       grub_memset (&info, 0, sizeof (info));
 881       info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
 882       grub_free (node);
 883       return hook (filename, &info);
 884   }
 885
 886   grub_dl_ref (my_mod);
 887
 888   data = grub_ntfs_mount (device->disk);
 889   if (!data)
 890     goto fail;
 891
 892   grub_fshelp_find_file (path, &data->cmft, &fdiro, grub_ntfs_iterate_dir,
 893                          0, GRUB_FSHELP_DIR);
 894
 895   if (grub_errno)
 896     goto fail;
 897
 898   grub_ntfs_iterate_dir (fdiro, iterate);
 899
 900 fail:
 901   if ((fdiro) && (fdiro != &data->cmft))
 902     {
 903       free_file (fdiro);
 904       grub_free (fdiro);
 905     }
 906   if (data)
 907     {
 908       free_file (&data->mmft);
 909       free_file (&data->cmft);
 910       grub_free (data);
 911     }
 912
 913   grub_dl_unref (my_mod);
 914
 915   return grub_errno;
 916 }
 917
 918 static grub_err_t
 919 grub_ntfs_open (grub_file_t file, const char *name)
 920 {
 921   struct grub_ntfs_data *data = 0;
 922   struct grub_fshelp_node *mft = 0;
 923
 924   grub_dl_ref (my_mod);
 925
 926   data = grub_ntfs_mount (file->device->disk);
 927   if (!data)
 928     goto fail;
 929
 930   grub_fshelp_find_file (name, &data->cmft, &mft, grub_ntfs_iterate_dir,
 931                          0, GRUB_FSHELP_REG);
 932
 933   if (grub_errno)
 934     goto fail;
 935
 936   if (mft != &data->cmft)
 937     {
 938       free_file (&data->cmft);
 939       grub_memcpy (&data->cmft, mft, sizeof (*mft));
 940       grub_free (mft);
 941       if (!data->cmft.inode_read)
 942         {
 943           if (init_file (&data->cmft, data->cmft.ino))
 944             goto fail;
 945         }
 946     }
 947
 948   file->size = data->cmft.size;
 949   file->data = data;
 950   file->offset = 0;
 951
 952   return 0;
 953
 954 fail:
 955   if (data)
 956     {
 957       free_file (&data->mmft);
 958       free_file (&data->cmft);
 959       grub_free (data);
 960     }
 961
 962   grub_dl_unref (my_mod);
 963
 964   return grub_errno;
 965 }
 966
 967 static grub_ssize_t
 968 grub_ntfs_read (grub_file_t file, char *buf, grub_size_t len)
 969 {
 970   struct grub_ntfs_file *mft;
 971
 972   mft = &((struct grub_ntfs_data *) file->data)->cmft;
 973   if (file->read_hook)
 974     mft->attr.save_pos = 1;
 975
 976   if (file->offset > file->size)
 977     {
 978       grub_error (GRUB_ERR_BAD_FS, "Bad offset");
 979       return -1;
 980     }
 981
 982   if (file->offset + len > file->size)
 983     len = file->size - file->offset;
 984
 985   read_attr (&mft->attr, buf, file->offset, len, 1, file->read_hook);
 986   return (grub_errno) ? 0 : len;
 987 }
 988
 989 static grub_err_t
 990 grub_ntfs_close (grub_file_t file)
 991 {
 992   struct grub_ntfs_data *data;
 993
 994   data = file->data;
 995
 996   if (data)
 997     {
 998       free_file (&data->mmft);
 999       free_file (&data->cmft);
1000       grub_free (data);
1001     }
1002
1003   grub_dl_unref (my_mod);
1004
1005   return grub_errno;
1006 }
1007
1008 static grub_err_t
1009 grub_ntfs_label (grub_device_t device, char **label)
1010 {
1011   struct grub_ntfs_data *data = 0;
1012   struct grub_fshelp_node *mft = 0;
1013   char *pa;
1014
1015   grub_dl_ref (my_mod);
1016
1017   *label = 0;
1018
1019   data = grub_ntfs_mount (device->disk);
1020   if (!data)
1021     goto fail;
1022
1023   grub_fshelp_find_file ("/$Volume", &data->cmft, &mft, grub_ntfs_iterate_dir,
1024                          0, GRUB_FSHELP_REG);
1025
1026   if (grub_errno)
1027     goto fail;
1028
1029   if (!mft->inode_read)
1030     {
1031       mft->buf = grub_malloc (mft->data->mft_size << BLK_SHR);
1032       if (mft->buf == NULL)
1033         goto fail;
1034
1035       if (read_mft (mft->data, mft->buf, mft->ino))
1036         goto fail;
1037     }
1038
1039   init_attr (&mft->attr, mft);
1040   pa = find_attr (&mft->attr, AT_VOLUME_NAME);
1041   if ((pa) && (pa[8] == 0) && (u32at (pa, 0x10)))
1042     {
1043       char *buf;
1044       int len;
1045
1046       len = u32at (pa, 0x10) / 2;
1047       buf = grub_malloc (len * 4 + 1);
1048       pa += u16at (pa, 0x14);
1049       *grub_utf16_to_utf8 ((grub_uint8_t *) buf, (grub_uint16_t *) pa, len) =
1050         '\0';
1051       *label = buf;
1052     }
1053
1054 fail:
1055   if ((mft) && (mft != &data->cmft))
1056     {
1057       free_file (mft);
1058       grub_free (mft);
1059     }
1060   if (data)
1061     {
1062       free_file (&data->mmft);
1063       free_file (&data->cmft);
1064       grub_free (data);
1065     }
1066
1067   grub_dl_unref (my_mod);
1068
1069   return grub_errno;
1070 }
1071
1072 static grub_err_t
1073 grub_ntfs_uuid (grub_device_t device, char **uuid)
1074 {
1075   struct grub_ntfs_data *data;
1076   grub_disk_t disk = device->disk;
1077
1078   grub_dl_ref (my_mod);
1079
1080   data = grub_ntfs_mount (disk);
1081   if (data)
1082     {
1083       *uuid = grub_malloc (16 + sizeof ('\0'));
1084       grub_sprintf (*uuid, "%016llx", (unsigned long long) data->uuid);
1085     }
1086   else
1087     *uuid = NULL;
1088
1089   grub_dl_unref (my_mod);
1090
1091   grub_free (data);
1092
1093   return grub_errno;
1094 }
1095
1096 static struct grub_fs grub_ntfs_fs = {
1097   .name = "ntfs",
1098   .dir = grub_ntfs_dir,
1099   .open = grub_ntfs_open,
1100   .read = grub_ntfs_read,
1101   .close = grub_ntfs_close,
1102   .label = grub_ntfs_label,
1103   .uuid = grub_ntfs_uuid,
1104   .next = 0
1105 };
1106
1107 GRUB_MOD_INIT (ntfs)
1108 {
1109   grub_fs_register (&grub_ntfs_fs);
1110   my_mod = mod;
1111 }
1112
1113 GRUB_MOD_FINI (ntfs)
1114 {
1115   grub_fs_unregister (&grub_ntfs_fs);
1116 }