1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * Copyright (C) 2020 Hyunchul Lee <hyc.lee@gmail.com>
4 */
5 #include <stdio.h>
6 #include <string.h>
7 #include <stdarg.h>
8 #include <stdlib.h>
9 #include <errno.h>
10
11 #include "exfat_ondisk.h"
12 #include "libexfat.h"
13 #include "repair.h"
14 #include "exfat_fs.h"
15 #include "fsck.h"
16
17 struct exfat_repair_problem {
18 er_problem_code_t prcode;
19 unsigned int flags;
20 unsigned int prompt_type;
21 unsigned int default_number;
22 unsigned int bypass_number;
23 unsigned int max_number;
24 };
25
26 /* Problem flags */
27 #define ERF_PREEN_YES 0x00000001
28 #define ERF_DEFAULT_YES 0x00000002
29 #define ERF_DEFAULT_NO 0x00000004
30
31 /* Prompt types */
32 #define ERP_FIX 0x00000001
33 #define ERP_TRUNCATE 0x00000002
34 #define ERP_DELETE 0x00000003
35 #define ERP_RENAME 0x00000004
36
37 static const char *prompts[] = {
38 "Repair",
39 "Fix",
40 "Truncate",
41 "Delete",
42 "Select",
43 };
44
45 static struct exfat_repair_problem problems[] = {
46 {ER_BS_CHECKSUM, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
47 {ER_BS_BOOT_REGION, 0, ERP_FIX, 0, 0, 0},
48 {ER_DE_CHECKSUM, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
49 {ER_DE_UNKNOWN, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
50 {ER_DE_FILE, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
51 {ER_DE_SECONDARY_COUNT, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
52 {ER_DE_STREAM, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
53 {ER_DE_NAME, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
54 {ER_DE_NAME_HASH, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
55 {ER_DE_NAME_LEN, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
56 {ER_DE_DOT_NAME, ERF_PREEN_YES, ERP_RENAME, 2, 3, 4},
57 {ER_DE_DUPLICATED_NAME, ERF_PREEN_YES, ERP_RENAME, 2, 3, 4},
58 {ER_DE_INVALID_NAME, ERF_PREEN_YES, ERP_RENAME, 2, 3, 4},
59 {ER_FILE_VALID_SIZE, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
60 {ER_FILE_INVALID_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
61 {ER_FILE_FIRST_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
62 {ER_FILE_SMALLER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
63 {ER_FILE_LARGER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
64 {ER_FILE_DUPLICATED_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
65 {ER_FILE_ZERO_NOFAT, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
66 {ER_VENDOR_GUID, ERF_DEFAULT_NO, ERP_FIX, 0, 0, 0},
67 };
68
find_problem(er_problem_code_t prcode)69 static struct exfat_repair_problem *find_problem(er_problem_code_t prcode)
70 {
71 unsigned int i;
72
73 for (i = 0; i < sizeof(problems)/sizeof(problems[0]); i++) {
74 if (problems[i].prcode == prcode) {
75 return &problems[i];
76 }
77 }
78 return NULL;
79 }
80
ask_repair(struct exfat_fsck * fsck,struct exfat_repair_problem * pr)81 static int ask_repair(struct exfat_fsck *fsck, struct exfat_repair_problem *pr)
82 {
83 int repair = 0;
84 char answer[8];
85
86 if (fsck->options & FSCK_OPTS_REPAIR_NO ||
87 pr->flags & ERF_DEFAULT_NO)
88 repair = 0;
89 else if (fsck->options & FSCK_OPTS_REPAIR_YES ||
90 pr->flags & ERF_DEFAULT_YES)
91 repair = 1;
92 else {
93 if (fsck->options & FSCK_OPTS_REPAIR_ASK) {
94 do {
95 if (pr->prompt_type & ERP_RENAME) {
96 printf("%s (Number: ?) ",
97 prompts[pr->prompt_type]);
98 } else {
99 printf(". %s (y/N)? ",
100 prompts[pr->prompt_type]);
101 }
102 fflush(stdout);
103
104 if (!fgets(answer, sizeof(answer), stdin))
105 continue;
106
107 if (pr->prompt_type & ERP_RENAME) {
108 unsigned int number = atoi(answer);
109
110 if (number > 0 && number < pr->max_number)
111 return number;
112 } else {
113 if (strcasecmp(answer, "Y\n") == 0)
114 return 1;
115 else if (strcasecmp(answer, "\n") == 0 ||
116 strcasecmp(answer, "N\n") == 0)
117 return 0;
118 }
119 } while (1);
120 } else if (fsck->options & FSCK_OPTS_REPAIR_AUTO &&
121 pr->flags & ERF_PREEN_YES)
122 repair = 1;
123 }
124
125 if (pr->prompt_type & ERP_RENAME) {
126 int print_num = repair ? pr->default_number : pr->bypass_number;
127
128 printf("%s (Number : %d)\n", prompts[pr->prompt_type],
129 print_num);
130 repair = print_num;
131 } else {
132 printf(". %s (y/N)? %c\n", prompts[pr->prompt_type],
133 repair ? 'y' : 'n');
134 }
135 return repair;
136 }
137
exfat_repair_ask(struct exfat_fsck * fsck,er_problem_code_t prcode,const char * desc,...)138 int exfat_repair_ask(struct exfat_fsck *fsck, er_problem_code_t prcode,
139 const char *desc, ...)
140 {
141 struct exfat_repair_problem *pr = NULL;
142 va_list ap;
143 int repair;
144
145 pr = find_problem(prcode);
146 if (!pr) {
147 exfat_err("unknown problem code. %#x\n", prcode);
148 return 0;
149 }
150
151 va_start(ap, desc);
152 vprintf(desc, ap);
153 va_end(ap);
154
155 repair = ask_repair(fsck, pr);
156 if (repair) {
157 if (pr->prompt_type & ERP_TRUNCATE)
158 fsck->dirty_fat = true;
159 fsck->dirty = true;
160 }
161 return repair;
162 }
163
get_rename_from_user(struct exfat_de_iter * iter,__le16 * utf16_name,int name_size)164 static int get_rename_from_user(struct exfat_de_iter *iter,
165 __le16 *utf16_name, int name_size)
166 {
167 int len = 0;
168 char *rename = malloc(ENTRY_NAME_MAX + 2);
169
170 if (!rename)
171 return -ENOMEM;
172
173 retry:
174 /* +2 means LF(Line Feed) and NULL terminator */
175 memset(rename, 0x1, ENTRY_NAME_MAX + 2);
176 printf("New name: ");
177 if (fgets(rename, ENTRY_NAME_MAX + 2, stdin)) {
178 int err;
179 struct exfat_lookup_filter filter;
180
181 len = strlen(rename);
182 /* Remove LF in filename */
183 rename[len - 1] = '\0';
184
185 memset(utf16_name, 0, name_size);
186 len = exfat_utf16_enc(rename, utf16_name, name_size);
187 if (len < 0)
188 goto out;
189
190 err = exfat_check_name(utf16_name, len >> 1);
191 if (err != len >> 1) {
192 printf("filename contain invalid character(%c)\n",
193 le16_to_cpu(utf16_name[err]));
194 goto retry;
195 }
196
197 exfat_de_iter_flush(iter);
198 err = exfat_lookup_file(iter->exfat, iter->parent, rename, &filter);
199 if (!err) {
200 printf("file(%s) already exists, retry to insert name\n", rename);
201 goto retry;
202 }
203 }
204
205 out:
206 free(rename);
207
208 return len;
209 }
210
generate_rename(struct exfat_de_iter * iter,__le16 * utf16_name,int name_size)211 static int generate_rename(struct exfat_de_iter *iter, __le16 *utf16_name,
212 int name_size)
213 {
214 int err;
215 char *rename;
216
217 if (iter->invalid_name_num > INVALID_NAME_NUM_MAX)
218 return -ERANGE;
219
220 rename = malloc(ENTRY_NAME_MAX + 1);
221 if (!rename)
222 return -ENOMEM;
223
224 while (1) {
225 struct exfat_lookup_filter filter;
226
227 snprintf(rename, ENTRY_NAME_MAX + 1, "FILE%07d.CHK",
228 iter->invalid_name_num++);
229 err = exfat_lookup_file(iter->exfat, iter->parent, rename,
230 &filter);
231 if (!err)
232 continue;
233 break;
234 }
235
236 memset(utf16_name, 0, name_size);
237 err = exfat_utf16_enc(rename, utf16_name, name_size);
238 free(rename);
239
240 return err;
241 }
242
exfat_repair_rename_ask(struct exfat_fsck * fsck,struct exfat_de_iter * iter,__le16 * uname,er_problem_code_t prcode,char * error_msg)243 int exfat_repair_rename_ask(struct exfat_fsck *fsck, struct exfat_de_iter *iter,
244 __le16 *uname, er_problem_code_t prcode, char *error_msg)
245 {
246 int num;
247 char old_name[PATH_MAX + 1] = {0};
248
249 if (exfat_utf16_dec(uname, NAME_BUFFER_SIZE, old_name, PATH_MAX) <= 0) {
250 exfat_err("failed to decode filename\n");
251 return -EINVAL;
252 }
253
254 ask_again:
255 num = exfat_repair_ask(fsck, prcode, "ERROR: '%s' %s.\n%s",
256 old_name, error_msg,
257 " [1] Insert the name you want to rename.\n"
258 " [2] Automatically renames filename.\n"
259 " [3] Bypass this check(No repair)\n");
260 if (num) {
261 __le16 utf16_name[ENTRY_NAME_MAX];
262 __u16 hash;
263 struct exfat_dentry *dentry;
264 int ret;
265
266 switch (num) {
267 case 1:
268 ret = get_rename_from_user(iter, utf16_name,
269 sizeof(utf16_name));
270 break;
271 case 2:
272 ret = generate_rename(iter, utf16_name,
273 sizeof(utf16_name));
274 break;
275 case 3:
276 return -EINVAL;
277 default:
278 exfat_info("select 1 or 2 number instead of %d\n", num);
279 goto ask_again;
280 }
281
282 if (ret < 0)
283 return -EINVAL;
284
285 exfat_de_iter_get_dirty(iter, 2, &dentry);
286
287 ret >>= 1;
288 memcpy(dentry->name_unicode, utf16_name, ENTRY_NAME_MAX * 2);
289 hash = exfat_calc_name_hash(iter->exfat, utf16_name, ret);
290 exfat_de_iter_get_dirty(iter, 1, &dentry);
291 dentry->stream_name_len = (__u8)ret;
292 dentry->stream_name_hash = cpu_to_le16(hash);
293 return 1;
294
295 }
296
297 return 0;
298 }
299