]> git.sven.stormbind.net Git - sven/exfatprogs.git/blob - exfat2img/exfat2img.c
New upstream release.
[sven/exfatprogs.git] / exfat2img / exfat2img.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *   Copyright (C) 2021 LG Electronics.
4  *
5  *   Author(s): Hyunchul Lee <hyc.lee@gmail.com>
6  */
7
8 #include <unistd.h>
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <fcntl.h>
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <getopt.h>
15 #include <inttypes.h>
16 #include <string.h>
17 #include <errno.h>
18
19 #include "exfat_ondisk.h"
20 #include "libexfat.h"
21 #include "exfat_fs.h"
22 #include "exfat_dir.h"
23
24 #define EXFAT_MAX_UPCASE_CHARS  0x10000
25
26 struct exfat2img_hdr {
27         __le32  magic;
28         __le32  major_version;
29         __le32  minor_version;
30         __le32  data_offset;
31         __le32  heap_clus_offset;
32         __le32  cluster_size;
33         __le32  cluster_count;
34         __le32  reserved[20];
35 } __packed;
36
37 #define EI_MAGIC                0xB67598DB
38 #define EI_CC_PAYLOAD_LEN       4
39
40 enum {
41         EI_CC_INVALID,
42         EI_CC_COPY_1,
43         EI_CC_COPY_2,   /* followed by cluster count(4-byte) */
44         EI_CC_SKIP_1,
45         EI_CC_SKIP_2,   /* followed by cluster count(4-byte) */
46 };
47
48 struct exfat2img {
49         int                     out_fd;
50         bool                    is_stdout;
51         off_t                   stdout_offset;
52         bool                    save_cc;
53         struct exfat_blk_dev    bdev;
54         struct exfat            *exfat;
55         struct buffer_desc      *dump_bdesc;
56         struct buffer_desc      *scan_bdesc;
57         struct exfat_de_iter    de_iter;
58 };
59
60 struct exfat_stat {
61         long            dir_count;
62         long            file_count;
63         long            error_count;
64         uint64_t        written_bytes;
65 };
66
67 static struct exfat2img_hdr ei_hdr;
68 static struct exfat2img ei;
69 static struct exfat_stat exfat_stat;
70 static struct path_resolve_ctx path_resolve_ctx;
71
72 static struct option opts[] = {
73         {"output",      required_argument,      NULL,   'o' },
74         {"version",     no_argument,            NULL,   'V' },
75         {"help",        no_argument,            NULL,   'h' },
76         {NULL,          0,                      NULL,    0  }
77 };
78
79 static void usage(const char *name)
80 {
81         fprintf(stderr, "Usage: %s <device> [image-file]\n", name);
82         fprintf(stderr, "\t-o | --output <image-file> Specify destination file\n");
83         fprintf(stderr, "\t-V | --version             Show version\n");
84         fprintf(stderr, "\t-h | --help                Show help\n");
85         exit(EXIT_FAILURE);
86 }
87
88 #define ei_err(parent, inode, fmt, ...)                 \
89 ({                                                      \
90                 exfat_resolve_path_parent(&path_resolve_ctx,    \
91                         parent, inode);                 \
92                 exfat_err("ERROR: %s: " fmt,            \
93                         path_resolve_ctx.local_path,    \
94                         ##__VA_ARGS__);                 \
95 })
96
97 static void free_exfat2img(struct exfat2img *ei)
98 {
99         if (ei->exfat)
100                 exfat_free_exfat(ei->exfat);
101         if (ei->dump_bdesc)
102                 exfat_free_buffer(ei->dump_bdesc, 2);
103         if (ei->scan_bdesc)
104                 exfat_free_buffer(ei->scan_bdesc, 2);
105         if (ei->out_fd)
106                 close(ei->out_fd);
107         if (ei->bdev.dev_fd)
108                 close(ei->bdev.dev_fd);
109 }
110
111 static int create_exfat2img(struct exfat2img *ei,
112                             struct pbr *bs,
113                             const char *out_path)
114 {
115         int err;
116
117         ei->exfat = exfat_alloc_exfat(&ei->bdev, bs);
118         if (!ei->exfat)
119                 return -ENOMEM;
120
121         ei->dump_bdesc = exfat_alloc_buffer(2,
122                                             ei->exfat->clus_size,
123                                             ei->exfat->sect_size);
124         if (!ei->dump_bdesc) {
125                 err = -ENOMEM;
126                 goto err;
127         }
128
129         ei->scan_bdesc = exfat_alloc_buffer(2,
130                                             ei->exfat->clus_size,
131                                             ei->exfat->sect_size);
132         if (!ei->scan_bdesc) {
133                 err = -ENOMEM;
134                 goto err;
135         }
136
137         if (strcmp(out_path, "-")) {
138                 ei->out_fd = open(out_path, O_CREAT | O_TRUNC | O_RDWR, 0664);
139         } else {
140                 ei->is_stdout = true;
141                 ei->out_fd = fileno(stdout);
142                 ei->save_cc = true;
143         }
144         if (ei->out_fd < 0) {
145                 exfat_err("failed to open %s: %s\n", out_path,
146                           strerror(errno));
147                 err = -errno;
148                 goto err;
149         }
150
151         return 0;
152 err:
153         free_exfat2img(ei);
154         return err;
155 }
156
157 /**
158  * @end: excluded.
159  */
160 static ssize_t dump_range(struct exfat2img *ei, off_t start, off_t end)
161 {
162         struct exfat *exfat = ei->exfat;
163         size_t len, total_len = 0;
164         ssize_t ret;
165
166         if (ei->is_stdout) {
167                 unsigned int sc, sc_offset;
168                 unsigned int ec, ec_offset;
169
170                 if (exfat_o2c(ei->exfat, start, &sc, &sc_offset) < 0)
171                         return -ERANGE;
172                 if (exfat_o2c(ei->exfat, end - 1, &ec, &ec_offset) < 0)
173                         return -ERANGE;
174                 exfat_bitmap_set_range(ei->exfat, exfat->alloc_bitmap,
175                                        sc, ec - sc + 1);
176                 return end - start;
177         }
178
179         while (start < end) {
180                 len = (size_t)MIN(end - start, exfat->clus_size);
181
182                 ret = exfat_read(exfat->blk_dev->dev_fd,
183                                  ei->dump_bdesc[0].buffer,
184                                  len, start);
185                 if (ret != (ssize_t)len) {
186                         exfat_err("failed to read %llu bytes at %llu\n",
187                                   (unsigned long long)len,
188                                   (unsigned long long)start);
189                         return -EIO;
190                 }
191
192                 ret = pwrite(ei->out_fd, ei->dump_bdesc[0].buffer,
193                              len, start);
194                 if (ret != (ssize_t)len) {
195                         exfat_err("failed to write %llu bytes at %llu\n",
196                                   (unsigned long long)len,
197                                   (unsigned long long)start);
198                         return -EIO;
199                 }
200
201                 start += len;
202                 total_len += len;
203                 exfat_stat.written_bytes += len;
204         }
205         return total_len;
206 }
207
208 static int dump_sectors(struct exfat2img *ei,
209                         off_t start_sect,
210                         off_t end_sect_excl)
211 {
212         struct exfat *exfat = ei->exfat;
213         off_t s, e;
214
215         s = exfat_s2o(exfat, start_sect);
216         e = exfat_s2o(exfat, end_sect_excl);
217         return dump_range(ei, s, e) <= 0 ? -EIO : 0;
218 }
219
220 static int dump_clusters(struct exfat2img *ei,
221                          clus_t start_clus,
222                          clus_t end_clus_excl)
223 {
224         struct exfat *exfat = ei->exfat;
225         off_t s, e;
226
227         s = exfat_c2o(exfat, start_clus);
228         e = exfat_c2o(exfat, end_clus_excl);
229         return dump_range(ei, s, e) <= 0 ? -EIO : 0;
230 }
231
232 static int dump_directory(struct exfat2img *ei,
233                           struct exfat_inode *inode, size_t size,
234                           clus_t *out_clus_count)
235 {
236         struct exfat *exfat = ei->exfat;
237         clus_t clus, possible_count;
238         uint64_t max_count;
239         size_t dump_size;
240         off_t start_off, end_off;
241
242         if (size == 0)
243                 return -EINVAL;
244
245         if (!(inode->attr & ATTR_SUBDIR))
246                 return -EINVAL;
247
248         clus = inode->first_clus;
249         *out_clus_count = 0;
250         max_count = DIV_ROUND_UP(inode->size, exfat->clus_size);
251
252         possible_count = (256 * MB) >> (exfat->bs->bsx.sect_per_clus_bits +
253                                         exfat->bs->bsx.sect_size_bits);
254         possible_count = MIN(possible_count, exfat->clus_count);
255
256         while (exfat_heap_clus(exfat, clus) && *out_clus_count < possible_count) {
257                 dump_size = MIN(size, exfat->clus_size);
258                 start_off = exfat_c2o(exfat, clus);
259                 end_off = start_off + DIV_ROUND_UP(dump_size, 512) * 512;
260
261                 if (dump_range(ei, start_off, end_off) < 0)
262                         return -EIO;
263
264                 *out_clus_count += 1;
265                 size -= dump_size;
266                 if (size == 0)
267                         break;
268
269                 if (inode->is_contiguous) {
270                         if (*out_clus_count >= max_count)
271                                 break;
272                 }
273                 if (exfat_get_inode_next_clus(exfat, inode, clus, &clus))
274                         return -EINVAL;
275         }
276         return 0;
277 }
278
279 static int dump_root(struct exfat2img *ei)
280 {
281         struct exfat *exfat = ei->exfat;
282         struct exfat_inode *root;
283         clus_t clus_count = 0;
284
285         root = exfat_alloc_inode(ATTR_SUBDIR);
286         if (!root)
287                 return -ENOMEM;
288
289         root->first_clus = le32_to_cpu(exfat->bs->bsx.root_cluster);
290         dump_directory(ei, root, (size_t)-1, &clus_count);
291         root->size = clus_count * exfat->clus_size;
292
293         ei->exfat->root = root;
294         return 0;
295 }
296
297 static int read_file_dentry_set(struct exfat_de_iter *iter,
298                                 struct exfat_inode **new_node, int *skip_dentries)
299 {
300         struct exfat_dentry *file_de, *stream_de, *dentry;
301         struct exfat_inode *node = NULL;
302         int i, ret;
303
304         ret = exfat_de_iter_get(iter, 0, &file_de);
305         if (ret || file_de->type != EXFAT_FILE) {
306                 exfat_debug("failed to get file dentry\n");
307                 return -EINVAL;
308         }
309
310         ret = exfat_de_iter_get(iter, 1, &stream_de);
311         if (ret || stream_de->type != EXFAT_STREAM) {
312                 exfat_debug("failed to get stream dentry\n");
313                 *skip_dentries = 2;
314                 goto skip_dset;
315         }
316
317         *new_node = NULL;
318         node = exfat_alloc_inode(le16_to_cpu(file_de->file_attr));
319         if (!node)
320                 return -ENOMEM;
321
322         for (i = 2; i <= MIN(file_de->file_num_ext, 1 + MAX_NAME_DENTRIES); i++) {
323                 ret = exfat_de_iter_get(iter, i, &dentry);
324                 if (ret || dentry->type != EXFAT_NAME)
325                         break;
326                 memcpy(node->name +
327                        (i - 2) * ENTRY_NAME_MAX, dentry->name_unicode,
328                        sizeof(dentry->name_unicode));
329         }
330
331         node->first_clus = le32_to_cpu(stream_de->stream_start_clu);
332         node->is_contiguous =
333                 ((stream_de->stream_flags & EXFAT_SF_CONTIGUOUS) != 0);
334         node->size = le64_to_cpu(stream_de->stream_size);
335
336         *skip_dentries = i;
337         *new_node = node;
338         return 0;
339 skip_dset:
340         *new_node = NULL;
341         exfat_free_inode(node);
342         return -EINVAL;
343 }
344
345 static int read_file(struct exfat_de_iter *de_iter,
346                      struct exfat_inode **new_node, int *dentry_count)
347 {
348         struct exfat_inode *node;
349         int ret;
350
351         *new_node = NULL;
352
353         ret = read_file_dentry_set(de_iter, &node, dentry_count);
354         if (ret)
355                 return ret;
356
357         if (node->attr & ATTR_SUBDIR)
358                 exfat_stat.dir_count++;
359         else
360                 exfat_stat.file_count++;
361         *new_node = node;
362         return ret;
363 }
364
365 static int read_bitmap(struct exfat2img *ei, struct exfat_de_iter *iter)
366 {
367         struct exfat *exfat = ei->exfat;
368         struct exfat_dentry *dentry;
369         int ret;
370
371         ret = exfat_de_iter_get(iter, 0, &dentry);
372         if (ret || dentry->type != EXFAT_BITMAP) {
373                 exfat_debug("failed to get bimtap dentry\n");
374                 return -EINVAL;
375         }
376
377         exfat_debug("start cluster %#x, size %#" PRIx64 "\n",
378                     le32_to_cpu(dentry->bitmap_start_clu),
379                     le64_to_cpu(dentry->bitmap_size));
380
381         if (!exfat_heap_clus(exfat, le32_to_cpu(dentry->bitmap_start_clu))) {
382                 exfat_err("invalid start cluster of allocate bitmap. 0x%x\n",
383                           le32_to_cpu(dentry->bitmap_start_clu));
384                 return -EINVAL;
385         }
386
387         exfat->disk_bitmap_clus = le32_to_cpu(dentry->bitmap_start_clu);
388         exfat->disk_bitmap_size = DIV_ROUND_UP(exfat->clus_count, 8);
389
390         return dump_clusters(ei,
391                              exfat->disk_bitmap_clus,
392                              exfat->disk_bitmap_clus +
393                              DIV_ROUND_UP(exfat->disk_bitmap_size,
394                                           exfat->clus_size));
395 }
396
397 static int read_upcase_table(struct exfat2img *ei,
398                              struct exfat_de_iter *iter)
399 {
400         struct exfat *exfat = ei->exfat;
401         struct exfat_dentry *dentry = NULL;
402         int retval;
403         ssize_t size;
404
405         retval = exfat_de_iter_get(iter, 0, &dentry);
406         if (retval || dentry->type != EXFAT_UPCASE) {
407                 exfat_debug("failed to get upcase dentry\n");
408                 return -EINVAL;
409         }
410
411         if (!exfat_heap_clus(exfat, le32_to_cpu(dentry->upcase_start_clu))) {
412                 exfat_err("invalid start cluster of upcase table. 0x%x\n",
413                           le32_to_cpu(dentry->upcase_start_clu));
414                 return -EINVAL;
415         }
416
417         size = EXFAT_MAX_UPCASE_CHARS * sizeof(__le16);
418         return dump_clusters(ei, le32_to_cpu(dentry->upcase_start_clu),
419                              le32_to_cpu(dentry->upcase_start_clu) +
420                              DIV_ROUND_UP(size, exfat->clus_size));
421 }
422
423 static int read_children(struct exfat2img *ei, struct exfat_inode *dir,
424                          off_t *end_file_offset)
425 {
426         struct exfat *exfat = ei->exfat;
427         struct exfat_inode *node = NULL;
428         struct exfat_dentry *dentry;
429         struct exfat_de_iter *de_iter;
430         int dentry_count;
431         int ret;
432
433         *end_file_offset = 0;
434         de_iter = &ei->de_iter;
435         ret = exfat_de_iter_init(de_iter, exfat, dir, ei->scan_bdesc);
436         if (ret == EOF)
437                 return 0;
438         else if (ret)
439                 return ret;
440
441         while (1) {
442                 ret = exfat_de_iter_get(de_iter, 0, &dentry);
443                 if (ret == EOF) {
444                         break;
445                 } else if (ret) {
446                         ei_err(dir->parent, dir,
447                                "failed to get a dentry. %d\n", ret);
448                         goto err;
449                 }
450                 dentry_count = 1;
451
452                 switch (dentry->type) {
453                 case EXFAT_FILE:
454                         ret = read_file(de_iter, &node, &dentry_count);
455                         if (ret < 0) {
456                                 exfat_stat.error_count++;
457                                 break;
458                         }
459
460                         if (node) {
461                                 if ((node->attr & ATTR_SUBDIR) && node->size) {
462                                         node->parent = dir;
463                                         list_add_tail(&node->sibling,
464                                                       &dir->children);
465                                         list_add_tail(&node->list,
466                                                       &exfat->dir_list);
467                                 } else {
468                                         exfat_free_inode(node);
469                                 }
470                         }
471                         break;
472                 case EXFAT_LAST:
473                         goto out;
474                 case EXFAT_BITMAP:
475                         if (dir == exfat->root) {
476                                 ret = read_bitmap(ei, de_iter);
477                                 if (ret)
478                                         exfat_debug("failed to read bitmap\n");
479                         }
480                         break;
481                 case EXFAT_UPCASE:
482                         if (dir == exfat->root) {
483                                 ret = read_upcase_table(ei, de_iter);
484                                 if (ret)
485                                         exfat_debug("failed to upcase table\n");
486                         }
487                         break;
488                 case EXFAT_VOLUME:
489                 default:
490                         break;
491                 }
492
493                 ret = exfat_de_iter_advance(de_iter, dentry_count);
494         }
495 out:
496         *end_file_offset = exfat_de_iter_file_offset(de_iter);
497         exfat_de_iter_flush(de_iter);
498         return 0;
499 err:
500         exfat_free_children(dir, false);
501         INIT_LIST_HEAD(&dir->children);
502         exfat_de_iter_flush(de_iter);
503         return ret;
504 }
505
506 static int dump_filesystem(struct exfat2img *ei)
507 {
508         struct exfat *exfat = ei->exfat;
509         struct exfat_inode *dir;
510         int ret = 0, dir_errors;
511         clus_t clus_count;
512         off_t end_file_offset;
513
514         if (!exfat->root) {
515                 exfat_err("root is NULL\n");
516                 return -ENOENT;
517         }
518
519         list_add(&exfat->root->list, &exfat->dir_list);
520
521         while (!list_empty(&exfat->dir_list)) {
522                 dir = list_entry(exfat->dir_list.next,
523                                  struct exfat_inode, list);
524                 clus_count = 0;
525
526                 if (!(dir->attr & ATTR_SUBDIR)) {
527                         ei_err(dir->parent, dir,
528                                "failed to travel directories. the node is not directory\n");
529                         ret = -EINVAL;
530                         goto out;
531                 }
532
533                 dir_errors = read_children(ei, dir, &end_file_offset);
534                 if (!dir_errors) {
535                         dump_directory(ei, dir, (size_t)end_file_offset,
536                                        &clus_count);
537                 } else if (dir_errors) {
538                         dump_directory(ei, dir, (size_t)-1,
539                                        &clus_count);
540                         exfat_resolve_path(&path_resolve_ctx, dir);
541                         exfat_debug("failed to check dentries: %s\n",
542                                     path_resolve_ctx.local_path);
543                         ret = dir_errors;
544                 }
545
546                 list_del(&dir->list);
547                 exfat_free_ancestors(dir);
548         }
549 out:
550         exfat_free_dir_list(exfat);
551         return ret;
552 }
553
554 static int dump_bytes_to_stdout(struct exfat2img *ei,
555                                 off_t start, off_t end_excl, bool fill_zero)
556 {
557         struct exfat *exfat = ei->exfat;
558         size_t len;
559         ssize_t ret;
560
561         if (start != ei->stdout_offset) {
562                 exfat_err("try to skip for stdout at %llu, expected: %llu\n",
563                           (unsigned long long)start,
564                           (unsigned long long)ei->stdout_offset);
565                 return -EINVAL;
566         }
567
568         while (start < end_excl) {
569                 len = (size_t)MIN(end_excl - start, exfat->clus_size);
570                 if (!fill_zero) {
571                         ret = exfat_read(exfat->blk_dev->dev_fd,
572                                          ei->dump_bdesc[0].buffer,
573                                          len, start);
574                         if (ret != (ssize_t)len) {
575                                 exfat_err("failed to read %llu bytes at %llu\n",
576                                           (unsigned long long)len,
577                                           (unsigned long long)start);
578                                 return -EIO;
579                         }
580
581                         ret = write(ei->out_fd, ei->dump_bdesc[0].buffer, len);
582                         if (ret != (ssize_t)len) {
583                                 exfat_err("failed to write %llu bytes at %llu\n",
584                                           (unsigned long long)len,
585                                           (unsigned long long)start);
586                                 return -EIO;
587                         }
588                 } else {
589                         ret = write(ei->out_fd, exfat->zero_cluster, len);
590                         if (ret != (ssize_t)len) {
591                                 exfat_err("failed to write %llu bytes at %llu\n",
592                                           (unsigned long long)len,
593                                           (unsigned long long)start);
594                                 return -EIO;
595                         }
596                 }
597
598                 start += len;
599                 ei->stdout_offset += len;
600                 exfat_stat.written_bytes += len;
601         }
602         return 0;
603 }
604
605 static int dump_clusters_to_stdout(struct exfat2img *ei,
606                                    unsigned int start_clu, unsigned int end_clu,
607                                    bool fill_zero)
608 {
609         unsigned int clu, clu_count;
610         unsigned char cc;
611         unsigned int cc_clu_count, cc_len;
612         off_t start_off, end_off_excl;
613         char buf[1 + EI_CC_PAYLOAD_LEN];
614
615         clu = start_clu;
616         clu_count = end_clu - start_clu + 1;
617
618         if (ei->save_cc) {
619                 /* if the count of clusters is less than 5, use SKIP_1 or COPY_2 */
620                 cc_clu_count = clu_count < 5 ? 1 : clu_count;
621                 cc_len = cc_clu_count == 1 ? 1 : 1 + EI_CC_PAYLOAD_LEN;
622                 if (fill_zero)
623                         cc = cc_clu_count == 1 ? EI_CC_SKIP_1 : EI_CC_SKIP_2;
624                 else
625                         cc = cc_clu_count == 1 ? EI_CC_COPY_1 : EI_CC_COPY_2;
626         } else {
627                 cc = EI_CC_INVALID;
628                 cc_clu_count = clu_count;
629         }
630
631         while (clu <= end_clu) {
632                 if (cc != EI_CC_INVALID) {
633                         buf[0] = cc;
634                         *((__le32 *)&buf[1]) =
635                                 cpu_to_le32(cc_clu_count);
636                         if (write(ei->out_fd, buf, cc_len) != (ssize_t)cc_len) {
637                                 exfat_err("failed to write cc %d : %u\n for %u ~ %u clusters\n",
638                                           cc, cc_clu_count,
639                                           start_clu, start_clu + cc_clu_count - 1);
640                         }
641                 }
642
643                 if (cc == EI_CC_COPY_1 || cc == EI_CC_COPY_2) {
644                         start_off = exfat_c2o(ei->exfat, clu);
645                         end_off_excl = exfat_c2o(ei->exfat, clu + cc_clu_count);
646
647                         if (dump_bytes_to_stdout(ei, start_off, end_off_excl,
648                                                  false) < 0)
649                                 return -EIO;
650                 } else {
651                         ei->stdout_offset += (off_t)cc_clu_count * ei->exfat->clus_size;
652                 }
653                 clu += cc_clu_count;
654         }
655
656         return 0;
657 }
658
659 static int dump_to_stdout(struct exfat2img *ei)
660 {
661         struct exfat *exfat = ei->exfat;
662         off_t start_off, end_off;
663         unsigned int clu, last_clu, next_clu;
664         unsigned int start_clu, end_clu;
665
666         start_off = 0;
667         end_off = exfat_s2o(exfat, le32_to_cpu(exfat->bs->bsx.clu_offset));
668         if (dump_bytes_to_stdout(ei, start_off, end_off, false) < 0) {
669                 exfat_err("failed to dump boot sectors and FAT tables\n");
670                 return -EIO;
671         }
672
673         clu = EXFAT_FIRST_CLUSTER;
674         last_clu = clu + exfat->clus_count;
675         while (clu < last_clu) {
676                 /* read and write clusters for allocated ones */
677                 start_clu = 0;
678                 while (clu < last_clu &&
679                        exfat_bitmap_get(exfat->alloc_bitmap, clu)) {
680                         if (!start_clu)
681                                 start_clu = clu;
682                         end_clu = clu;
683                         clu++;
684                 }
685
686                 if (start_clu) {
687                         if (dump_clusters_to_stdout(ei, start_clu, end_clu, false) < 0) {
688                                 start_off = exfat_c2o(exfat, start_clu);
689                                 end_off = exfat_c2o(exfat, end_clu);
690                                 exfat_err("failed to dump range from %llx to %llx\n",
691                                           (unsigned long long)start_off,
692                                           (unsigned long long)end_off);
693                                 return -EIO;
694                         }
695                 }
696
697                 /* exit if all of the remaining clusters are free */
698                 if (clu >= last_clu)
699                         break;
700                 if (exfat_bitmap_find_one(exfat, exfat->alloc_bitmap,
701                                           clu, &next_clu))
702                         next_clu = EXFAT_FIRST_CLUSTER + exfat->clus_count;
703
704                 /* write zeroes for free clusters */
705                 start_clu = clu;
706                 end_clu = next_clu - 1;
707                 if (dump_clusters_to_stdout(ei, start_clu, end_clu, true) < 0) {
708                         start_off = exfat_c2o(exfat, start_clu);
709                         end_off = exfat_c2o(exfat, end_clu);
710                         exfat_err("failed to dump zero range from %llx to %llx\n",
711                                   (unsigned long long)start_off,
712                                   (unsigned long long)end_off);
713                         return -EIO;
714                 }
715
716                 clu = next_clu;
717         }
718
719         return 0;
720 }
721
722 static int dump_header(struct exfat2img *ei)
723 {
724         struct exfat *exfat = ei->exfat;
725
726         ei_hdr.magic = cpu_to_le32(EI_MAGIC);
727         ei_hdr.major_version = cpu_to_le32(1);
728         ei_hdr.minor_version = cpu_to_le32(0);
729         ei_hdr.data_offset = cpu_to_le32(sizeof(struct exfat2img_hdr));
730         ei_hdr.heap_clus_offset =
731                 cpu_to_le32(le32_to_cpu(exfat->bs->bsx.clu_offset) *
732                             exfat->sect_size);
733         ei_hdr.cluster_size = cpu_to_le32(exfat->clus_size);
734         ei_hdr.cluster_count = cpu_to_le32(exfat->clus_count);
735
736         if (write(ei->out_fd, &ei_hdr, sizeof(ei_hdr)) != (ssize_t)sizeof(ei_hdr)) {
737                 exfat_err("failed to write exfat2img header\n");
738                 return -EIO;
739         }
740         return 0;
741 }
742
743 static ssize_t read_stream(int fd, void *buf, size_t len)
744 {
745         size_t read_len = 0;
746         ssize_t ret;
747
748         while (read_len < len) {
749                 ret = read(fd, buf, len - read_len);
750                 if (ret < 0) {
751                         if (errno != -EAGAIN && errno != -EINTR)
752                                 return -1;
753                         ret = 0;
754                 } else if (ret == 0) {
755                         return 0;
756                 }
757                 buf = (char *)buf + (size_t)ret;
758                 read_len += (size_t)ret;
759         }
760         return read_len;
761 }
762
763 static int restore_from_stdin(struct exfat2img *ei)
764 {
765         int in_fd, ret;
766         unsigned char cc;
767         unsigned int clu, end_clu;
768         unsigned int cc_clu_count;
769         unsigned int clus_size;
770         __le32 t_cc_clu_count;
771         off_t out_start_off, out_end_off_excl;
772         off_t in_start_off;
773         size_t len;
774
775         in_fd = fileno(stdin);
776         if (in_fd < 0) {
777                 exfat_err("failed to get fd from stdin\n");
778                 return in_fd;
779         }
780
781         if (read_stream(in_fd, &ei_hdr, sizeof(ei_hdr)) != (ssize_t)sizeof(ei_hdr)) {
782                 exfat_err("failed to read a header\n");
783                 return -EIO;
784         }
785
786         if (le32_to_cpu(ei_hdr.magic) != EI_MAGIC) {
787                 exfat_err("header has invalid magic %#x, expected %#x\n",
788                           le32_to_cpu(ei_hdr.magic), EI_MAGIC);
789                 return -EINVAL;
790         }
791
792         clus_size = le32_to_cpu(ei_hdr.cluster_size);
793
794         ei->out_fd = ei->bdev.dev_fd;
795         ei->dump_bdesc = exfat_alloc_buffer(2, clus_size, 512);
796         if (!ei->dump_bdesc)
797                 return -ENOMEM;
798
799         /* restore boot regions, and FAT tables */
800         in_start_off = le32_to_cpu(ei_hdr.data_offset);
801         out_start_off = 0;
802         out_end_off_excl = le32_to_cpu(ei_hdr.heap_clus_offset);
803         while (out_start_off < out_end_off_excl) {
804                 len = MIN(out_end_off_excl - out_start_off, clus_size);
805                 if (read_stream(in_fd, ei->dump_bdesc[0].buffer, len) != (ssize_t)len) {
806                         exfat_err("failed to read first meta region. %llu ~ %llu\n",
807                                   (unsigned long long)in_start_off,
808                                   (unsigned long long)in_start_off + len);
809                         ret = -EIO;
810                         goto out;
811                 }
812
813                 if (pwrite(ei->out_fd, ei->dump_bdesc[0].buffer, len, out_start_off)
814                     != (ssize_t)len) {
815                         exfat_err("failed to write first meta region. %llu ~ %llu\n",
816                                   (unsigned long long)out_start_off,
817                                   (unsigned long long)out_start_off + len);
818                         ret = -EIO;
819                         goto out;
820                 }
821
822                 out_start_off += len;
823                 in_start_off += len;
824         }
825
826         /* restore heap clusters */
827         clu = 0;
828         while (clu < le32_to_cpu(ei_hdr.cluster_count)) {
829                 if (read_stream(in_fd, &cc, sizeof(cc)) != (ssize_t)sizeof(cc)) {
830                         exfat_err("failed to read cc at %llu\n",
831                                   (unsigned long long)in_start_off);
832                         ret = -EIO;
833                         goto out;
834                 }
835                 in_start_off += 1;
836
837                 if (cc == EI_CC_COPY_2 || cc == EI_CC_SKIP_2) {
838                         if (read_stream(in_fd, &t_cc_clu_count, EI_CC_PAYLOAD_LEN) !=
839                             (ssize_t)EI_CC_PAYLOAD_LEN) {
840                                 exfat_err("failed to read cc cluster count at %llu\n",
841                                           (unsigned long long)in_start_off);
842                                 ret = -EIO;
843                                 goto out;
844                         }
845                         cc_clu_count = le32_to_cpu(t_cc_clu_count);
846                         in_start_off += EI_CC_PAYLOAD_LEN;
847                 } else if (cc == EI_CC_COPY_1 || cc == EI_CC_SKIP_1) {
848                         cc_clu_count = 1;
849                 } else {
850                         exfat_err("unexpected cc %d at %llu\n",
851                                   cc, (unsigned long long)in_start_off);
852                         ret = -EINVAL;
853                         goto out;
854                 }
855
856                 if (cc == EI_CC_COPY_1 || cc == EI_CC_COPY_2) {
857                         end_clu = clu + cc_clu_count;
858                         while (clu < end_clu) {
859                                 if (read_stream(in_fd, ei->dump_bdesc[0].buffer,
860                                                 clus_size) != (ssize_t)clus_size) {
861                                         exfat_err("failed to read range %llu ~ %llu\n",
862                                                   (unsigned long long)in_start_off,
863                                                   (unsigned long long)in_start_off + clus_size);
864                                         ret = -EIO;
865                                         goto out;
866                                 }
867                                 if (pwrite(ei->out_fd, ei->dump_bdesc[0].buffer,
868                                            clus_size, out_start_off) != (ssize_t)clus_size) {
869                                         exfat_err("failed to write range %llu ~ %llu\n",
870                                                   (unsigned long long)out_start_off,
871                                                   (unsigned long long)out_start_off + clus_size);
872                                         ret = -EIO;
873                                         goto out;
874                                 }
875
876                                 out_start_off += clus_size;
877                                 in_start_off += clus_size;
878                                 clu++;
879                         }
880                 } else {
881                         out_start_off += (off_t)cc_clu_count * clus_size;
882                         in_start_off +=  (off_t)cc_clu_count * clus_size;
883                         if (lseek(ei->out_fd, out_start_off, SEEK_SET) == (off_t)-1) {
884                                 exfat_err("failed to seek to %llu\n",
885                                           (unsigned long long)out_start_off);
886                                 ret = -EIO;
887                                 goto out;
888                         }
889                         clu += cc_clu_count;
890                 }
891         }
892 out:
893         fsync(ei->out_fd);
894         exfat_free_buffer(ei->dump_bdesc, 2);
895         return ret;
896 }
897
898 int main(int argc, char * const argv[])
899 {
900         int err = 0, c;
901         const char *in_path, *out_path = NULL, *blkdev_path;
902         struct pbr *bs;
903         struct exfat_user_input ui;
904         off_t last_sect;
905         bool restore;
906
907         print_level = EXFAT_ERROR;
908
909         opterr = 0;
910         while ((c = getopt_long(argc, argv, "o:Vh", opts, NULL)) != EOF) {
911                 switch (c) {
912                 case 'o':
913                         out_path = optarg;
914                         break;
915                 case 'V':
916                         show_version();
917                         return 0;
918                 case 'h':
919                         /* Fall through */
920                 default:
921                         usage(argv[0]);
922                         break;
923                 }
924         }
925
926         show_version();
927         if (!(optind == argc - 1 && out_path) &&
928             !(optind == argc - 2 && !out_path))
929                 usage(argv[0]);
930
931         in_path = argv[optind++];
932         if (!out_path)
933                 out_path = argv[optind++];
934
935         if (!strcmp(in_path, "-")) {
936                 restore = true;
937                 blkdev_path = out_path;
938         } else {
939                 restore = false;
940                 blkdev_path = in_path;
941         }
942
943         memset(&ui, 0, sizeof(ui));
944         snprintf(ui.dev_name, sizeof(ui.dev_name), "%s", blkdev_path);
945         if (restore)
946                 ui.writeable = true;
947         else
948                 ui.writeable = false;
949
950         if (exfat_get_blk_dev_info(&ui, &ei.bdev)) {
951                 exfat_err("failed to open %s\n", ui.dev_name);
952                 return EXIT_FAILURE;
953         }
954
955         if (restore)
956                 return restore_from_stdin(&ei);
957
958         err = read_boot_sect(&ei.bdev, &bs);
959         if (err) {
960                 close(ei.bdev.dev_fd);
961                 return EXIT_FAILURE;
962         }
963
964         err = create_exfat2img(&ei, bs, out_path);
965         if (err)
966                 return EXIT_FAILURE;
967
968         if (!ei.is_stdout) {
969                 err = dump_sectors(&ei, 0, le32_to_cpu(ei.exfat->bs->bsx.clu_offset));
970                 if (err) {
971                         exfat_err("failed to dump boot sectors, fat\n");
972                         goto out;
973                 }
974
975                 last_sect = (off_t)le32_to_cpu(ei.exfat->bs->bsx.clu_offset) +
976                         (le32_to_cpu(ei.exfat->bs->bsx.clu_count) <<
977                          ei.exfat->bs->bsx.sect_per_clus_bits) - 1;
978                 err = dump_sectors(&ei, last_sect, last_sect + 1);
979                 if (err) {
980                         exfat_err("failed to dump last sector\n");
981                         goto out;
982                 }
983         }
984
985         err = dump_root(&ei);
986         if (err) {
987                 exfat_err("failed to dump root\n");
988                 goto out;
989         }
990
991         dump_filesystem(&ei);
992
993         if (ei.is_stdout) {
994                 err = dump_header(&ei);
995                 if (err)
996                         goto out;
997                 err = dump_to_stdout(&ei);
998                 if (err)
999                         goto out;
1000         } else {
1001                 err = fsync(ei.out_fd);
1002                 if (err) {
1003                         exfat_err("failed to fsync %s. %d\n", out_path, errno);
1004                         goto out;
1005                 }
1006                 close(ei.out_fd);
1007         }
1008
1009         printf("%ld files found, %ld directories dumped, %llu kbytes written\n",
1010                exfat_stat.file_count,
1011                exfat_stat.dir_count,
1012                (unsigned long long)DIV_ROUND_UP(exfat_stat.written_bytes, 1024));
1013
1014 out:
1015         free_exfat2img(&ei);
1016         return err == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1017 }