New upstream version 1.0.3
[sven/exfatprogs.git] / lib / libexfat.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
4  */
5
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <sys/ioctl.h>
9 #include <unistd.h>
10 #include <fcntl.h>
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <string.h>
14 #include <errno.h>
15 #include <wchar.h>
16 #include <limits.h>
17
18 #include "exfat_ondisk.h"
19 #include "libexfat.h"
20 #include "version.h"
21
22 #ifdef WORDS_BIGENDIAN
23 #define BITOP_LE_SWIZZLE        (~0x7)
24 #else
25 #define BITOP_LE_SWIZZLE        0
26 #endif
27
28 #define BIT_MASK(nr)            ((1) << ((nr) % 32))
29 #define BIT_WORD(nr)            ((nr) / 32)
30
31 unsigned int print_level  = EXFAT_INFO;
32
33 static inline void set_bit(int nr, unsigned int *addr)
34 {
35         unsigned long mask = BIT_MASK(nr);
36         unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
37
38         *p  |= mask;
39 }
40
41 static inline void clear_bit(int nr, unsigned int *addr)
42 {
43         unsigned long mask = BIT_MASK(nr);
44         unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
45
46         *p &= ~mask;
47 }
48
49 static inline void set_bit_le(int nr, void *addr)
50 {
51         set_bit(nr ^ BITOP_LE_SWIZZLE, addr);
52 }
53
54 static inline void clear_bit_le(int nr, void *addr)
55 {
56         clear_bit(nr ^ BITOP_LE_SWIZZLE, addr);
57 }
58
59 void exfat_set_bit(struct exfat_blk_dev *bd, char *bitmap,
60                 unsigned int clu)
61 {
62         int b;
63
64         b = clu & ((bd->sector_size << 3) - 1);
65
66         set_bit_le(b, bitmap);
67 }
68
69 void exfat_clear_bit(struct exfat_blk_dev *bd, char *bitmap,
70                 unsigned int clu)
71 {
72         int b;
73
74         b = clu & ((bd->sector_size << 3) - 1);
75
76         clear_bit_le(b, bitmap);
77 }
78
79 wchar_t exfat_bad_char(wchar_t w)
80 {
81         return (w < 0x0020)
82                 || (w == '*') || (w == '?') || (w == '<') || (w == '>')
83                 || (w == '|') || (w == '"') || (w == ':') || (w == '/')
84                 || (w == '\\');
85 }
86
87 void boot_calc_checksum(unsigned char *sector, unsigned short size,
88                 bool is_boot_sec, __le32 *checksum)
89 {
90         unsigned int index;
91
92         if (is_boot_sec) {
93                 for (index = 0; index < size; index++) {
94                         if ((index == 106) || (index == 107) || (index == 112))
95                                 continue;
96                         *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
97                                 (*checksum >> 1) + sector[index];
98                 }
99         } else {
100                 for (index = 0; index < size; index++) {
101                         *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
102                                 (*checksum >> 1) + sector[index];
103                 }
104         }
105 }
106
107 void show_version(void)
108 {
109         printf("exfatprogs version : %s\n", EXFAT_PROGS_VERSION);
110 }
111
112 static inline unsigned int sector_size_bits(unsigned int size)
113 {
114         unsigned int bits = 8;
115
116         do {
117                 bits++;
118                 size >>= 1;
119         } while (size > 256);
120
121         return bits;
122 }
123
124 static void exfat_set_default_cluster_size(struct exfat_blk_dev *bd,
125                 struct exfat_user_input *ui)
126 {
127         if (256 * MB >= bd->size)
128                 ui->cluster_size = 4 * KB;
129         else if (32 * GB >= bd->size)
130                 ui->cluster_size = 32 * KB;
131         else
132                 ui->cluster_size = 128 * KB;
133 }
134
135 void init_user_input(struct exfat_user_input *ui)
136 {
137         memset(ui, 0, sizeof(struct exfat_user_input));
138         ui->writeable = true;
139         ui->quick = true;
140 }
141
142 int exfat_get_blk_dev_info(struct exfat_user_input *ui,
143                 struct exfat_blk_dev *bd)
144 {
145         int fd, ret = -1;
146         off_t blk_dev_size;
147
148         fd = open(ui->dev_name, ui->writeable ? O_RDWR|O_EXCL : O_RDONLY);
149         if (fd < 0) {
150                 exfat_err("open failed : %s, %s\n", ui->dev_name,
151                         strerror(errno));
152                 return -1;
153         }
154         blk_dev_size = lseek(fd, 0, SEEK_END);
155         if (blk_dev_size <= 0) {
156                 exfat_err("invalid block device size(%s)\n",
157                         ui->dev_name);
158                 ret = blk_dev_size;
159                 close(fd);
160                 goto out;
161         }
162
163         bd->dev_fd = fd;
164         bd->size = blk_dev_size;
165         if (!ui->cluster_size)
166                 exfat_set_default_cluster_size(bd, ui);
167
168         if (ioctl(fd, BLKSSZGET, &bd->sector_size) < 0)
169                 bd->sector_size = DEFAULT_SECTOR_SIZE;
170         bd->sector_size_bits = sector_size_bits(bd->sector_size);
171         bd->num_sectors = blk_dev_size / DEFAULT_SECTOR_SIZE;
172         bd->num_clusters = blk_dev_size / ui->cluster_size;
173
174         exfat_debug("Block device name : %s\n", ui->dev_name);
175         exfat_debug("Block device size : %lld\n", bd->size);
176         exfat_debug("Block sector size : %u\n", bd->sector_size);
177         exfat_debug("Number of the sectors : %llu\n",
178                 bd->num_sectors);
179         exfat_debug("Number of the clusters : %u\n",
180                 bd->num_clusters);
181
182         ret = 0;
183         bd->dev_fd = fd;
184 out:
185         return ret;
186 }
187
188 ssize_t exfat_read(int fd, void *buf, size_t size, off_t offset)
189 {
190         return pread(fd, buf, size, offset);
191 }
192
193 ssize_t exfat_write(int fd, void *buf, size_t size, off_t offset)
194 {
195         return pwrite(fd, buf, size, offset);
196 }
197
198 ssize_t exfat_utf16_enc(const char *in_str, __u16 *out_str, size_t out_size)
199 {
200         size_t mbs_len, out_len, i;
201         wchar_t *wcs;
202
203         mbs_len = mbstowcs(NULL, in_str, 0);
204         if (mbs_len == (size_t)-1) {
205                 if (errno == EINVAL || errno == EILSEQ)
206                         exfat_err("invalid character sequence in current locale\n");
207                 return -errno;
208         }
209
210         wcs = calloc(mbs_len+1, sizeof(wchar_t));
211         if (!wcs)
212                 return -ENOMEM;
213
214         /* First convert multibyte char* string to wchar_t* string */
215         if (mbstowcs(wcs, in_str, mbs_len+1) == (size_t)-1) {
216                 if (errno == EINVAL || errno == EILSEQ)
217                         exfat_err("invalid character sequence in current locale\n");
218                 return -errno;
219         }
220
221         /* Convert wchar_t* string (sequence of code points) to UTF-16 string */
222         for (i = 0, out_len = 0; i < mbs_len; i++) {
223                 if (2*(out_len+1) > out_size ||
224                     (wcs[i] >= 0x10000 && 2*(out_len+2) > out_size)) {
225                         exfat_err("input string is too long\n");
226                         free(wcs);
227                         return -E2BIG;
228                 }
229
230                 /* Encode code point above Plane0 as UTF-16 surrogate pair */
231                 if (wcs[i] >= 0x10000) {
232                         out_str[out_len++] =
233                           cpu_to_le16(((wcs[i] - 0x10000) >> 10) + 0xD800);
234                         wcs[i] = ((wcs[i] - 0x10000) & 0x3FF) + 0xDC00;
235                 }
236
237                 out_str[out_len++] = cpu_to_le16(wcs[i]);
238         }
239
240         free(wcs);
241         return 2*out_len;
242 }
243
244 ssize_t exfat_utf16_dec(const __u16 *in_str, size_t in_len,
245                         char *out_str, size_t out_size)
246 {
247         size_t wcs_len, out_len, c_len, i;
248         char c_str[MB_LEN_MAX];
249         wchar_t *wcs;
250         mbstate_t ps;
251         wchar_t w;
252
253         wcs = calloc(in_len/2+1, sizeof(wchar_t));
254         if (!wcs)
255                 return -ENOMEM;
256
257         /* First convert UTF-16 string to wchar_t* string */
258         for (i = 0, wcs_len = 0; i < in_len/2; i++, wcs_len++) {
259                 wcs[wcs_len] = le16_to_cpu(in_str[i]);
260                 /*
261                  * If wchar_t can store code point above Plane0
262                  * then unpack UTF-16 surrogate pair to code point
263                  */
264 #if WCHAR_MAX >= 0x10FFFF
265                 if (wcs[wcs_len] >= 0xD800 && wcs[wcs_len] <= 0xDBFF &&
266                     i+1 < in_len/2) {
267                         w = le16_to_cpu(in_str[i+1]);
268                         if (w >= 0xDC00 && w <= 0xDFFF) {
269                                 wcs[wcs_len] = 0x10000 +
270                                                ((wcs[wcs_len] - 0xD800) << 10) +
271                                                (w - 0xDC00);
272                                 i++;
273                         }
274                 }
275 #endif
276         }
277
278         memset(&ps, 0, sizeof(ps));
279
280         /* And then convert wchar_t* string to multibyte char* string */
281         for (i = 0, out_len = 0, c_len = 0; i < wcs_len; i++) {
282                 c_len = wcrtomb(c_str, wcs[i], &ps);
283                 /*
284                  * If character is non-representable in current locale then
285                  * try to store it as Unicode replacement code point U+FFFD
286                  */
287                 if (c_len == (size_t)-1 && errno == EILSEQ)
288                         c_len = wcrtomb(c_str, 0xFFFD, &ps);
289                 /* If U+FFFD is also non-representable, try question mark */
290                 if (c_len == (size_t)-1 && errno == EILSEQ)
291                         c_len = wcrtomb(c_str, L'?', &ps);
292                 /* If also (7bit) question mark fails then we cannot do more */
293                 if (c_len == (size_t)-1) {
294                         exfat_err("invalid UTF-16 sequence\n");
295                         free(wcs);
296                         return -errno;
297                 }
298                 if (out_len+c_len > out_size) {
299                         exfat_err("input string is too long\n");
300                         free(wcs);
301                         return -E2BIG;
302                 }
303                 memcpy(out_str+out_len, c_str, c_len);
304                 out_len += c_len;
305         }
306
307         free(wcs);
308
309         /* Last iteration of above loop should have produced null byte */
310         if (c_len == 0 || out_str[out_len] != 0) {
311                 exfat_err("invalid UTF-16 sequence\n");
312                 return -errno;
313         }
314
315         return out_len-1;
316 }