fsck: add support for renaming dot and dotdot files

User report that "." and ".." files can be created from windows cmd.
e.g. echo "hello world" > "\\?\D:\.."

Problem is that user can check same dot and dotdot name entry from linux.

$ ls -al /mnt/test
total 104
drwxr-xr-x  3 root root 32768 10월  9 14:18  .
drwxr-xr-x  3 root root 32768 10월  9 14:18  .
drwxr-xr-x 10 root root  4096  5월 24 12:06  ..
drwxr-xr-x 10 root root  4096  5월 24 12:06  ..

FSCK in exfatprogs can rename this entries to other valid names.
This patch suggest to user to rename them with two option. (name given from
users and auto rename).

Signed-off-by: Namjae Jeon <linkinjeon@kernel.org>

5 files changed, 222 insertions, 40 deletions

diff --git a/fsck/fsck.c b/fsck/fsck.c
index 5721877..219d723 100644
--- a/fsck/fsck.c
+++ b/fsck/fsck.c
@@ -668,6 +668,147 @@ static int check_name_dentry_set(struct exfat_de_iter *iter,
 	return 0;
 }
 
+static int check_bad_char(char w)
+{
+	return (w < 0x0020) || (w == '*') || (w == '?') || (w == '<') ||
+		(w == '>') || (w == '|') || (w == '"') || (w == ':') ||
+		(w == '/') || (w == '\\');
+}
+
+static char *get_rename_from_user(struct exfat_de_iter *iter)
+{
+	char *rename = malloc(ENTRY_NAME_MAX + 2);
+
+	if (!rename)
+		return NULL;
+
+retry:
+	/* +2 means LF(Line Feed) and NULL terminator */
+	memset(rename, 0x1, ENTRY_NAME_MAX + 2);
+	printf("New name: ");
+	if (fgets(rename, ENTRY_NAME_MAX + 2, stdin)) {
+		int i, len, err;
+		struct exfat_lookup_filter filter;
+
+		len = strlen(rename);
+		/* Remove LF in filename */
+		rename[len - 1] = '\0';
+		for (i = 0; i < len - 1; i++) {
+			if (check_bad_char(rename[i])) {
+				printf("filename contain invalid character(%c)\n", rename[i]);
+				goto retry;
+			}
+		}
+
+		exfat_de_iter_flush(iter);
+		err = exfat_lookup_file(iter->exfat, iter->parent, rename, &filter);
+		if (!err) {
+			printf("file(%s) already exists, retry to insert name\n", rename);
+			goto retry;
+		}
+	}
+
+	return rename;
+}
+
+static char *generate_rename(struct exfat_de_iter *iter)
+{
+	char *rename;
+
+	if (iter->dot_name_num > DOT_NAME_NUM_MAX)
+		return NULL;
+
+	rename = malloc(ENTRY_NAME_MAX + 1);
+	if (!rename)
+		return NULL;
+
+	while (1) {
+		struct exfat_lookup_filter filter;
+		int err;
+
+		snprintf(rename, ENTRY_NAME_MAX + 1, "FILE%07d.CHK",
+			 iter->dot_name_num++);
+		err = exfat_lookup_file(iter->exfat, iter->parent, rename,
+					&filter);
+		if (!err)
+			continue;
+		break;
+	}
+
+	return rename;
+}
+
+const __le16 MSDOS_DOT[ENTRY_NAME_MAX] = {cpu_to_le16(46), 0, };
+const __le16 MSDOS_DOTDOT[ENTRY_NAME_MAX] = {cpu_to_le16(46), cpu_to_le16(46), 0, };
+
+static int handle_dot_dotdot_filename(struct exfat_de_iter *iter,
+				      struct exfat_dentry *dentry,
+				      int strm_name_len)
+{
+	char *filename;
+	char error_msg[150];
+	int num;
+
+	if (!memcmp(dentry->name_unicode, MSDOS_DOT, strm_name_len * 2))
+		filename = ".";
+	else if (!memcmp(dentry->name_unicode, MSDOS_DOTDOT,
+			 strm_name_len * 2))
+		filename = "..";
+	else
+		return 0;
+
+	sprintf(error_msg, "ERROR: '%s' filename is not allowed.\n"
+			" [1] Insert the name you want to rename.\n"
+			" [2] Automatically renames filename.\n"
+			" [3] Bypass this check(No repair)\n", filename);
+ask_again:
+	num = exfat_repair_ask(&exfat_fsck, ER_DE_DOT_NAME,
+			       error_msg);
+	if (num) {
+		__le16 utf16_name[ENTRY_NAME_MAX];
+		char *rename = NULL;
+		__u16 hash;
+		struct exfat_dentry *stream_de;
+		int name_len, ret;
+
+		switch (num) {
+		case 1:
+			rename = get_rename_from_user(iter);
+			break;
+		case 2:
+			rename = generate_rename(iter);
+			break;
+		case 3:
+			break;
+		default:
+			exfat_info("select 1 or 2 number instead of %d\n", num);
+			goto ask_again;
+		}
+
+		if (!rename)
+			return -EINVAL;
+
+		exfat_info("%s filename is renamed to %s\n", filename, rename);
+
+		exfat_de_iter_get_dirty(iter, 2, &dentry);
+
+		memset(utf16_name, 0, sizeof(utf16_name));
+		ret = exfat_utf16_enc(rename, utf16_name, sizeof(utf16_name));
+		free(rename);
+		if (ret < 0)
+			return ret;
+
+		memcpy(dentry->name_unicode, utf16_name, ENTRY_NAME_MAX * 2);
+		name_len = exfat_utf16_len(utf16_name, ENTRY_NAME_MAX * 2);
+		hash = exfat_calc_name_hash(iter->exfat, utf16_name, (int)name_len);
+		exfat_de_iter_get_dirty(iter, 1, &stream_de);
+		stream_de->stream_name_len = (__u8)name_len;
+		stream_de->stream_name_hash = cpu_to_le16(hash);
+	}
+
+	return 0;
+}
+
 static int read_file_dentry_set(struct exfat_de_iter *iter,
 				struct exfat_inode **new_node, int *skip_dentries)
 {
@@ -739,6 +880,15 @@ static int read_file_dentry_set(struct exfat_de_iter *iter,
 		goto skip_dset;
 	}
 
+	if (file_de->file_num_ext == 2 && stream_de->stream_name_len <= 2) {
+		ret = handle_dot_dotdot_filename(iter, dentry,
+				stream_de->stream_name_len);
+		if (ret < 0) {
+			*skip_dentries = file_de->file_num_ext + 1;
+			goto skip_dset;
+		}
+	}
+
 	node->first_clus = le32_to_cpu(stream_de->stream_start_clu);
 	node->is_contiguous =
 		((stream_de->stream_flags & EXFAT_SF_CONTIGUOUS) != 0);
diff --git a/fsck/repair.c b/fsck/repair.c
index 65f4a9f..92b1c3f 100644
--- a/fsck/repair.c
+++ b/fsck/repair.c
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
+#include <stdlib.h>
 
 #include "exfat_ondisk.h"
 #include "libexfat.h"
@@ -17,6 +18,9 @@ struct exfat_repair_problem {
 	er_problem_code_t	prcode;
 	unsigned int		flags;
 	unsigned int		prompt_type;
+	unsigned int		default_number;
+	unsigned int		bypass_number;
+	unsigned int		max_number;
 };
 
 /* Problem flags */
@@ -28,32 +32,35 @@ struct exfat_repair_problem {
 #define ERP_FIX			0x00000001
 #define ERP_TRUNCATE		0x00000002
 #define ERP_DELETE		0x00000003
+#define ERP_RENAME		0x00000004
 
 static const char *prompts[] = {
 	"Repair",
 	"Fix",
 	"Truncate",
 	"Delete",
+	"Select",
 };
 
 static struct exfat_repair_problem problems[] = {
-	{ER_BS_CHECKSUM, ERF_PREEN_YES, ERP_FIX},
-	{ER_BS_BOOT_REGION, 0, ERP_FIX},
-	{ER_DE_CHECKSUM, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_UNKNOWN, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_FILE, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_SECONDARY_COUNT, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_STREAM, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_NAME, ERF_PREEN_YES, ERP_DELETE},
-	{ER_DE_NAME_HASH, ERF_PREEN_YES, ERP_FIX},
-	{ER_DE_NAME_LEN, ERF_PREEN_YES, ERP_FIX},
-	{ER_FILE_VALID_SIZE, ERF_PREEN_YES, ERP_FIX},
-	{ER_FILE_INVALID_CLUS, ERF_PREEN_YES, ERP_TRUNCATE},
-	{ER_FILE_FIRST_CLUS, ERF_PREEN_YES, ERP_TRUNCATE},
-	{ER_FILE_SMALLER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE},
-	{ER_FILE_LARGER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE},
-	{ER_FILE_DUPLICATED_CLUS, ERF_PREEN_YES, ERP_TRUNCATE},
-	{ER_FILE_ZERO_NOFAT, ERF_PREEN_YES, ERP_FIX},
+	{ER_BS_CHECKSUM, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
+	{ER_BS_BOOT_REGION, 0, ERP_FIX, 0, 0, 0},
+	{ER_DE_CHECKSUM, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_UNKNOWN, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_FILE, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_SECONDARY_COUNT, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_STREAM, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_NAME, ERF_PREEN_YES, ERP_DELETE, 0, 0, 0},
+	{ER_DE_NAME_HASH, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
+	{ER_DE_NAME_LEN, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
+	{ER_DE_DOT_NAME, ERF_PREEN_YES, ERP_RENAME, 2, 3, 4},
+	{ER_FILE_VALID_SIZE, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
+	{ER_FILE_INVALID_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
+	{ER_FILE_FIRST_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
+	{ER_FILE_SMALLER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
+	{ER_FILE_LARGER_SIZE, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
+	{ER_FILE_DUPLICATED_CLUS, ERF_PREEN_YES, ERP_TRUNCATE, 0, 0, 0},
+	{ER_FILE_ZERO_NOFAT, ERF_PREEN_YES, ERP_FIX, 0, 0, 0},
 };
 
 static struct exfat_repair_problem *find_problem(er_problem_code_t prcode)
@@ -68,64 +75,85 @@ static struct exfat_repair_problem *find_problem(er_problem_code_t prcode)
 	return NULL;
 }
 
-static bool ask_repair(struct exfat_fsck *fsck, struct exfat_repair_problem *pr)
+static int ask_repair(struct exfat_fsck *fsck, struct exfat_repair_problem *pr)
 {
-	bool repair = false;
+	int repair = 0;
 	char answer[8];
 
 	if (fsck->options & FSCK_OPTS_REPAIR_NO ||
 	    pr->flags & ERF_DEFAULT_NO)
-		repair = false;
+		repair = 0;
 	else if (fsck->options & FSCK_OPTS_REPAIR_YES ||
 		 pr->flags & ERF_DEFAULT_YES)
-		repair = true;
+		repair = 1;
 	else {
 		if (fsck->options & FSCK_OPTS_REPAIR_ASK) {
 			do {
-				printf(". %s (y/N)? ",
-					prompts[pr->prompt_type]);
+				if (pr->prompt_type & ERP_RENAME) {
+					printf("%s (Number: ?) ",
+					       prompts[pr->prompt_type]);
+				} else {
+					printf(". %s (y/N)? ",
+					       prompts[pr->prompt_type]);
+				}
 				fflush(stdout);
 
-				if (fgets(answer, sizeof(answer), stdin)) {
+				if (!fgets(answer, sizeof(answer), stdin))
+					continue;
+
+				if (pr->prompt_type & ERP_RENAME) {
+					unsigned int number = atoi(answer);
+
+					if (number > 0 && number < pr->max_number)
+						return number;
+				} else {
 					if (strcasecmp(answer, "Y\n") == 0)
-						return true;
-					else if (strcasecmp(answer, "\n") == 0
-						|| strcasecmp(answer, "N\n") == 0)
-						return false;
+						return 1;
+					else if (strcasecmp(answer, "\n") == 0 ||
+						 strcasecmp(answer, "N\n") == 0)
+						return 0;
 				}
 			} while (1);
 		} else if (fsck->options & FSCK_OPTS_REPAIR_AUTO &&
 			   pr->flags & ERF_PREEN_YES)
-			repair = true;
+			repair = 1;
 	}
 
-	printf(". %s (y/N)? %c\n", prompts[pr->prompt_type],
-		repair ? 'y' : 'n');
+	if (pr->prompt_type & ERP_RENAME) {
+		int print_num = repair ? pr->default_number : pr->bypass_number;
+
+		printf("%s (Number : %d)\n", prompts[pr->prompt_type],
+		       print_num);
+		repair = print_num;
+	} else {
+		printf(". %s (y/N)? %c\n", prompts[pr->prompt_type],
+		       repair ? 'y' : 'n');
+	}
 	return repair;
 }
 
-bool exfat_repair_ask(struct exfat_fsck *fsck, er_problem_code_t prcode,
-		      const char *desc, ...)
+int exfat_repair_ask(struct exfat_fsck *fsck, er_problem_code_t prcode,
+		     const char *desc, ...)
 {
 	struct exfat_repair_problem *pr = NULL;
 	va_list ap;
+	int repair;
 
 	pr = find_problem(prcode);
 	if (!pr) {
 		exfat_err("unknown problem code. %#x\n", prcode);
-		return false;
+		return 0;
 	}
 
 	va_start(ap, desc);
 	vprintf(desc, ap);
 	va_end(ap);
 
-	if (ask_repair(fsck, pr)) {
+	repair = ask_repair(fsck, pr);
+	if (repair) {
 		if (pr->prompt_type & ERP_TRUNCATE)
 			fsck->dirty_fat = true;
 		fsck->dirty = true;
-		return true;
-	} else {
-		return false;
 	}
+	return repair;
 }
diff --git a/fsck/repair.h b/fsck/repair.h
index 4e9a6bf..dc3cc50 100644
--- a/fsck/repair.h
+++ b/fsck/repair.h
@@ -15,6 +15,7 @@
 #define ER_DE_NAME			0x00001030
 #define ER_DE_NAME_HASH			0x00001031
 #define ER_DE_NAME_LEN			0x00001032
+#define ER_DE_DOT_NAME			0x00001033
 #define ER_FILE_VALID_SIZE		0x00002001
 #define ER_FILE_INVALID_CLUS		0x00002002
 #define ER_FILE_FIRST_CLUS		0x00002003
@@ -26,7 +27,7 @@
 typedef unsigned int er_problem_code_t;
 struct exfat_fsck;
 
-bool exfat_repair_ask(struct exfat_fsck *fsck, er_problem_code_t prcode,
-		      const char *fmt, ...);
+int exfat_repair_ask(struct exfat_fsck *fsck, er_problem_code_t prcode,
+		     const char *fmt, ...);
 
 #endif
diff --git a/include/exfat_dir.h b/include/exfat_dir.h
index 617f98e..3bc5b51 100644
--- a/include/exfat_dir.h
+++ b/include/exfat_dir.h
@@ -25,6 +25,8 @@ struct exfat_de_iter {
 	off_t			de_file_offset;
 	off_t			next_read_offset;
 	int			max_skip_dentries;
+#define DOT_NAME_NUM_MAX	9999999
+	unsigned int		dot_name_num;
 };
 
 struct exfat_lookup_filter {
diff --git a/lib/exfat_dir.c b/lib/exfat_dir.c
index 2eda805..499b672 100644
--- a/lib/exfat_dir.c
+++ b/lib/exfat_dir.c
@@ -236,6 +236,7 @@ int exfat_de_iter_init(struct exfat_de_iter *iter, struct exfat *exfat,
 	iter->de_file_offset = 0;
 	iter->next_read_offset = iter->read_size;
 	iter->max_skip_dentries = 0;
+	iter->dot_name_num = 0;
 
 	if (iter->parent->size == 0)
 		return EOF;