/*- * Copyright (c) 2003-2004 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ */ #ifndef ARCHIVE_PRIVATE_H_INCLUDED #define ARCHIVE_PRIVATE_H_INCLUDED #include "archive.h" #include "archive_string.h" #define ARCHIVE_WRITE_MAGIC (0xb0c5c0deU) #define ARCHIVE_READ_MAGIC (0xdeb0c5U) /* * This is used by archive_extract to keep track of non-writable * directories so that they can be initially restored writable, then * fixed up at end. This also handles mtime/atime fixups. */ struct archive_extract_dir_entry; struct archive { /* * The magic/state values are used to sanity-check the * client's usage. If an API function is called at a * rediculous time, or the client passes us an invalid * pointer, these values allow me to catch that. */ unsigned magic; unsigned state; struct archive_entry *entry; /* Utility: Pointer to a block of nulls. */ const char *nulls; size_t null_length; /* * Used to limit reads of entry data. Eventually, each reader * will be able to register it's own read_data routine and these * will move into the per-format data for the formats that use them. */ off_t entry_bytes_remaining; off_t entry_padding; /* Skip this much after entry data. */ uid_t user_uid; /* UID of current user. */ /* Callbacks to open/read/write/close archive stream. */ archive_open_callback *client_opener; archive_read_callback *client_reader; archive_write_callback *client_writer; archive_close_callback *client_closer; void *client_data; /* * Blocking information. Note that bytes_in_last_block is * misleadingly named; I should find a better name. These * control the final output from all compressors, including * compression_none. */ int bytes_per_block; int bytes_in_last_block; /* * These control whether data within a gzip/bzip2 compressed * stream gets padded or not. If pad_uncompressed is set, * the data will be padded to a full block before being * compressed. The pad_uncompressed_byte determines the value * that will be used for padding. Note that these have no * effect on compression "none." */ int pad_uncompressed; int pad_uncompressed_byte; /* TODO: Support this. */ /* Position in UNCOMPRESSED data stream. */ off_t file_position; /* File offset of beginning of most recently-read header. */ off_t header_position; /* * Detection functions for decompression: bid functions are * given a block of data from the beginning of the stream and * can bid on whether or not they support the data stream. * General guideline: bid the number of bits that you actually * test, e.g., 16 if you test a 2-byte magic value. The * highest bidder will have their init function invoked, which * can set up pointers to specific handlers. * * On write, the client just invokes an archive_write_set function * which sets up the data here directly. */ int compression_code; /* Currently active compression. */ const char *compression_name; struct { int (*bid)(const void *buff, size_t); int (*init)(struct archive *, const void *buff, size_t); } decompressors[4]; /* Read/write data stream (with compression). */ void *compression_data; /* Data for (de)compressor. */ int (*compression_init)(struct archive *); /* Initialize. */ int (*compression_finish)(struct archive *); ssize_t (*compression_write)(struct archive *, const void *, size_t); /* * Read uses a peek/consume I/O model: the decompression code * returns a pointer to the requested block and advances the * file position only when requested by a consume call. This * reduces copying and also simplifies look-ahead for format * detection. */ ssize_t (*compression_read_ahead)(struct archive *, const void **, size_t request); ssize_t (*compression_read_consume)(struct archive *, size_t); /* * Format detection is mostly the same as compression * detection, with two significant differences: The bidders * use the read_ahead calls above to examine the stream rather * than having the supervisor hand them a block of data to * examine, and the auction is repeated for every header. * Winning bidders should set the archive_format and * archive_format_name appropriately. Bid routines should * check archive_format and decline to bid if the format of * the last header was incompatible. * * Again, write support is considerably simpler because there's * no need for an auction. */ int archive_format; const char *archive_format_name; struct archive_format_descriptor { int (*bid)(struct archive *); int (*read_header)(struct archive *, struct archive_entry *); int (*cleanup)(struct archive *); void *format_data; /* Format-specific data for readers. */ } formats[4]; struct archive_format_descriptor *format; /* Active format. */ /* * Storage for format-specific data. Note that there can be * multiple format readers active at one time, so we need to * allow for multiple format readers to have their data * available. The pformat_data slot here is the solution: on * read, it is gauranteed to always point to a void* variable * that the format can use. */ void **pformat_data; /* Pointer to current format_data. */ void *format_data; /* Used by writers. */ /* * Pointers to format-specific functions. On read, these are * initialized in the bid process. On write, they're initialized by * archive_write_set_format_XXX() calls. */ int (*format_init)(struct archive *); /* Only used on write. */ int (*format_finish)(struct archive *); int (*format_finish_entry)(struct archive *); int (*format_write_header)(struct archive *, struct archive_entry *); int (*format_write_data)(struct archive *, const void *buff, size_t); /* * Various information needed by archive_extract. */ struct archive_string extract_mkdirpath; struct archive_extract_dir_entry *archive_extract_dir_list; void (*cleanup_archive_extract)(struct archive *); int archive_error_number; const char *error; struct archive_string error_string; }; /* Utility function to format a USTAR header into a buffer. */ int __archive_write_format_header_ustar(struct archive *, char buff[512], struct archive_entry *); #define ARCHIVE_STATE_ANY 0xFFFFU #define ARCHIVE_STATE_NEW 1U #define ARCHIVE_STATE_HEADER 2U #define ARCHIVE_STATE_DATA 4U #define ARCHIVE_STATE_EOF 8U #define ARCHIVE_STATE_CLOSED 0x10U #define ARCHIVE_STATE_FATAL 0x8000U /* Check magic value and state; exit if it isn't valid. */ void __archive_check_magic(struct archive *, unsigned magic, unsigned state, const char *func); #define archive_check_magic(a,m,s) \ __archive_check_magic((a), (m), (s), __func__) int __archive_read_register_format(struct archive *a, void *format_data, int (*bid)(struct archive *), int (*read_header)(struct archive *, struct archive_entry *), int (*cleanup)(struct archive *)); int __archive_read_register_compression(struct archive *a, int (*bid)(const void *, size_t), int (*init)(struct archive *, const void *, size_t)); #define err_combine(a,b) ((a) < (b) ? (a) : (b)) #endif