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