← Back to branch summary

~ubuntu-branches/ubuntu/trusty/grub2/trusty-updates

« back to all changes in this revision

Viewing changes to grub-core/fs/ntfs.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-09-13 18:02:04 UTC
  • mfrom: (1.17.15 upstream)
  • mto: (17.6.27 experimental)
  • mto: This revision was merged to the branch mainline in revision 145.
  • Revision ID: package-import@ubuntu.com-20120913180204-mojnmocbimlom4im
Tags: upstream-2.00
Import upstream version 2.00

Show diffs side-by-side

added added

removed removed

Lines of Context:
grub-core/fs/ntfs.c
17
17
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
18
 */
19
19
 
 
20
#define grub_fshelp_node grub_ntfs_file 
 
21
 
20
22
#include <grub/file.h>
21
23
#include <grub/mm.h>
22
24
#include <grub/misc.h>
30
32
 
31
33
static grub_dl_t my_mod;
32
34
 
33
 
ntfscomp_func_t grub_ntfscomp_func;
 
35
#define grub_fshelp_node grub_ntfs_file 
 
36
 
 
37
static inline grub_uint16_t
 
38
u16at (void *ptr, grub_size_t ofs)
 
39
{
 
40
  return grub_le_to_cpu16 (grub_get_unaligned16 ((char *) ptr + ofs));
 
41
}
 
42
 
 
43
static inline grub_uint32_t
 
44
u32at (void *ptr, grub_size_t ofs)
 
45
{
 
46
  return grub_le_to_cpu32 (grub_get_unaligned32 ((char *) ptr + ofs));
 
47
}
 
48
 
 
49
static inline grub_uint64_t
 
50
u64at (void *ptr, grub_size_t ofs)
 
51
{
 
52
  return grub_le_to_cpu64 (grub_get_unaligned64 ((char *) ptr + ofs));
 
53
}
 
54
 
 
55
grub_ntfscomp_func_t grub_ntfscomp_func;
34
56
 
35
57
static grub_err_t
36
 
fixup (struct grub_ntfs_data *data, char *buf, int len, char *magic)
 
