New upstream version 1.1.1
[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 <sys/sysmacros.h>
10 #include <unistd.h>
11 #include <fcntl.h>
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <errno.h>
16 #include <wchar.h>
17 #include <limits.h>
18
19 #include "exfat_ondisk.h"
20 #include "libexfat.h"
21 #include "version.h"
22
23 #define BITS_PER_LONG           (sizeof(long) * CHAR_BIT)
24
25 #ifdef WORDS_BIGENDIAN
26 #define BITOP_LE_SWIZZLE        ((BITS_PER_LONG - 1) & ~0x7)
27 #else
28 #define BITOP_LE_SWIZZLE        0
29 #endif
30
31 #define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
32 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
33
34 unsigned int print_level  = EXFAT_INFO;
35
36 static inline void set_bit(int nr, void *addr)
37 {
38         unsigned long mask = BIT_MASK(nr);
39         unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
40
41         *p  |= mask;
42 }
43
44 static inline void clear_bit(int nr, void *addr)
45 {
46         unsigned long mask = BIT_MASK(nr);
47         unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
48
49         *p &= ~mask;
50 }
51
52 static inline void set_bit_le(int nr, void *addr)
53 {
54         set_bit(nr ^ BITOP_LE_SWIZZLE, addr);
55 }
56
57 static inline void clear_bit_le(int nr, void *addr)
58 {
59         clear_bit(nr ^ BITOP_LE_SWIZZLE, addr);
60 }
61
62 void exfat_set_bit(struct exfat_blk_dev *bd, char *bitmap,
63                 unsigned int clu)
64 {
65         int b;
66
67         b = clu & ((bd->sector_size << 3) - 1);
68
69         set_bit_le(b, bitmap);
70 }
71
72 void exfat_clear_bit(struct exfat_blk_dev *bd, char *bitmap,
73                 unsigned int clu)
74 {
75         int b;
76
77         b = clu & ((bd->sector_size << 3) - 1);
78
79         clear_bit_le(b, bitmap);
80 }
81
82 wchar_t exfat_bad_char(wchar_t w)
83 {
84         return (w < 0x0020)
85                 || (w == '*') || (w == '?') || (w == '<') || (w == '>')
86                 || (w == '|') || (w == '"') || (w == ':') || (w == '/')
87                 || (w == '\\');
88 }
89
90 void boot_calc_checksum(unsigned char *sector, unsigned short size,
91                 bool is_boot_sec, __le32 *checksum)
92 {
93         unsigned int index;
94
95         if (is_boot_sec) {
96                 for (index = 0; index < size; index++) {
97                         if ((index == 106) || (index == 107) || (index == 112))
98                                 continue;
99                         *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
100                                 (*checksum >> 1) + sector[index];
101                 }
102         } else {
103                 for (index = 0; index < size; index++) {
104                         *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
105                                 (*checksum >> 1) + sector[index];
106                 }
107         }
108 }
109
110 void show_version(void)
111 {
112         printf("exfatprogs version : %s\n", EXFAT_PROGS_VERSION);
113 }
114
115 static inline unsigned int sector_size_bits(unsigned int size)
116 {
117         unsigned int bits = 8;
118
119         do {
120                 bits++;
121                 size >>= 1;
122         } while (size > 256);
123
124         return bits;
125 }
126
127 static void exfat_set_default_cluster_size(struct exfat_blk_dev *bd,
128                 struct exfat_user_input *ui)
129 {
130         if (256 * MB >= bd->size)
131                 ui->cluster_size = 4 * KB;
132         else if (32 * GB >= bd->size)
133                 ui->cluster_size = 32 * KB;
134         else
135                 ui->cluster_size = 128 * KB;
136 }
137
138 void init_user_input(struct exfat_user_input *ui)
139 {
140         memset(ui, 0, sizeof(struct exfat_user_input));
141         ui->writeable = true;
142         ui->quick = true;
143 }
144
145 int exfat_get_blk_dev_info(struct exfat_user_input *ui,
146                 struct exfat_blk_dev *bd)
147 {
148         int fd, ret = -1;
149         off_t blk_dev_size;
150         struct stat st;
151         unsigned long long blk_dev_offset = 0;
152
153         fd = open(ui->dev_name, ui->writeable ? O_RDWR|O_EXCL : O_RDONLY);
154         if (fd < 0) {
155                 exfat_err("open failed : %s, %s\n", ui->dev_name,
156                         strerror(errno));
157                 return -1;
158         }
159         blk_dev_size = lseek(fd, 0, SEEK_END);
160         if (blk_dev_size <= 0) {
161                 exfat_err("invalid block device size(%s)\n",
162                         ui->dev_name);
163                 ret = blk_dev_size;
164                 close(fd);
165                 goto out;
166         }
167
168         if (fstat(fd, &st) == 0 && S_ISBLK(st.st_mode)) {
169                 char pathname[sizeof("/sys/dev/block/4294967295:4294967295/start")];
170                 FILE *fp;
171
172                 snprintf(pathname, sizeof(pathname), "/sys/dev/block/%u:%u/start",
173                         major(st.st_rdev), minor(st.st_rdev));
174                 fp = fopen(pathname, "r");
175                 if (fp != NULL) {
176                         if (fscanf(fp, "%llu", &blk_dev_offset) == 1) {
177                                 /*
178                                  * Linux kernel always reports partition offset
179                                  * in 512-byte units, regardless of sector size
180                                  */
181                                 blk_dev_offset <<= 9;
182                         }
183                         fclose(fp);
184                 }
185         }
186
187         bd->dev_fd = fd;
188         bd->offset = blk_dev_offset;
189         bd->size = blk_dev_size;
190         if (!ui->cluster_size)
191                 exfat_set_default_cluster_size(bd, ui);
192
193         if (!ui->boundary_align)
194                 ui->boundary_align = DEFAULT_BOUNDARY_ALIGNMENT;
195
196         if (ioctl(fd, BLKSSZGET, &bd->sector_size) < 0)
197                 bd->sector_size = DEFAULT_SECTOR_SIZE;
198         bd->sector_size_bits = sector_size_bits(bd->sector_size);
199         bd->num_sectors = blk_dev_size / DEFAULT_SECTOR_SIZE;
200         bd->num_clusters = blk_dev_size / ui->cluster_size;
201
202         exfat_debug("Block device name : %s\n", ui->dev_name);
203         exfat_debug("Block device offset : %llu\n", bd->offset);
204         exfat_debug("Block device size : %llu\n", bd->size);
205         exfat_debug("Block sector size : %u\n", bd->sector_size);
206         exfat_debug("Number of the sectors : %llu\n",
207                 bd->num_sectors);
208         exfat_debug("Number of the clusters : %u\n",
209                 bd->num_clusters);
210
211         ret = 0;
212         bd->dev_fd = fd;
213 out:
214         return ret;
215 }
216
217 ssize_t exfat_read(int fd, void *buf, size_t size, off_t offset)
218 {
219         return pread(fd, buf, size, offset);
220 }
221
222 ssize_t exfat_write(int fd, void *buf, size_t size, off_t offset)
223 {
224         return pwrite(fd, buf, size, offset);
225 }
226
227 size_t exfat_utf16_len(const __le16 *str, size_t max_size)
228 {
229         size_t i = 0;
230
231         while (le16_to_cpu(str[i]) && i < max_size)
232                 i++;
233         return i;
234 }
235
236 ssize_t exfat_utf16_enc(const char *in_str, __u16 *out_str, size_t out_size)
237 {
238         size_t mbs_len, out_len, i;
239         wchar_t *wcs;
240
241         mbs_len = mbstowcs(NULL, in_str, 0);
242         if (mbs_len == (size_t)-1) {
243                 if (errno == EINVAL || errno == EILSEQ)
244                         exfat_err("invalid character sequence in current locale\n");
245                 return -errno;
246         }
247
248         wcs = calloc(mbs_len+1, sizeof(wchar_t));
249         if (!wcs)
250                 return -ENOMEM;
251
252         /* First convert multibyte char* string to wchar_t* string */
253         if (mbstowcs(wcs, in_str, mbs_len+1) == (size_t)-1) {
254                 if (errno == EINVAL || errno == EILSEQ)
255                         exfat_err("invalid character sequence in current locale\n");
256                 free(wcs);
257                 return -errno;
258         }
259
260         /* Convert wchar_t* string (sequence of code points) to UTF-16 string */
261         for (i = 0, out_len = 0; i < mbs_len; i++) {
262                 if (2*(out_len+1) > out_size ||
263                     (wcs[i] >= 0x10000 && 2*(out_len+2) > out_size)) {
264                         exfat_err("input string is too long\n");
265                         free(wcs);
266                         return -E2BIG;
267                 }
268
269                 /* Encode code point above Plane0 as UTF-16 surrogate pair */
270                 if (wcs[i] >= 0x10000) {
271                         out_str[out_len++] =
272                           cpu_to_le16(((wcs[i] - 0x10000) >> 10) + 0xD800);
273                         wcs[i] = ((wcs[i] - 0x10000) & 0x3FF) + 0xDC00;
274                 }
275
276                 out_str[out_len++] = cpu_to_le16(wcs[i]);
277         }
278
279         free(wcs);
280         return 2*out_len;
281 }
282
283 ssize_t exfat_utf16_dec(const __u16 *in_str, size_t in_len,
284                         char *out_str, size_t out_size)
285 {
286         size_t wcs_len, out_len, c_len, i;
287         char c_str[MB_LEN_MAX];
288         wchar_t *wcs;
289         mbstate_t ps;
290         wchar_t w;
291
292         wcs = calloc(in_len/2+1, sizeof(wchar_t));
293         if (!wcs)
294                 return -ENOMEM;
295
296         /* First convert UTF-16 string to wchar_t* string */
297         for (i = 0, wcs_len = 0; i < in_len/2; i++, wcs_len++) {
298                 wcs[wcs_len] = le16_to_cpu(in_str[i]);
299                 /*
300                  * If wchar_t can store code point above Plane0
301                  * then unpack UTF-16 surrogate pair to code point
302                  */
303 #if WCHAR_MAX >= 0x10FFFF
304                 if (wcs[wcs_len] >= 0xD800 && wcs[wcs_len] <= 0xDBFF &&
305                     i+1 < in_len/2) {
306                         w = le16_to_cpu(in_str[i+1]);
307                         if (w >= 0xDC00 && w <= 0xDFFF) {
308                                 wcs[wcs_len] = 0x10000 +
309                                                ((wcs[wcs_len] - 0xD800) << 10) +
310                                                (w - 0xDC00);
311                                 i++;
312                         }
313                 }
314 #endif
315         }
316
317         memset(&ps, 0, sizeof(ps));
318
319         /* And then convert wchar_t* string to multibyte char* string */
320         for (i = 0, out_len = 0, c_len = 0; i <= wcs_len; i++) {
321                 c_len = wcrtomb(c_str, wcs[i], &ps);
322                 /*
323                  * If character is non-representable in current locale then
324                  * try to store it as Unicode replacement code point U+FFFD
325                  */
326                 if (c_len == (size_t)-1 && errno == EILSEQ)
327                         c_len = wcrtomb(c_str, 0xFFFD, &ps);
328                 /* If U+FFFD is also non-representable, try question mark */
329                 if (c_len == (size_t)-1 && errno == EILSEQ)
330                         c_len = wcrtomb(c_str, L'?', &ps);
331                 /* If also (7bit) question mark fails then we cannot do more */
332                 if (c_len == (size_t)-1) {
333                         exfat_err("invalid UTF-16 sequence\n");
334                         free(wcs);
335                         return -errno;
336                 }
337                 if (out_len+c_len > out_size) {
338                         exfat_err("input string is too long\n");
339                         free(wcs);
340                         return -E2BIG;
341                 }
342                 memcpy(out_str+out_len, c_str, c_len);
343                 out_len += c_len;
344         }
345
346         free(wcs);
347
348         /* Last iteration of above loop should have produced null byte */
349         if (c_len == 0 || out_str[out_len-1] != 0) {
350                 exfat_err("invalid UTF-16 sequence\n");
351                 return -errno;
352         }
353
354         return out_len-1;
355 }
356
357 off_t exfat_get_root_entry_offset(struct exfat_blk_dev *bd)
358 {
359         struct pbr *bs;
360         int nbytes;
361         unsigned int cluster_size;
362         off_t root_clu_off;
363
364         bs = (struct pbr *)malloc(sizeof(struct pbr));
365         if (!bs) {
366                 exfat_err("failed to allocate memory\n");
367                 return -ENOMEM;
368         }
369
370         nbytes = exfat_read(bd->dev_fd, bs, sizeof(struct pbr), 0);
371         if (nbytes != sizeof(struct pbr)) {
372                 exfat_err("boot sector read failed: %d\n", errno);
373                 free(bs);
374                 return -1;
375         }
376
377         cluster_size = (1 << bs->bsx.sect_per_clus_bits) * bd->sector_size;
378         root_clu_off = le32_to_cpu(bs->bsx.clu_offset) * bd->sector_size +
379                 le32_to_cpu(bs->bsx.root_cluster - EXFAT_RESERVED_CLUSTERS)
380                 * cluster_size;
381         free(bs);
382
383         return root_clu_off;
384 }
385
386 char *exfat_conv_volume_label(struct exfat_dentry *vol_entry)
387 {
388         char *volume_label;
389         __le16 disk_label[VOLUME_LABEL_MAX_LEN];
390
391         volume_label = malloc(VOLUME_LABEL_BUFFER_SIZE);
392         if (!volume_label)
393                 return NULL;
394
395         memcpy(disk_label, vol_entry->vol_label, sizeof(disk_label));
396         memset(volume_label, 0, VOLUME_LABEL_BUFFER_SIZE);
397         if (exfat_utf16_dec(disk_label, vol_entry->vol_char_cnt*2,
398                 volume_label, VOLUME_LABEL_BUFFER_SIZE) < 0) {
399                 exfat_err("failed to decode volume label\n");
400                 free(volume_label);
401                 return NULL;
402         }
403
404         return volume_label;
405 }
406
407 int exfat_show_volume_label(struct exfat_blk_dev *bd, off_t root_clu_off)
408 {
409         struct exfat_dentry *vol_entry;
410         char *volume_label;
411         int nbytes;
412
413         vol_entry = malloc(sizeof(struct exfat_dentry));
414         if (!vol_entry) {
415                 exfat_err("failed to allocate memory\n");
416                 return -ENOMEM;
417         }
418
419         nbytes = exfat_read(bd->dev_fd, vol_entry,
420                 sizeof(struct exfat_dentry), root_clu_off);
421         if (nbytes != sizeof(struct exfat_dentry)) {
422                 exfat_err("volume entry read failed: %d\n", errno);
423                 free(vol_entry);
424                 return -1;
425         }
426
427         volume_label = exfat_conv_volume_label(vol_entry);
428         if (!volume_label) {
429                 free(vol_entry);
430                 return -EINVAL;
431         }
432
433         exfat_info("label: %s\n", volume_label);
434
435         free(volume_label);
436         free(vol_entry);
437         return 0;
438 }
439
440 int exfat_set_volume_label(struct exfat_blk_dev *bd,
441                 char *label_input, off_t root_clu_off)
442 {
443         struct exfat_dentry vol;
444         int nbytes;
445         __u16 volume_label[VOLUME_LABEL_MAX_LEN];
446         int volume_label_len;
447
448         volume_label_len = exfat_utf16_enc(label_input,
449                         volume_label, sizeof(volume_label));
450         if (volume_label_len < 0) {
451                 exfat_err("failed to encode volume label\n");
452                 return -1;
453         }
454
455         vol.type = EXFAT_VOLUME;
456         memset(vol.vol_label, 0, sizeof(vol.vol_label));
457         memcpy(vol.vol_label, volume_label, volume_label_len);
458         vol.vol_char_cnt = volume_label_len/2;
459
460         nbytes = exfat_write(bd->dev_fd, &vol, sizeof(struct exfat_dentry),
461                         root_clu_off);
462         if (nbytes != sizeof(struct exfat_dentry)) {
463                 exfat_err("volume entry write failed: %d\n", errno);
464                 return -1;
465         }
466         fsync(bd->dev_fd);
467
468         exfat_info("new label: %s\n", label_input);
469         return 0;
470 }
471
472 int exfat_read_sector(struct exfat_blk_dev *bd, void *buf, unsigned int sec_off)
473 {
474         int ret;
475         unsigned long long offset = sec_off * bd->sector_size;
476
477         lseek(bd->dev_fd, offset, SEEK_SET);
478         ret = read(bd->dev_fd, buf, bd->sector_size);
479         if (ret < 0) {
480                 exfat_err("read failed, sec_off : %u\n", sec_off);
481                 return -1;
482         }
483         return 0;
484 }
485
486 int exfat_write_sector(struct exfat_blk_dev *bd, void *buf,
487                 unsigned int sec_off)
488 {
489         int bytes;
490         unsigned long long offset = sec_off * bd->sector_size;
491
492         lseek(bd->dev_fd, offset, SEEK_SET);
493         bytes = write(bd->dev_fd, buf, bd->sector_size);
494         if (bytes != (int)bd->sector_size) {
495                 exfat_err("write failed, sec_off : %u, bytes : %d\n", sec_off,
496                         bytes);
497                 return -1;
498         }
499         return 0;
500 }
501
502 int exfat_write_checksum_sector(struct exfat_blk_dev *bd,
503                 unsigned int checksum, bool is_backup)
504 {
505         __le32 *checksum_buf;
506         int ret = 0;
507         unsigned int i;
508         unsigned int sec_idx = CHECKSUM_SEC_IDX;
509
510         checksum_buf = malloc(bd->sector_size);
511         if (!checksum_buf)
512                 return -1;
513
514         if (is_backup)
515                 sec_idx += BACKUP_BOOT_SEC_IDX;
516
517         for (i = 0; i < bd->sector_size / sizeof(int); i++)
518                 checksum_buf[i] = cpu_to_le32(checksum);
519
520         ret = exfat_write_sector(bd, checksum_buf, sec_idx);
521         if (ret) {
522                 exfat_err("checksum sector write failed\n");
523                 goto free;
524         }
525
526 free:
527         free(checksum_buf);
528         return ret;
529 }
530
531 int exfat_show_volume_serial(struct exfat_blk_dev *bd,
532                 struct exfat_user_input *ui)
533 {
534         struct pbr *ppbr;
535         int ret;
536
537         ppbr = malloc(bd->sector_size);
538         if (!ppbr) {
539                 exfat_err("Cannot allocate pbr: out of memory\n");
540                 return -1;
541         }
542
543         /* read main boot sector */
544         ret = exfat_read_sector(bd, (char *)ppbr, BOOT_SEC_IDX);
545         if (ret < 0) {
546                 exfat_err("main boot sector read failed\n");
547                 ret = -1;
548                 goto free_ppbr;
549         }
550
551         exfat_info("volume serial : 0x%x\n", ppbr->bsx.vol_serial);
552
553 free_ppbr:
554         free(ppbr);
555         return ret;
556 }
557
558 static int exfat_update_boot_checksum(struct exfat_blk_dev *bd, bool is_backup)
559 {
560         unsigned int checksum = 0;
561         int ret, sec_idx, backup_sec_idx = 0;
562         int sector_size = bd->sector_size;
563         unsigned char *buf;
564
565         buf = malloc(bd->sector_size);
566         if (!buf) {
567                 exfat_err("Cannot allocate pbr: out of memory\n");
568                 return -1;
569         }
570
571         if (is_backup)
572                 backup_sec_idx = BACKUP_BOOT_SEC_IDX;
573
574         for (sec_idx = BOOT_SEC_IDX; sec_idx < CHECKSUM_SEC_IDX; sec_idx++) {
575                 bool is_boot_sec = false;
576
577                 ret = exfat_read_sector(bd, buf, sec_idx + backup_sec_idx);
578                 if (ret < 0) {
579                         exfat_err("sector(%d) read failed\n", sec_idx);
580                         ret = -1;
581                         goto free_buf;
582                 }
583
584                 if (sec_idx == BOOT_SEC_IDX) {
585                         is_boot_sec = true;
586                         sector_size = sizeof(struct pbr);
587                 } else if (sec_idx >= EXBOOT_SEC_IDX && sec_idx < OEM_SEC_IDX)
588                         sector_size = sizeof(struct exbs);
589
590                 boot_calc_checksum(buf, sector_size, is_boot_sec,
591                         &checksum);
592         }
593
594         ret = exfat_write_checksum_sector(bd, checksum, is_backup);
595
596 free_buf:
597         free(buf);
598
599         return ret;
600 }
601
602 int exfat_set_volume_serial(struct exfat_blk_dev *bd,
603                 struct exfat_user_input *ui)
604 {
605         int ret;
606         struct pbr *ppbr;
607
608         ppbr = malloc(bd->sector_size);
609         if (!ppbr) {
610                 exfat_err("Cannot allocate pbr: out of memory\n");
611                 return -1;
612         }
613
614         /* read main boot sector */
615         ret = exfat_read_sector(bd, (char *)ppbr, BOOT_SEC_IDX);
616         if (ret < 0) {
617                 exfat_err("main boot sector read failed\n");
618                 ret = -1;
619                 goto free_ppbr;
620         }
621
622         ppbr->bsx.vol_serial = ui->volume_serial;
623
624         /* update main boot sector */
625         ret = exfat_write_sector(bd, (char *)ppbr, BOOT_SEC_IDX);
626         if (ret < 0) {
627                 exfat_err("main boot sector write failed\n");
628                 ret = -1;
629                 goto free_ppbr;
630         }
631
632         /* update backup boot sector */
633         ret = exfat_write_sector(bd, (char *)ppbr, BACKUP_BOOT_SEC_IDX);
634         if (ret < 0) {
635                 exfat_err("backup boot sector write failed\n");
636                 ret = -1;
637                 goto free_ppbr;
638         }
639
640         ret = exfat_update_boot_checksum(bd, 0);
641         if (ret < 0) {
642                 exfat_err("main checksum update failed\n");
643                 goto free_ppbr;
644         }
645
646         ret = exfat_update_boot_checksum(bd, 1);
647         if (ret < 0)
648                 exfat_err("backup checksum update failed\n");
649 free_ppbr:
650         free(ppbr);
651
652         exfat_info("New volume serial : 0x%x\n", ui->volume_serial);
653
654         return ret;
655 }
656
657 unsigned int exfat_clus_to_blk_dev_off(struct exfat_blk_dev *bd,
658                 unsigned int clu_off_sectnr, unsigned int clu)
659 {
660         return clu_off_sectnr * bd->sector_size +
661                 (clu - EXFAT_RESERVED_CLUSTERS) * bd->cluster_size;
662 }