1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * 4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved. 5 * 6 * Directory handling functions for NTFS-based filesystems. 7 * 8 */ 9 10 #include <linux/blkdev.h> 11 #include <linux/buffer_head.h> 12 #include <linux/fs.h> 13 #include <linux/iversion.h> 14 #include <linux/nls.h> 15 16 #include "debug.h" 17 #include "ntfs.h" 18 #include "ntfs_fs.h" 19 20 /* Convert little endian UTF-16 to NLS string. */ 21 int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const struct le_str *uni, 22 u8 *buf, int buf_len) 23 { 24 int ret, uni_len, warn; 25 const __le16 *ip; 26 u8 *op; 27 struct nls_table *nls = sbi->options.nls; 28 29 static_assert(sizeof(wchar_t) == sizeof(__le16)); 30 31 if (!nls) { 32 /* UTF-16 -> UTF-8 */ 33 ret = utf16s_to_utf8s((wchar_t *)uni->name, uni->len, 34 UTF16_LITTLE_ENDIAN, buf, buf_len); 35 buf[ret] = '\0'; 36 return ret; 37 } 38 39 ip = uni->name; 40 op = buf; 41 uni_len = uni->len; 42 warn = 0; 43 44 while (uni_len--) { 45 u16 ec; 46 int charlen; 47 char dump[5]; 48 49 if (buf_len < NLS_MAX_CHARSET_SIZE) { 50 ntfs_warn(sbi->sb, 51 "filename was truncated while converting."); 52 break; 53 } 54 55 ec = le16_to_cpu(*ip++); 56 charlen = nls->uni2char(ec, op, buf_len); 57 58 if (charlen > 0) { 59 op += charlen; 60 buf_len -= charlen; 61 continue; 62 } 63 64 *op++ = '_'; 65 buf_len -= 1; 66 if (warn) 67 continue; 68 69 warn = 1; 70 hex_byte_pack(&dump[0], ec >> 8); 71 hex_byte_pack(&dump[2], ec); 72 dump[4] = 0; 73 74 ntfs_err(sbi->sb, "failed to convert \"%s\" to %s", dump, 75 nls->charset); 76 } 77 78 *op = '\0'; 79 return op - buf; 80 } 81 82 // clang-format off 83 #define PLANE_SIZE 0x00010000 84 85 #define SURROGATE_PAIR 0x0000d800 86 #define SURROGATE_LOW 0x00000400 87 #define SURROGATE_BITS 0x000003ff 88 // clang-format on 89 90 /* 91 * put_utf16 - Modified version of put_utf16 from fs/nls/nls_base.c 92 * 93 * Function is sparse warnings free. 94 */ 95 static inline void put_utf16(wchar_t *s, unsigned int c, 96 enum utf16_endian endian) 97 { 98 static_assert(sizeof(wchar_t) == sizeof(__le16)); 99 static_assert(sizeof(wchar_t) == sizeof(__be16)); 100 101 switch (endian) { 102 default: 103 *s = (wchar_t)c; 104 break; 105 case UTF16_LITTLE_ENDIAN: 106 *(__le16 *)s = __cpu_to_le16(c); 107 break; 108 case UTF16_BIG_ENDIAN: 109 *(__be16 *)s = __cpu_to_be16(c); 110 break; 111 } 112 } 113 114 /* 115 * _utf8s_to_utf16s 116 * 117 * Modified version of 'utf8s_to_utf16s' allows to 118 * detect -ENAMETOOLONG without writing out of expected maximum. 119 */ 120 static int _utf8s_to_utf16s(const u8 *s, int inlen, enum utf16_endian endian, 121 wchar_t *pwcs, int maxout) 122 { 123 u16 *op; 124 int size; 125 unicode_t u; 126 127 op = pwcs; 128 while (inlen > 0 && *s) { 129 if (*s & 0x80) { 130 size = utf8_to_utf32(s, inlen, &u); 131 if (size < 0) 132 return -EINVAL; 133 s += size; 134 inlen -= size; 135 136 if (u >= PLANE_SIZE) { 137 if (maxout < 2) 138 return -ENAMETOOLONG; 139 140 u -= PLANE_SIZE; 141 put_utf16(op++, 142 SURROGATE_PAIR | 143 ((u >> 10) & SURROGATE_BITS), 144 endian); 145 put_utf16(op++, 146 SURROGATE_PAIR | SURROGATE_LOW | 147 (u & SURROGATE_BITS), 148 endian); 149 maxout -= 2; 150 } else { 151 if (maxout < 1) 152 return -ENAMETOOLONG; 153 154 put_utf16(op++, u, endian); 155 maxout--; 156 } 157 } else { 158 if (maxout < 1) 159 return -ENAMETOOLONG; 160 161 put_utf16(op++, *s++, endian); 162 inlen--; 163 maxout--; 164 } 165 } 166 return op - pwcs; 167 } 168 169 /* 170 * ntfs_nls_to_utf16 - Convert input string to UTF-16. 171 * @name: Input name. 172 * @name_len: Input name length. 173 * @uni: Destination memory. 174 * @max_ulen: Destination memory. 175 * @endian: Endian of target UTF-16 string. 176 * 177 * This function is called: 178 * - to create NTFS name 179 * - to create symlink 180 * 181 * Return: UTF-16 string length or error (if negative). 182 */ 183 int ntfs_nls_to_utf16(struct ntfs_sb_info *sbi, const u8 *name, u32 name_len, 184 struct cpu_str *uni, u32 max_ulen, 185 enum utf16_endian endian) 186 { 187 int ret, slen; 188 const u8 *end; 189 struct nls_table *nls = sbi->options.nls; 190 u16 *uname = uni->name; 191 192 static_assert(sizeof(wchar_t) == sizeof(u16)); 193 194 if (!nls) { 195 /* utf8 -> utf16 */ 196 ret = _utf8s_to_utf16s(name, name_len, endian, uname, max_ulen); 197 uni->len = ret; 198 return ret; 199 } 200 201 for (ret = 0, end = name + name_len; name < end; ret++, name += slen) { 202 if (ret >= max_ulen) 203 return -ENAMETOOLONG; 204 205 slen = nls->char2uni(name, end - name, uname + ret); 206 if (!slen) 207 return -EINVAL; 208 if (slen < 0) 209 return slen; 210 } 211 212 #ifdef __BIG_ENDIAN 213 if (endian == UTF16_LITTLE_ENDIAN) { 214 int i = ret; 215 216 while (i--) { 217 __cpu_to_le16s(uname); 218 uname++; 219 } 220 } 221 #else 222 if (endian == UTF16_BIG_ENDIAN) { 223 int i = ret; 224 225 while (i--) { 226 __cpu_to_be16s(uname); 227 uname++; 228 } 229 } 230 #endif 231 232 uni->len = ret; 233 return ret; 234 } 235 236 /* 237 * dir_search_u - Helper function. 238 */ 239 struct inode *dir_search_u(struct inode *dir, const struct cpu_str *uni, 240 struct ntfs_fnd *fnd) 241 { 242 int err = 0; 243 struct super_block *sb = dir->i_sb; 244 struct ntfs_sb_info *sbi = sb->s_fs_info; 245 struct ntfs_inode *ni = ntfs_i(dir); 246 struct NTFS_DE *e; 247 int diff; 248 struct inode *inode = NULL; 249 struct ntfs_fnd *fnd_a = NULL; 250 251 if (!fnd) { 252 fnd_a = fnd_get(); 253 if (!fnd_a) { 254 err = -ENOMEM; 255 goto out; 256 } 257 fnd = fnd_a; 258 } 259 260 err = indx_find(&ni->dir, ni, NULL, uni, 0, sbi, &diff, &e, fnd); 261 262 if (err) 263 goto out; 264 265 if (diff) { 266 err = -ENOENT; 267 goto out; 268 } 269 270 inode = ntfs_iget5(sb, &e->ref, uni); 271 if (!IS_ERR(inode) && is_bad_inode(inode)) { 272 iput(inode); 273 err = -EINVAL; 274 } 275 out: 276 fnd_put(fnd_a); 277 278 return err == -ENOENT ? NULL : err ? ERR_PTR(err) : inode; 279 } 280 281 static inline int ntfs_filldir(struct ntfs_sb_info *sbi, struct ntfs_inode *ni, 282 const struct NTFS_DE *e, u8 *name, 283 struct dir_context *ctx) 284 { 285 const struct ATTR_FILE_NAME *fname; 286 unsigned long ino; 287 int name_len; 288 u32 dt_type; 289 290 fname = Add2Ptr(e, sizeof(struct NTFS_DE)); 291 292 if (fname->type == FILE_NAME_DOS) 293 return 0; 294 295 if (!mi_is_ref(&ni->mi, &fname->home)) 296 return 0; 297 298 ino = ino_get(&e->ref); 299 300 if (ino == MFT_REC_ROOT) 301 return 0; 302 303 /* Skip meta files. Unless option to show metafiles is set. */ 304 if (!sbi->options.showmeta && ntfs_is_meta_file(sbi, ino)) 305 return 0; 306 307 if (sbi->options.nohidden && (fname->dup.fa & FILE_ATTRIBUTE_HIDDEN)) 308 return 0; 309 310 name_len = ntfs_utf16_to_nls(sbi, (struct le_str *)&fname->name_len, 311 name, PATH_MAX); 312 if (name_len <= 0) { 313 ntfs_warn(sbi->sb, "failed to convert name for inode %lx.", 314 ino); 315 return 0; 316 } 317 318 dt_type = (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY) ? DT_DIR : DT_REG; 319 320 return !dir_emit(ctx, (s8 *)name, name_len, ino, dt_type); 321 } 322 323 /* 324 * ntfs_read_hdr - Helper function for ntfs_readdir(). 325 */ 326 static int ntfs_read_hdr(struct ntfs_sb_info *sbi, struct ntfs_inode *ni, 327 const struct INDEX_HDR *hdr, u64 vbo, u64 pos, 328 u8 *name, struct dir_context *ctx) 329 { 330 int err; 331 const struct NTFS_DE *e; 332 u32 e_size; 333 u32 end = le32_to_cpu(hdr->used); 334 u32 off = le32_to_cpu(hdr->de_off); 335 336 for (;; off += e_size) { 337 if (off + sizeof(struct NTFS_DE) > end) 338 return -1; 339 340 e = Add2Ptr(hdr, off); 341 e_size = le16_to_cpu(e->size); 342 if (e_size < sizeof(struct NTFS_DE) || off + e_size > end) 343 return -1; 344 345 if (de_is_last(e)) 346 return 0; 347 348 /* Skip already enumerated. */ 349 if (vbo + off < pos) 350 continue; 351 352 if (le16_to_cpu(e->key_size) < SIZEOF_ATTRIBUTE_FILENAME) 353 return -1; 354 355 ctx->pos = vbo + off; 356 357 /* Submit the name to the filldir callback. */ 358 err = ntfs_filldir(sbi, ni, e, name, ctx); 359 if (err) 360 return err; 361 } 362 } 363 364 /* 365 * ntfs_readdir - file_operations::iterate_shared 366 * 367 * Use non sorted enumeration. 368 * We have an example of broken volume where sorted enumeration 369 * counts each name twice. 370 */ 371 static int ntfs_readdir(struct file *file, struct dir_context *ctx) 372 { 373 const struct INDEX_ROOT *root; 374 u64 vbo; 375 size_t bit; 376 loff_t eod; 377 int err = 0; 378 struct inode *dir = file_inode(file); 379 struct ntfs_inode *ni = ntfs_i(dir); 380 struct super_block *sb = dir->i_sb; 381 struct ntfs_sb_info *sbi = sb->s_fs_info; 382 loff_t i_size = i_size_read(dir); 383 u32 pos = ctx->pos; 384 u8 *name = NULL; 385 struct indx_node *node = NULL; 386 u8 index_bits = ni->dir.index_bits; 387 388 /* Name is a buffer of PATH_MAX length. */ 389 static_assert(NTFS_NAME_LEN * 4 < PATH_MAX); 390 391 eod = i_size + sbi->record_size; 392 393 if (pos >= eod) 394 return 0; 395 396 if (!dir_emit_dots(file, ctx)) 397 return 0; 398 399 /* Allocate PATH_MAX bytes. */ 400 name = __getname(); 401 if (!name) 402 return -ENOMEM; 403 404 if (!ni->mi_loaded && ni->attr_list.size) { 405 /* 406 * Directory inode is locked for read. 407 * Load all subrecords to avoid 'write' access to 'ni' during 408 * directory reading. 409 */ 410 ni_lock(ni); 411 if (!ni->mi_loaded && ni->attr_list.size) { 412 err = ni_load_all_mi(ni); 413 if (!err) 414 ni->mi_loaded = true; 415 } 416 ni_unlock(ni); 417 if (err) 418 goto out; 419 } 420 421 root = indx_get_root(&ni->dir, ni, NULL, NULL); 422 if (!root) { 423 err = -EINVAL; 424 goto out; 425 } 426 427 if (pos >= sbi->record_size) { 428 bit = (pos - sbi->record_size) >> index_bits; 429 } else { 430 err = ntfs_read_hdr(sbi, ni, &root->ihdr, 0, pos, name, ctx); 431 if (err) 432 goto out; 433 bit = 0; 434 } 435 436 if (!i_size) { 437 ctx->pos = eod; 438 goto out; 439 } 440 441 for (;;) { 442 vbo = (u64)bit << index_bits; 443 if (vbo >= i_size) { 444 ctx->pos = eod; 445 goto out; 446 } 447 448 err = indx_used_bit(&ni->dir, ni, &bit); 449 if (err) 450 goto out; 451 452 if (bit == MINUS_ONE_T) { 453 ctx->pos = eod; 454 goto out; 455 } 456 457 vbo = (u64)bit << index_bits; 458 if (vbo >= i_size) { 459 ntfs_inode_err(dir, "Looks like your dir is corrupt"); 460 err = -EINVAL; 461 goto out; 462 } 463 464 err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits, 465 &node); 466 if (err) 467 goto out; 468 469 err = ntfs_read_hdr(sbi, ni, &node->index->ihdr, 470 vbo + sbi->record_size, pos, name, ctx); 471 if (err) 472 goto out; 473 474 bit += 1; 475 } 476 477 out: 478 479 __putname(name); 480 put_indx_node(node); 481 482 if (err == -ENOENT) { 483 err = 0; 484 ctx->pos = pos; 485 } 486 487 return err; 488 } 489 490 static int ntfs_dir_count(struct inode *dir, bool *is_empty, size_t *dirs, 491 size_t *files) 492 { 493 int err = 0; 494 struct ntfs_inode *ni = ntfs_i(dir); 495 struct NTFS_DE *e = NULL; 496 struct INDEX_ROOT *root; 497 struct INDEX_HDR *hdr; 498 const struct ATTR_FILE_NAME *fname; 499 u32 e_size, off, end; 500 u64 vbo = 0; 501 size_t drs = 0, fles = 0, bit = 0; 502 loff_t i_size = ni->vfs_inode.i_size; 503 struct indx_node *node = NULL; 504 u8 index_bits = ni->dir.index_bits; 505 506 if (is_empty) 507 *is_empty = true; 508 509 root = indx_get_root(&ni->dir, ni, NULL, NULL); 510 if (!root) 511 return -EINVAL; 512 513 hdr = &root->ihdr; 514 515 for (;;) { 516 end = le32_to_cpu(hdr->used); 517 off = le32_to_cpu(hdr->de_off); 518 519 for (; off + sizeof(struct NTFS_DE) <= end; off += e_size) { 520 e = Add2Ptr(hdr, off); 521 e_size = le16_to_cpu(e->size); 522 if (e_size < sizeof(struct NTFS_DE) || 523 off + e_size > end) 524 break; 525 526 if (de_is_last(e)) 527 break; 528 529 fname = de_get_fname(e); 530 if (!fname) 531 continue; 532 533 if (fname->type == FILE_NAME_DOS) 534 continue; 535 536 if (is_empty) { 537 *is_empty = false; 538 if (!dirs && !files) 539 goto out; 540 } 541 542 if (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY) 543 drs += 1; 544 else 545 fles += 1; 546 } 547 548 if (vbo >= i_size) 549 goto out; 550 551 err = indx_used_bit(&ni->dir, ni, &bit); 552 if (err) 553 goto out; 554 555 if (bit == MINUS_ONE_T) 556 goto out; 557 558 vbo = (u64)bit << index_bits; 559 if (vbo >= i_size) 560 goto out; 561 562 err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits, 563 &node); 564 if (err) 565 goto out; 566 567 hdr = &node->index->ihdr; 568 bit += 1; 569 vbo = (u64)bit << ni->dir.idx2vbn_bits; 570 } 571 572 out: 573 put_indx_node(node); 574 if (dirs) 575 *dirs = drs; 576 if (files) 577 *files = fles; 578 579 return err; 580 } 581 582 bool dir_is_empty(struct inode *dir) 583 { 584 bool is_empty = false; 585 586 ntfs_dir_count(dir, &is_empty, NULL, NULL); 587 588 return is_empty; 589 } 590 591 // clang-format off 592 const struct file_operations ntfs_dir_operations = { 593 .llseek = generic_file_llseek, 594 .read = generic_read_dir, 595 .iterate_shared = ntfs_readdir, 596 .fsync = generic_file_fsync, 597 .open = ntfs_file_open, 598 }; 599 // clang-format on 600