58
fixup (char *buf, int len, const char *magic)
37
59
{
38
60
  int ss;
39
61
  char *pu;
40
62
  grub_uint16_t us;
41
63
 
 
64
  COMPILE_TIME_ASSERT ((1 << GRUB_NTFS_BLK_SHR) == GRUB_DISK_SECTOR_SIZE);
 
65
 
42
66
  if (grub_memcmp (buf, magic, 4))
43
67
    return grub_error (GRUB_ERR_BAD_FS, "%s label not found", magic);
44
68
 
45
69
  ss = u16at (buf, 6) - 1;
46
 
  if (ss * (int) data->blocksize != len * GRUB_DISK_SECTOR_SIZE)
47
 
    return grub_error (GRUB_ERR_BAD_FS, "size not match",
48
 
                       ss * (int) data->blocksize,
49
 
                       len * GRUB_DISK_SECTOR_SIZE);
 
70
  if (ss != len)
 
71
    return grub_error (GRUB_ERR_BAD_FS, "size not match");
50
72
  pu = buf + u16at (buf, 4);
51
73
  us = u16at (pu, 0);
52
74
  buf -= 2;
53
75
  while (ss > 0)
54
76
    {
55
 
      buf += data->blocksize;
 
77
      buf += GRUB_DISK_SECTOR_SIZE;
56
78
      pu += 2;
57
79
      if (u16at (buf, 0) != us)
58
80
        return grub_error (GRUB_ERR_BAD_FS, "fixup signature not match");
59
 
      v16at (buf, 0) = v16at (pu, 0);
 
81
      buf[0] = pu[0];
 
82
      buf[1] = pu[1];
60
83
      ss--;
61
84
    }
62
85
 
87
110
init_attr (struct grub_ntfs_attr *at, struct grub_ntfs_file *mft)
88
111
{
89
112
  at->mft = mft;
90
 
  at->flags = (mft == &mft->data->mmft) ? AF_MMFT : 0;
 
113
  at->flags = (mft == &mft->data->mmft) ? GRUB_NTFS_AF_MMFT : 0;
91
114
  at->attr_nxt = mft->buf + u16at (mft->buf, 0x14);
92
115
  at->attr_end = at->emft_buf = at->edat_buf = at->sbuf = NULL;
93
116
}
103
126
static char *
104
127
find_attr (struct grub_ntfs_attr *at, unsigned char attr)
105
128
{
106
 
  if (at->flags & AF_ALST)
 
129
  if (at->flags & GRUB_NTFS_AF_ALST)
107
130
    {
108
131
    retry:
109
132
      while (at->attr_nxt < at->attr_end)
114
137
            {
115
138
              char *new_pos;
116
139
 
117
 
              if (at->flags & AF_MMFT)
 
140
              if (at->flags & GRUB_NTFS_AF_MMFT)
118
141
                {
119
142
                  if ((grub_disk_read
120
 
                       (at->mft->data->disk, v32at (at->attr_cur, 0x10), 0,
 
143
                       (at->mft->data->disk, u32at (at->attr_cur, 0x10), 0,
121
144
                        512, at->emft_buf))
122
145
                      ||
123
146
                      (grub_disk_read
124
 
                       (at->mft->data->disk, v32at (at->attr_cur, 0x14), 0,
 
147
                       (at->mft->data->disk, u32at (at->attr_cur, 0x14), 0,
125
148
                        512, at->emft_buf + 512)))
126
149
                    return NULL;
127
150
 
128
 
                  if (fixup
129
 
                      (at->mft->data, at->emft_buf, at->mft->data->mft_size,
130
 
                       "FILE"))
 
151
                  if (fixup (at->emft_buf, at->mft->data->mft_size, "FILE"))
131
152
                    return NULL;
132
153
                }
133
154
              else
160
181
  while ((unsigned char) *at->attr_cur != 0xFF)
161
182
    {
162
183
      at->attr_nxt += u16at (at->attr_cur, 4);
163
 
      if ((unsigned char) *at->attr_cur == AT_ATTRIBUTE_LIST)
 
184
      if ((unsigned char) *at->attr_cur == GRUB_NTFS_AT_ATTRIBUTE_LIST)
164
185
        at->attr_end = at->attr_cur;
165
186
      if (((unsigned char) *at->attr_cur == attr) || (attr == 0))
166
187
        return at->attr_cur;
170
191
    {
171
192
      char *pa;
172
193
 
173
 
      at->emft_buf = grub_malloc (at->mft->data->mft_size << BLK_SHR);
 
194
      at->emft_buf = grub_malloc (at->mft->data->mft_size << GRUB_NTFS_BLK_SHR);
174
195
      if (at->emft_buf == NULL)
175
196
        return NULL;
176
197
 
199
220
          at->attr_nxt = at->attr_end + u16at (pa, 0x14);
200
221
          at->attr_end = at->attr_end + u32at (pa, 4);
201
222
        }
202
 
      at->flags |= AF_ALST;
 
223
      at->flags |= GRUB_NTFS_AF_ALST;
203
224
      while (at->attr_nxt < at->attr_end)
204
225
        {
205
226
          if (((unsigned char) *at->attr_nxt == attr) || (attr == 0))
209
230
      if (at->attr_nxt >= at->attr_end)
210
231
        return NULL;
211
232
 
212
 
      if ((at->flags & AF_MMFT) && (attr == AT_DATA))
 
233
      if ((at->flags & GRUB_NTFS_AF_MMFT) && (attr == GRUB_NTFS_AT_DATA))
213
234
        {
214
 
          at->flags |= AF_GPOS;
 
235
          at->flags |= GRUB_NTFS_AF_GPOS;
215
236
          at->attr_cur = at->attr_nxt;
216
237
          pa = at->attr_cur;
217
 
          v32at (pa, 0x10) = at->mft->data->mft_start;
218
 
          v32at (pa, 0x14) = at->mft->data->mft_start + 1;
 
238
          grub_set_unaligned32 ((char *) pa + 0x10,
 
239
                                grub_cpu_to_le32 (at->mft->data->mft_start));
 
240
          grub_set_unaligned32 ((char *) pa + 0x14,
 
241
                                grub_cpu_to_le32 (at->mft->data->mft_start
 
242
                                                  + 1));
219
243
          pa = at->attr_nxt + u16at (pa, 4);
220
244
          while (pa < at->attr_end)
221
245
            {
223
247
                break;
224
248
              if (read_attr
225
249
                  (at, pa + 0x10,
226
 
                   u32at (pa, 0x10) * (at->mft->data->mft_size << BLK_SHR),
227
 
                   at->mft->data->mft_size << BLK_SHR, 0, 0))
 
250
                   u32at (pa, 0x10) * (at->mft->data->mft_size << GRUB_NTFS_BLK_SHR),
 
251
                   at->mft->data->mft_size << GRUB_NTFS_BLK_SHR, 0, 0))
228
252
                return NULL;
229
253
              pa += u16at (pa, 4);
230
254
            }
231
255
          at->attr_nxt = at->attr_cur;
232
 
          at->flags &= ~AF_GPOS;
 
256
          at->flags &= ~GRUB_NTFS_AF_GPOS;
233
257
        }
234
258
      goto retry;
235
259
    }
243
267
  char *pa;
244
268
 
245
269
  init_attr (at, mft);
246
 
  if ((pa = find_attr (at, attr)) == NULL)
 
270
  pa = find_attr (at, attr);
 
271
  if (pa == NULL)
247
272
    return NULL;
248
 
  if ((at->flags & AF_ALST) == 0)
 
273
  if ((at->flags & GRUB_NTFS_AF_ALST) == 0)
249
274
    {
250
275
      while (1)
251
276
        {
252
 
          if ((pa = find_attr (at, attr)) == NULL)
 
277
          pa = find_attr (at, attr);
 
278
          if (pa == NULL)
253
279
            break;
254
 
          if (at->flags & AF_ALST)
 
280
          if (at->flags & GRUB_NTFS_AF_ALST)
255
281
            return pa;
256
282
        }
257
283
      grub_errno = GRUB_ERR_NONE;
296
322
  c2 = ((unsigned char) (*run) >> 4);
297
323
  if (!c1)
298
324
    {
299
 
      if ((ctx->attr) && (ctx->attr->flags & AF_ALST))
 
325
      if ((ctx->attr) && (ctx->attr->flags & GRUB_NTFS_AF_ALST))
300
326
        {
301
327
          void NESTED_FUNC_ATTR (*save_hook) (grub_disk_addr_t sector,
302
328
                                              unsigned offset,
325
351
  run = read_run_data (run, c2, &val, 1);       /* offset to previous LCN */
326
352
  ctx->curr_lcn += val;
327
353
  if (val == 0)
328
 
    ctx->flags |= RF_BLNK;
 
354
    ctx->flags |= GRUB_NTFS_RF_BLNK;
329
355
  else
330
 
    ctx->flags &= ~RF_BLNK;
 
356
    ctx->flags &= ~GRUB_NTFS_RF_BLNK;
331
357
  ctx->cur_run = run;
332
358
  return 0;
333
359
}
345
371
      return ctx->curr_lcn;
346
372
    }
347
373
  else
348
 
    return (ctx->flags & RF_BLNK) ? 0 : (block -
 
374
    return (ctx->flags & GRUB_NTFS_RF_BLNK) ? 0 : (block -
349
375
                                         ctx->curr_vcn + ctx->curr_lcn);
350
376
}
351
377
 
376
402
      return 0;
377
403
    }
378
404
 
379
 
  if (u16at (pa, 0xC) & FLAG_COMPRESSED)
380
 
    ctx->flags |= RF_COMP;
 
405
  if (u16at (pa, 0xC) & GRUB_NTFS_FLAG_COMPRESSED)
 
406
    ctx->flags |= GRUB_NTFS_RF_COMP;
381
407
  else
382
 
    ctx->flags &= ~RF_COMP;
 
408
    ctx->flags &= ~GRUB_NTFS_RF_COMP;
383
409
  ctx->cur_run = pa + u16at (pa, 0x20);
384
410
 
385
 
  if (ctx->flags & RF_COMP)
 
411
  if (ctx->flags & GRUB_NTFS_RF_COMP)
386
412
    {
387
413
      if (!cached)
388
414
        return grub_error (GRUB_ERR_BAD_FS, "attribute can\'t be compressed");
389
415
 
390
416
      if (at->sbuf)
391
417
        {
392
 
          if ((ofs & (~(COM_LEN - 1))) == at->save_pos)
 
418
          if ((ofs & (~(GRUB_NTFS_COM_LEN - 1))) == at->save_pos)
393
419
            {
394
420
              grub_disk_addr_t n;
395
421
 
396
 
              n = COM_LEN - (ofs - at->save_pos);
 
422
              n = GRUB_NTFS_COM_LEN - (ofs - at->save_pos);
397
423
              if (n > len)
398
424
                n = len;
399
425
 
408
434
        }
409
435
      else
410
436
        {
411
 
          at->sbuf = grub_malloc (COM_LEN);
 
437
          at->sbuf = grub_malloc (GRUB_NTFS_COM_LEN);
412
438
          if (at->sbuf == NULL)
413
439
            return grub_errno;
414
440
          at->save_pos = 1;
415
441
        }
416
442
 
417
 
      vcn = ctx->target_vcn = (ofs >> COM_LOG_LEN) * (COM_SEC / ctx->comp.spc);
418
 
      ctx->target_vcn &= ~0xF;
 
443
      vcn = ctx->target_vcn = (ofs >> GRUB_NTFS_COM_LOG_LEN) * (GRUB_NTFS_COM_SEC / ctx->comp.spc);
 
444
      ctx->target_vcn &= ~0xFULL;
419
445
    }
420
446
  else
421
 
    vcn = ctx->target_vcn = grub_divmod64 (ofs >> BLK_SHR, ctx->comp.spc, 0);
 
447
    vcn = ctx->target_vcn = grub_divmod64 (ofs >> GRUB_NTFS_BLK_SHR, ctx->comp.spc, 0);
422
448
 
423
449
  ctx->next_vcn = u32at (pa, 0x10);
424
450
  ctx->curr_lcn = 0;
428
454
        return grub_errno;
429
455
    }
430
456
 
431
 
  if (at->flags & AF_GPOS)
 
457
  if (at->flags & GRUB_NTFS_AF_GPOS)
432
458
    {
433
459
      grub_disk_addr_t st0, st1;
434
 
      grub_uint32_t m;
 
460
      grub_uint64_t m;
435
461
 
436
 
      grub_divmod64 (ofs >> BLK_SHR, ctx->comp.spc, &m);
 
462
      grub_divmod64 (ofs >> GRUB_NTFS_BLK_SHR, ctx->comp.spc, &m);
437
463
 
438
464
      st0 =
439
465
        (ctx->target_vcn - ctx->curr_vcn + ctx->curr_lcn) * ctx->comp.spc + m;
445
471
            return grub_errno;
446
472
          st1 = ctx->curr_lcn * ctx->comp.spc;
447
473
        }
448
 
      v32at (dest, 0) = st0;
449
 
      v32at (dest, 4) = st1;
 
474
      grub_set_unaligned32 (dest, grub_cpu_to_le32 (st0));
 
475
      grub_set_unaligned32 (dest + 4, grub_cpu_to_le32 (st1));
450
476
      return 0;
451
477
    }
452
478
 
453
 
  if (!(ctx->flags & RF_COMP))
 
479
  if (!(ctx->flags & GRUB_NTFS_RF_COMP))
454
480
    {
455
481
      unsigned int pow;
456
482
 
457
483
      if (!grub_fshelp_log2blksize (ctx->comp.spc, &pow))
458
484
        grub_fshelp_read_file (ctx->comp.disk, (grub_fshelp_node_t) ctx,
459
485
                               read_hook, ofs, len, dest,
460
 
                               grub_ntfs_read_block, ofs + len, pow);
 
486
                               grub_ntfs_read_block, ofs + len, pow, 0);
461
487
      return grub_errno;
462
488
    }
463
489
 
464
490
  return (grub_ntfscomp_func) ? grub_ntfscomp_func (at, dest, ofs, len, ctx,
465
491
                                                    vcn) :
466
 
    grub_error (GRUB_ERR_BAD_FS, "ntfscomp module not loaded");
 
492
    grub_error (GRUB_ERR_BAD_FS, N_("module `%s' isn't loaded"),
 
493
                "ntfscomp");
467
494
}
468
495
 
469
496
static grub_err_t
481
508
  save_cur = at->attr_cur;
482
509
  at->attr_nxt = at->attr_cur;
483
510
  attr = (unsigned char) *at->attr_nxt;
484
 
  if (at->flags & AF_ALST)
 
511
  if (at->flags & GRUB_NTFS_AF_ALST)
485
512
    {
486
513
      char *pa;
487
514
      grub_disk_addr_t vcn;
488
515
 
489
 
      vcn = grub_divmod64 (ofs, at->mft->data->spc << BLK_SHR, 0);
 
516
      /* If compression is possible make sure that we include possible
 
517
         compressed block size.  */
 
518
      if (GRUB_NTFS_COM_SEC >= at->mft->data->spc)
 
519
        vcn = ((ofs >> GRUB_NTFS_COM_LOG_LEN)
 
520
               * (GRUB_NTFS_COM_SEC / at->mft->data->spc)) & ~0xFULL;
 
521
      else
 
522
        vcn = grub_divmod64 (ofs, at->mft->data->spc << GRUB_NTFS_BLK_SHR, 0);
490
523
      pa = at->attr_nxt + u16at (at->attr_nxt, 4);
491
524
      while (pa < at->attr_end)
492
525
        {
513
546
read_mft (struct grub_ntfs_data *data, char *buf, grub_uint32_t mftno)
514
547
{
515
548
  if (read_attr
516
 
      (&data->mmft.attr, buf, mftno * ((grub_disk_addr_t) data->mft_size << BLK_SHR),
517
 
       data->mft_size << BLK_SHR, 0, 0))
 
549
      (&data->mmft.attr, buf, mftno * ((grub_disk_addr_t) data->mft_size << GRUB_NTFS_BLK_SHR),
 
550
       data->mft_size << GRUB_NTFS_BLK_SHR, 0, 0))
518
551
    return grub_error (GRUB_ERR_BAD_FS, "read MFT 0x%X fails", mftno);
519
 
  return fixup (data, buf, data->mft_size, "FILE");
 
552
  return fixup (buf, data->mft_size, "FILE");
520
553
}
521
554
 
522
555
static grub_err_t
526
559
 
527
560
  mft->inode_read = 1;
528
561
 
529
 
  mft->buf = grub_malloc (mft->data->mft_size << BLK_SHR);
 
562
  mft->buf = grub_malloc (mft->data->mft_size << GRUB_NTFS_BLK_SHR);
530
563
  if (mft->buf == NULL)
531
564
    return grub_errno;
532
565
 
541
574
    {
542
575
      char *pa;
543
576
 
544
 
      pa = locate_attr (&mft->attr, mft, AT_DATA);
 
577
      pa = locate_attr (&mft->attr, mft, GRUB_NTFS_AT_DATA);
545
578
      if (pa == NULL)
546
579
        return grub_error (GRUB_ERR_BAD_FS, "no $DATA in MFT 0x%X", mftno);
547
580
 
550
583
      else
551
584
        mft->size = u64at (pa, 0x30);
552
585
 
553
 
      if ((mft->attr.flags & AF_ALST) == 0)
 
586
      if ((mft->attr.flags & GRUB_NTFS_AF_ALST) == 0)
554
587
        mft->attr.attr_end = 0; /*  Don't jump to attribute list */
555
588
    }
556
589
  else
595
628
        {
596
629
          enum grub_fshelp_filetype type;
597
630
          struct grub_ntfs_file *fdiro;
 
631
          grub_uint32_t attr;
598
632
 
599
633
          if (u16at (pos, 4))
600
634
            {
602
636
              return 0;
603
637
            }
604
638
 
605
 
          type =
606
 
            (u32at (pos, 0x48) & ATTR_DIRECTORY) ? GRUB_FSHELP_DIR :
607
 
            GRUB_FSHELP_REG;
 
639
          attr = u32at (pos, 0x48);
 
640
          if (attr & GRUB_NTFS_ATTR_REPARSE)
 
641
            type = GRUB_FSHELP_SYMLINK;
 
642
          else if (attr & GRUB_NTFS_ATTR_DIRECTORY)
 
643
            type = GRUB_FSHELP_DIR;
 
644
          else
 
645
            type = GRUB_FSHELP_REG;
608
646
 
609
647
          fdiro = grub_zalloc (sizeof (struct grub_ntfs_file));
610
648
          if (!fdiro)
612
650
 
613
651
          fdiro->data = diro->data;
614
652
          fdiro->ino = u32at (pos, 0);
 
653
          fdiro->mtime = u64at (pos, 0x20);
615
654
 
616
 
          ustr = grub_malloc (ns * 4 + 1);
 
655
          ustr = grub_malloc (ns * GRUB_MAX_UTF8_PER_UTF16 + 1);
617
656
          if (ustr == NULL)
618
657
            return 0;
619
 
          *grub_utf16_to_utf8 ((grub_uint8_t *) ustr, (grub_uint16_t *) np,
620
 
                               ns) = '\0';
 
658
          {
 
659
            grub_uint16_t tmp[ns];
 
660
            int i;
 
661
            for (i = 0; i < ns; i++)
 
662
              tmp[i] = grub_le_to_cpu16 (grub_get_unaligned16 ((char *) np
 
663
                                                               + 2 * i));
621
664
 
 
665
            *grub_utf16_to_utf8 ((grub_uint8_t *) ustr, tmp, ns) = '\0';
 
666
          }
622
667
          if (namespace)
623
668
            type |= GRUB_FSHELP_CASE_INSENSITIVE;
624
669
 
635
680
  return 0;
636
681
}
637
682
 
 
683
struct symlink_descriptor
 
684
{
 
685
  grub_uint32_t type;
 
686
  grub_uint32_t total_len;
 
687
  grub_uint16_t off1;
 
688
  grub_uint16_t len1;
 
689
  grub_uint16_t off2;
 
690
  grub_uint16_t len2;
 
691
} __attribute__ ((packed));
 
692
 
 
693
static char *
 
694
grub_ntfs_read_symlink (grub_fshelp_node_t node)
 
695
{
 
696
  struct grub_ntfs_file *mft;
 
697
  struct symlink_descriptor symdesc;
 
698
  grub_err_t err;
 
699
  grub_uint16_t *buf16;
 
700
  char *buf, *end;
 
701
  grub_size_t len;
 
702
  grub_size_t i;
 
703
  char *pa;
 
704
  grub_size_t off;
 
705
 
 
706
  mft = (struct grub_ntfs_file *) node;
 
707
 
 
708
  mft->buf = grub_malloc (mft->data->mft_size << GRUB_NTFS_BLK_SHR);
 
709
  if (mft->buf == NULL)
 
710
    return NULL;
 
711
 
 
712
  if (read_mft (mft->data, mft->buf, mft->ino))
 
713
    return NULL;
 
714
 
 
715
  pa = locate_attr (&mft->attr, mft, GRUB_NTFS_AT_SYMLINK);
 
716
  if (pa == NULL)
 
717
    {
 
718
      grub_error (GRUB_ERR_BAD_FS, "no $SYMLINK in MFT 0x%X", mft->ino);
 
719
      return NULL;
 
720
    }
 
721
 
 
722
  err = read_attr (&mft->attr, (char *) &symdesc, 0,
 
723
                   sizeof (struct symlink_descriptor), 1, 0);
 
724
  if (err)
 
725
    return NULL;
 
726
 
 
727
  switch (grub_cpu_to_le32 (symdesc.type))
 
728
    {
 
729
    case 0xa000000c:
 
730
      off = (sizeof (struct symlink_descriptor) + 4
 
731
             + grub_cpu_to_le32 (symdesc.off1));
 
732
      len = grub_cpu_to_le32 (symdesc.len1);
 
733
      break;
 
734
    case 0xa0000003:
 
735
      off = (sizeof (struct symlink_descriptor)
 
736
             + grub_cpu_to_le32 (symdesc.off1));
 
737
      len = grub_cpu_to_le32 (symdesc.len1);
 
738
      break;
 
739
    default:
 
740
      grub_error (GRUB_ERR_BAD_FS, "symlink type invalid (%x)",
 
741
                  grub_cpu_to_le32 (symdesc.type));
 
742
      return NULL;
 
743
    }
 
744
 
 
745
  buf16 = grub_malloc (len);
 
746
  if (!buf16)
 
747
    return NULL;
 
748
 
 
749
  err = read_attr (&mft->attr, (char *) buf16, off, len, 1, 0);
 
750
  if (err)
 
751
    return NULL;
 
752
 
 
753
  buf = grub_malloc (len * 2 + 1);
 
754
  if (!buf)
 
755
    {
 
756
      grub_free (buf16);
 
757
      return NULL;
 
758
    }
 
759
 
 
760
  for (i = 0; i < len / 2; i++)
 
761
    {
 
762
      buf16[i] = grub_le_to_cpu16 (buf16[i]);
 
763
      if (buf16[i] == '\\')
 
764
        buf16[i] = '/';
 
765
    }
 
766
 
 
767
  end = (char *) grub_utf16_to_utf8 ((grub_uint8_t *) buf, buf16, len / 2);
 
768
  *end = '\0';
 
769
  /* Split the sequence to avoid GCC thinking that this is a trigraph.  */
 
770
  if (grub_memcmp (buf, "/?" "?/", 4) == 0 && buf[5] == ':' && buf[6] == '/'
 
771
      && grub_isalpha (buf[4]))
 
772
    {
 
773
      grub_memmove (buf, buf + 6, end - buf + 1 - 6);
 
774
      end -= 6; 
 
775
    }
 
776
  return buf;
 
777
}
 
778
 
638
779
static int
639
780
grub_ntfs_iterate_dir (grub_fshelp_node_t dir,
640
781
                       int NESTED_FUNC_ATTR
664
805
  init_attr (at, mft);
665
806
  while (1)
666
807
    {
667
 
      if ((cur_pos = find_attr (at, AT_INDEX_ROOT)) == NULL)
 
808
      cur_pos = find_attr (at, GRUB_NTFS_AT_INDEX_ROOT);
 
809
      if (cur_pos == NULL)
668
810
        {
669
811
          grub_error (GRUB_ERR_BAD_FS, "no $INDEX_ROOT");
670
812
          goto done;
690
832
  bitmap_len = 0;
691
833
  free_attr (at);
692
834
  init_attr (at, mft);
693
 
  while ((cur_pos = find_attr (at, AT_BITMAP)) != NULL)
 
835
  while ((cur_pos = find_attr (at, GRUB_NTFS_AT_BITMAP)) != NULL)
694
836
    {
695
837
      int ofs;
696
838
 
731
873
    }
732
874
 
733
875
  free_attr (at);
734
 
  cur_pos = locate_attr (at, mft, AT_INDEX_ALLOCATION);
 
876
  cur_pos = locate_attr (at, mft, GRUB_NTFS_AT_INDEX_ALLOCATION);
735
877
  while (cur_pos != NULL)
736
878
    {
737
879
      /* Non-resident, Namelen=4, Offset=0x40, Flags=0, Name="$I30" */
739
881
          (u32at (cur_pos, 0x40) == 0x490024) &&
740
882
          (u32at (cur_pos, 0x44) == 0x300033))
741
883
        break;
742
 
      cur_pos = find_attr (at, AT_INDEX_ALLOCATION);
 
884
      cur_pos = find_attr (at, GRUB_NTFS_AT_INDEX_ALLOCATION);
743
885
    }
744
886
 
745
887
  if ((!cur_pos) && (bitmap))
752
894
    {
753
895
      grub_disk_addr_t v, i;
754
896
 
755
 
      indx = grub_malloc (mft->data->idx_size << BLK_SHR);
 
897
      indx = grub_malloc (mft->data->idx_size << GRUB_NTFS_BLK_SHR);
756
898
      if (indx == NULL)
757
899
        goto done;
758
900
 
762
904
          if (*bitmap & v)
763
905
            {
764
906
              if ((read_attr
765
 
                   (at, indx, i * (mft->data->idx_size << BLK_SHR),
766
 
                    (mft->data->idx_size << BLK_SHR), 0, 0))
767
 
                  || (fixup (mft->data, indx, mft->data->idx_size, "INDX")))
 
907
                   (at, indx, i * (mft->data->idx_size << GRUB_NTFS_BLK_SHR),
 
908
                    (mft->data->idx_size << GRUB_NTFS_BLK_SHR), 0, 0))
 
909
                  || (fixup (indx, mft->data->idx_size, "INDX")))
768
910
                goto done;
769
911
              ret = list_file (mft, &indx[0x18 + u16at (indx, 0x18)], hook);
770
912
              if (ret)
806
948
  if (grub_disk_read (disk, 0, 0, sizeof (bpb), &bpb))
807
949
    goto fail;
808
950
 
809
 
  if (grub_memcmp ((char *) &bpb.oem_name, "NTFS", 4))
 
951
  if (grub_memcmp ((char *) &bpb.oem_name, "NTFS", 4) != 0
 
952
      || bpb.sectors_per_cluster == 0
 
953
      || (bpb.sectors_per_cluster & (bpb.sectors_per_cluster - 1)) != 0
 
954
      || bpb.bytes_per_sector == 0
 
955
      || (bpb.bytes_per_sector & (bpb.bytes_per_sector - 1)) != 0)
810
956
    goto fail;
811
957
 
812
 
  data->blocksize = grub_le_to_cpu16 (bpb.bytes_per_sector);
813
 
  data->spc = bpb.sectors_per_cluster * (data->blocksize >> BLK_SHR);
 
958
  data->spc = (((grub_uint32_t) bpb.sectors_per_cluster
 
959
                * (grub_uint32_t) grub_le_to_cpu16 (bpb.bytes_per_sector))
 
960
               >> GRUB_NTFS_BLK_SHR);
 
961
  if (!data->spc)
 
962
    goto fail;
814
963
 
815
964
  if (bpb.clusters_per_mft > 0)
816
965
    data->mft_size = data->spc * bpb.clusters_per_mft;
817
966
  else
818
 
    data->mft_size = 1 << (-bpb.clusters_per_mft - BLK_SHR);
 
967
    data->mft_size = 1 << (-bpb.clusters_per_mft - GRUB_NTFS_BLK_SHR);
819
968
 
820
969
  if (bpb.clusters_per_index > 0)
821
970
    data->idx_size = data->spc * bpb.clusters_per_index;
822
971
  else
823
 
    data->idx_size = 1 << (-bpb.clusters_per_index - BLK_SHR);
 
972
    data->idx_size = 1 << (-bpb.clusters_per_index - GRUB_NTFS_BLK_SHR);
824
973
 
825
974
  data->mft_start = grub_le_to_cpu64 (bpb.mft_lcn) * data->spc;
826
975
 
827
 
  if ((data->mft_size > MAX_MFT) || (data->idx_size > MAX_IDX))
 
976
  if ((data->mft_size > GRUB_NTFS_MAX_MFT) || (data->idx_size > GRUB_NTFS_MAX_IDX))
828
977
    goto fail;
829
978
 
830
979
  data->mmft.data = data;
831
980
  data->cmft.data = data;
832
981
 
833
 
  data->mmft.buf = grub_malloc (data->mft_size << BLK_SHR);
 
982
  data->mmft.buf = grub_malloc (data->mft_size << GRUB_NTFS_BLK_SHR);
834
983
  if (!data->mmft.buf)
835
984
    goto fail;
836
985
 
837
986
  if (grub_disk_read
838
 
      (disk, data->mft_start, 0, data->mft_size << BLK_SHR, data->mmft.buf))
 
987
      (disk, data->mft_start, 0, data->mft_size << GRUB_NTFS_BLK_SHR, data->mmft.buf))
839
988
    goto fail;
840
989
 
841
990
  data->uuid = grub_le_to_cpu64 (bpb.num_serial);
842
991
 
843
 
  if (fixup (data, data->mmft.buf, data->mft_size, "FILE"))
844
 
    goto fail;
845
 
 
846
 
  if (!locate_attr (&data->mmft.attr, &data->mmft, AT_DATA))
847
 
    goto fail;
848
 
 
849
 
  if (init_file (&data->cmft, FILE_ROOT))
 
992
  if (fixup (data->mmft.buf, data->mft_size, "FILE"))
 
993
    goto fail;
 
994
 
 
995
  if (!locate_attr (&data->mmft.attr, &data->mmft, GRUB_NTFS_AT_DATA))
 
996
    goto fail;
 
997
 
 
998
  if (init_file (&data->cmft, GRUB_NTFS_FILE_ROOT))
850
999
    goto fail;
851
1000
 
852
1001
  return data;
882
1031
      struct grub_dirhook_info info;
883
1032
      grub_memset (&info, 0, sizeof (info));
884
1033
      info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
 
1034
      info.mtimeset = 1;
 
1035
      info.mtime = grub_divmod64 (node->mtime, 10000000, 0) 
 
1036
        - 86400ULL * 365 * (1970 - 1601)
 
1037
        - 86400ULL * ((1970 - 1601) / 4) + 86400ULL * ((1970 - 1601) / 100);
885
1038
      grub_free (node);
886
1039
      return hook (filename, &info);
887
1040
  }
893
1046
    goto fail;
894
1047
 
895
1048
  grub_fshelp_find_file (path, &data->cmft, &fdiro, grub_ntfs_iterate_dir,
896
 
                         0, GRUB_FSHELP_DIR);
 
1049
                         grub_ntfs_read_symlink, GRUB_FSHELP_DIR);
897
1050
 
898
1051
  if (grub_errno)
899
1052
    goto fail;
931
1084
    goto fail;
932
1085
 
933
1086
  grub_fshelp_find_file (name, &data->cmft, &mft, grub_ntfs_iterate_dir,
934
 
                         0, GRUB_FSHELP_REG);
 
1087
                         grub_ntfs_read_symlink, GRUB_FSHELP_REG);
935
1088
 
936
1089
  if (grub_errno)
937
1090
    goto fail;
977
1130
    mft->attr.save_pos = 1;
978
1131
 
979
1132
  read_attr (&mft->attr, buf, file->offset, len, 1, file->read_hook);
980
 
  return (grub_errno) ? 0 : len;
 
1133
  return (grub_errno) ? -1 : (grub_ssize_t) len;
981
1134
}
982
1135
 
983
1136
static grub_err_t
1022
1175
 
1023
1176
  if (!mft->inode_read)
1024
1177
    {
1025
 
      mft->buf = grub_malloc (mft->data->mft_size << BLK_SHR);
 
1178
      mft->buf = grub_malloc (mft->data->mft_size << GRUB_NTFS_BLK_SHR);
1026
1179
      if (mft->buf == NULL)
1027
1180
        goto fail;
1028
1181
 
1031
1184
    }
1032
1185
 
1033
1186
  init_attr (&mft->attr, mft);
1034
 
  pa = find_attr (&mft->attr, AT_VOLUME_NAME);
 
1187
  pa = find_attr (&mft->attr, GRUB_NTFS_AT_VOLUME_NAME);
1035
1188
  if ((pa) && (pa[8] == 0) && (u32at (pa, 0x10)))
1036
1189
    {
1037
1190
      char *buf;
1040
1193
      len = u32at (pa, 0x10) / 2;
1041
1194
      buf = grub_malloc (len * 4 + 1);
1042
1195
      pa += u16at (pa, 0x14);
1043
 
      *grub_utf16_to_utf8 ((grub_uint8_t *) buf, (grub_uint16_t *) pa, len) =
1044
 
        '\0';
 
1196
      {
 
1197
        grub_uint16_t tmp[len];
 
1198
        int i;
 
1199
        for (i = 0; i < len; i++)
 
1200
          tmp[i] = grub_le_to_cpu16 (grub_get_unaligned16 (pa + 2 * i));
 
1201
        *grub_utf16_to_utf8 ((grub_uint8_t *) buf, tmp, len) =
 
1202
          '\0';
 
1203
      }
1045
1204
      *label = buf;
1046
1205
    }
1047
1206
 
1079
1238
      if (*uuid)
1080
1239
        for (ptr = *uuid; *ptr; ptr++)
1081
1240
          *ptr = grub_toupper (*ptr);
 
1241
      free_file (&data->mmft);
 
1242
      free_file (&data->cmft);
 
1243
      grub_free (data);
1082
1244
    }
1083
1245
  else
1084
1246
    *uuid = NULL;
1085
1247
 
1086
1248
  grub_dl_unref (my_mod);
1087
1249
 
1088
 
  grub_free (data);
1089
 
 
1090
1250
  return grub_errno;
1091
1251
}
1092
1252
 
1101
1261
    .uuid = grub_ntfs_uuid,
1102
1262
#ifdef GRUB_UTIL
1103
1263
    .reserved_first_sector = 1,
 
1264
    .blocklist_install = 1,
1104
1265
#endif
1105
1266
    .next = 0
1106
1267
};