archive.h

Go to the documentation of this file.

// Copyright (C) 2004-2024 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_ARCHIVE_H
#define MUPDF_FITZ_ARCHIVE_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/stream.h"
#include "mupdf/fitz/tree.h"
 
/* PUBLIC API */

 
typedef struct fz_archive fz_archive;

fz_archive *fz_open_archive(fz_context *ctx, const char *filename);

fz_archive *fz_open_archive_with_stream(fz_context *ctx, fz_stream *file);

fz_archive *fz_try_open_archive_with_stream(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_directory(fz_context *ctx, const char *path);
 

int fz_is_directory(fz_context *ctx, const char *path);

void fz_drop_archive(fz_context *ctx, fz_archive *arch);

fz_archive *
fz_keep_archive(fz_context *ctx, fz_archive *arch);

const char *fz_archive_format(fz_context *ctx, fz_archive *arch);

int fz_count_archive_entries(fz_context *ctx, fz_archive *arch);

const char *fz_list_archive_entry(fz_context *ctx, fz_archive *arch, int idx);

int fz_has_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);

fz_stream *fz_open_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);

fz_stream *fz_try_open_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);

fz_buffer *fz_read_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);

fz_buffer *fz_try_read_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);


int fz_is_tar_archive(fz_context *ctx, fz_stream *file);

int fz_is_libarchive_archive(fz_context *ctx, fz_stream *file);

int fz_is_cfb_archive(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_tar_archive(fz_context *ctx, const char *filename);

fz_archive *fz_open_tar_archive_with_stream(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_libarchive_archive(fz_context *ctx, const char *filename);

fz_archive *fz_open_libarchive_archive_with_stream(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_cfb_archive(fz_context *ctx, const char *filename);

fz_archive *fz_open_cfb_archive_with_stream(fz_context *ctx, fz_stream *file);


int fz_is_zip_archive(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_zip_archive(fz_context *ctx, const char *path);
 

fz_archive *fz_open_zip_archive_with_stream(fz_context *ctx, fz_stream *file);

fz_archive *fz_open_zip_archive_with_memory(fz_context *ctx, const unsigned char *data, size_t size);

 
typedef struct fz_zip_writer fz_zip_writer;

fz_zip_writer *fz_new_zip_writer(fz_context *ctx, const char *filename);

fz_zip_writer *fz_new_zip_writer_with_output(fz_context *ctx, fz_output *out);
 

void fz_write_zip_entry(fz_context *ctx, fz_zip_writer *zip, const char *name, fz_buffer *buf, int compress);

void fz_close_zip_writer(fz_context *ctx, fz_zip_writer *zip);

void fz_drop_zip_writer(fz_context *ctx, fz_zip_writer *zip);

fz_archive *fz_new_tree_archive(fz_context *ctx, fz_tree *tree);

void fz_tree_archive_add_buffer(fz_context *ctx, fz_archive *arch_, const char *name, fz_buffer *buf);

void fz_tree_archive_add_data(fz_context *ctx, fz_archive *arch_, const char *name, const void *data, size_t size);

fz_archive *fz_new_multi_archive(fz_context *ctx);

void fz_mount_multi_archive(fz_context *ctx, fz_archive *arch_, fz_archive *sub, const char *path);
 
typedef int (fz_recognize_archive_fn)(fz_context *, fz_stream *);
typedef fz_archive *(fz_open_archive_fn)(fz_context *, fz_stream *);
 
typedef struct
{
    fz_recognize_archive_fn *recognize;
    fz_open_archive_fn *open;
}
fz_archive_handler;
 
FZ_DATA extern const fz_archive_handler fz_libarchive_archive_handler;
 
void fz_register_archive_handler(fz_context *ctx, const fz_archive_handler *handler);

 
struct fz_archive
{
    int refs;
    fz_stream *file;
 
    const char *format;
 
    void (*drop_archive)(fz_context *ctx, fz_archive *arch);
    int (*count_entries)(fz_context *ctx, fz_archive *arch);
    const char *(*list_entry)(fz_context *ctx, fz_archive *arch, int idx);
    int (*has_entry)(fz_context *ctx, fz_archive *arch, const char *name);
    fz_buffer *(*read_entry)(fz_context *ctx, fz_archive *arch, const char *name);
    fz_stream *(*open_entry)(fz_context *ctx, fz_archive *arch, const char *name);
};
 
fz_archive *fz_new_archive_of_size(fz_context *ctx, fz_stream *file, int size);
 
#define fz_new_derived_archive(C,F,M) \
    ((M*)Memento_label(fz_new_archive_of_size(C, F, sizeof(M)), #M))
 
 
 
#endif