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