diff options
Diffstat (limited to 'source')
| -rw-r--r-- | source/cbz/mucbz.c | 6 | ||||
| -rw-r--r-- | source/fitz/archive.c | 2 | ||||
| -rw-r--r-- | source/fitz/untar.c | 235 |
3 files changed, 243 insertions, 0 deletions
diff --git a/source/cbz/mucbz.c b/source/cbz/mucbz.c index 17a881cc..8baea04f 100644 --- a/source/cbz/mucbz.c +++ b/source/cbz/mucbz.c @@ -256,6 +256,12 @@ cbz_recognize(fz_context *ctx, const char *magic) if ((ext && !fz_strcasecmp(ext, ".zip")) || !strcmp(magic, "zip") || !strcmp(magic, "application/zip")) return 100; + if ((ext && !fz_strcasecmp(ext, ".tar")) || !strcmp(magic, "tar") || + !strcmp(magic, "application/x-tar")) + return 100; + if ((ext && !fz_strcasecmp(ext, ".cbt")) || !strcmp(magic, "cbt") || + !strcmp(magic, "application/x-cbt")) + return 100; return 0; } diff --git a/source/fitz/archive.c b/source/fitz/archive.c index a61ceb01..5bd3434b 100644 --- a/source/fitz/archive.c +++ b/source/fitz/archive.c @@ -63,6 +63,8 @@ fz_open_archive_with_stream(fz_context *ctx, fz_stream *file) { if (fz_is_zip_archive(ctx, file)) arch = fz_open_zip_archive_with_stream(ctx, file); + else if (fz_is_tar_archive(ctx, file)) + arch = fz_open_tar_archive_with_stream(ctx, file); else fz_throw(ctx, FZ_ERROR_GENERIC, "cannot recognize archive"); } diff --git a/source/fitz/untar.c b/source/fitz/untar.c new file mode 100644 index 00000000..a364bf39 --- /dev/null +++ b/source/fitz/untar.c @@ -0,0 +1,235 @@ +#include "mupdf/fitz.h" + +typedef struct tar_entry_s tar_entry; +typedef struct fz_tar_archive_s fz_tar_archive; + +struct tar_entry_s +{ + char *name; + int offset, size; +}; + +struct fz_tar_archive_s +{ + fz_archive super; + + int count; + tar_entry *entries; +}; + +static inline int isoctdigit(char c) +{ + return c >= '0' && c <= '7'; +} + +static inline int otoi(const char *s) +{ + int value = 0; + + while (*s && isoctdigit(*s)) + { + value *= 8; + value += (*s) - '0'; + s++; + } + + return value; +} + +static void drop_tar_archive(fz_context *ctx, fz_archive *arch) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + int i; + for (i = 0; i < tar->count; ++i) + fz_free(ctx, tar->entries[i].name); + fz_free(ctx, tar->entries); +} + +static void ensure_tar_entries(fz_context *ctx, fz_tar_archive *tar) +{ + fz_stream *file = tar->super.file; + char name[100]; + char octsize[12]; + char typeflag; + int offset, blocks, size; + size_t n; + + tar->count = 0; + + fz_seek(ctx, file, 0, SEEK_SET); + + while (1) + { + offset = fz_tell(ctx, file); + n = fz_read(ctx, file, (unsigned char *) name, nelem(name)); + if (n < nelem(name)) + fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in zip entry name"); + name[nelem(name) - 1] = '\0'; + + if (strlen(name) == 0) + break; + + fz_seek(ctx, file, 24, 1); + n = fz_read(ctx, file, (unsigned char *) octsize, nelem(octsize)); + if (n < nelem(octsize)) + fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in zip entry size"); + size = otoi(octsize); + + fz_seek(ctx, file, 20, 1); + typeflag = fz_read_byte(ctx, file); + + fz_seek(ctx, file, 355, 1); + blocks = (size + 511) / 512; + fz_seek(ctx, file, blocks * 512, 1); + + if (typeflag != '0') + continue; + + tar->entries = fz_resize_array(ctx, tar->entries, tar->count + 1, sizeof *tar->entries); + + tar->entries[tar->count].name = fz_strdup(ctx, name); + tar->entries[tar->count].offset = offset; + tar->entries[tar->count].size = size; + + tar->count++; + } +} + +static tar_entry *lookup_tar_entry(fz_context *ctx, fz_tar_archive *tar, const char *name) +{ + int i; + for (i = 0; i < tar->count; i++) + if (!fz_strcasecmp(name, tar->entries[i].name)) + return &tar->entries[i]; + return NULL; +} + +static fz_stream *open_tar_entry(fz_context *ctx, fz_archive *arch, const char *name) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + fz_stream *file = tar->super.file; + tar_entry *ent; + + ent = lookup_tar_entry(ctx, tar, name); + if (!ent) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find named tar archive entry"); + + fz_seek(ctx, file, ent->offset + 512, 0); + return fz_open_null(ctx, file, ent->size, fz_tell(ctx, file)); +} + +static fz_buffer *read_tar_entry(fz_context *ctx, fz_archive *arch, const char *name) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + fz_stream *file = tar->super.file; + fz_buffer *ubuf; + tar_entry *ent; + + ent = lookup_tar_entry(ctx, tar, name); + if (!ent) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find named tar archive entry"); + + ubuf = fz_new_buffer(ctx, ent->size); + + fz_try(ctx) + { + fz_seek(ctx, file, ent->offset + 512, 0); + ubuf->len = fz_read(ctx, file, ubuf->data, ent->size); + if (ubuf->len != ent->size) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot read entire archive entry"); + } + fz_catch(ctx) + { + fz_drop_buffer(ctx, ubuf); + fz_rethrow(ctx); + } + + return ubuf; +} + +static int has_tar_entry(fz_context *ctx, fz_archive *arch, const char *name) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + tar_entry *ent = lookup_tar_entry(ctx, tar, name); + return ent != NULL; +} + +static const char *list_tar_entry(fz_context *ctx, fz_archive *arch, int idx) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + if (idx < 0 || idx >= tar->count) + return NULL; + return tar->entries[idx].name; +} + +static int count_tar_entries(fz_context *ctx, fz_archive *arch) +{ + fz_tar_archive *tar = (fz_tar_archive *) arch; + return tar->count; +} + +int +fz_is_tar_archive(fz_context *ctx, fz_stream *file) +{ + const unsigned char signature[6] = { 'u', 's', 't', 'a', 'r', ' ' }; + unsigned char data[6]; + size_t n; + + fz_seek(ctx, file, 257, 0); + n = fz_read(ctx, file, data, nelem(data)); + if (n != nelem(signature)) + return 0; + if (memcmp(data, signature, nelem(signature))) + return 0; + + return 1; +} + +fz_archive * +fz_open_tar_archive_with_stream(fz_context *ctx, fz_stream *file) +{ + fz_tar_archive *tar; + + if (!fz_is_tar_archive(ctx, file)) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot recognize tar archive"); + + tar = fz_new_archive(ctx, file, fz_tar_archive); + + fz_try(ctx) + { + tar->super.format = "tar"; + tar->super.count_entries = count_tar_entries; + tar->super.list_entry = list_tar_entry; + tar->super.has_entry = has_tar_entry; + tar->super.read_entry = read_tar_entry; + tar->super.open_entry = open_tar_entry; + tar->super.drop_archive = drop_tar_archive; + + ensure_tar_entries(ctx, tar); + } + fz_catch(ctx) + { + fz_drop_archive(ctx, &tar->super); + fz_rethrow(ctx); + } + + return &tar->super; +} + +fz_archive * +fz_open_tar_archive(fz_context *ctx, const char *filename) +{ + fz_archive *tar = NULL; + fz_stream *file; + + file = fz_open_file(ctx, filename); + + fz_try(ctx) + tar = fz_open_tar_archive_with_stream(ctx, file); + fz_always(ctx) + fz_drop_stream(ctx, file); + fz_catch(ctx) + fz_rethrow(ctx); + + return tar; +} |