exFAT file system implementation library.
Free exFAT implementation.
- Copyright (C) 2010-2014 Andrew Nayenko
+ Copyright (C) 2010-2016 Andrew Nayenko
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return true;
}
+static void decompress_upcase(uint16_t* output, const le16_t* source,
+ size_t size)
+{
+ size_t si;
+ size_t oi;
+
+ for (oi = 0; oi < EXFAT_UPCASE_CHARS; oi++)
+ output[oi] = oi;
+
+ for (si = 0, oi = 0; si < size && oi < EXFAT_UPCASE_CHARS; si++)
+ {
+ uint16_t ch = le16_to_cpu(source[si]);
+
+ if (ch == 0xffff && si + 1 < size) /* indicates a run */
+ oi += le16_to_cpu(source[++si]);
+ else
+ output[oi++] = ch;
+ }
+}
+
/*
* Reads one entry in directory at position pointed by iterator and fills
* node structure.
uint16_t reference_checksum = 0;
uint16_t actual_checksum = 0;
uint64_t valid_size = 0;
+ uint64_t upcase_size = 0;
+ le16_t* upcase_comp = NULL;
*node = NULL;
le32_to_cpu(upcase->start_cluster));
goto error;
}
- if (le64_to_cpu(upcase->size) == 0 ||
- le64_to_cpu(upcase->size) > 0xffff * sizeof(uint16_t) ||
- le64_to_cpu(upcase->size) % sizeof(uint16_t) != 0)
+ upcase_size = le64_to_cpu(upcase->size);
+ if (upcase_size == 0 ||
+ upcase_size > EXFAT_UPCASE_CHARS * sizeof(uint16_t) ||
+ upcase_size % sizeof(uint16_t) != 0)
{
exfat_error("bad upcase table size (%"PRIu64" bytes)",
- le64_to_cpu(upcase->size));
+ upcase_size);
goto error;
}
- ef->upcase = malloc(le64_to_cpu(upcase->size));
- if (ef->upcase == NULL)
+ upcase_comp = malloc(upcase_size);
+ if (upcase_comp == NULL)
{
exfat_error("failed to allocate upcase table (%"PRIu64" bytes)",
- le64_to_cpu(upcase->size));
+ upcase_size);
rc = -ENOMEM;
goto error;
}
- ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
- if (exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
+ /* read compressed upcase table */
+ if (exfat_pread(ef->dev, upcase_comp, upcase_size,
exfat_c2o(ef, le32_to_cpu(upcase->start_cluster))) < 0)
{
+ free(upcase_comp);
exfat_error("failed to read upper case table "
"(%"PRIu64" bytes starting at cluster %#x)",
- le64_to_cpu(upcase->size),
+ upcase_size,
le32_to_cpu(upcase->start_cluster));
goto error;
}
+
+ /* decompress upcase table */
+ ef->upcase = calloc(EXFAT_UPCASE_CHARS, sizeof(uint16_t));
+ if (ef->upcase == NULL)
+ {
+ free(upcase_comp);
+ exfat_error("failed to allocate decompressed upcase table");
+ rc = -ENOMEM;
+ goto error;
+ }
+ decompress_upcase(ef->upcase, upcase_comp,
+ upcase_size / sizeof(uint16_t));
+ free(upcase_comp);
break;
case EXFAT_ENTRY_BITMAP:
break;
default:
- if (entry->type & EXFAT_ENTRY_VALID)
+ if (!(entry->type & EXFAT_ENTRY_VALID))
+ break; /* deleted entry, ignore it */
+ if (!(entry->type & EXFAT_ENTRY_OPTIONAL))
{
- exfat_error("unknown entry type 0x%hhx", entry->type);
+ exfat_error("unknown entry type %#hhx", entry->type);
goto error;
}
+ /* optional entry, warn and skip */
+ exfat_warn("unknown entry type %#hhx", entry->type);
+ if (continuations == 0)
+ {
+ exfat_error("unexpected continuation");
+ goto error;
+ }
+ --continuations;
break;
}
}
node->flags &= ~EXFAT_ATTRIB_DIRTY;
- return 0;
+ return exfat_flush(ef);
}
static bool erase_entry(struct exfat* ef, struct exfat_node* node)
int rc;
struct exfat_node* node;
- rc = create(ef, path, EXFAT_ATTRIB_ARCH | EXFAT_ATTRIB_DIR);
+ rc = create(ef, path, EXFAT_ATTRIB_DIR);
if (rc != 0)
return rc;
rc = exfat_lookup(ef, &node, path);
}
exfat_put_node(ef, existing);
if (rc != 0)
+ {
+ /* free clusters even if something went wrong; overwise they
+ will be just lost */
+ exfat_cleanup_node(ef, existing);
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rc = exfat_cleanup_node(ef, existing);
+ if (rc != 0)
{
exfat_put_node(ef, dir);
exfat_put_node(ef, node);