1/////////////////////////////////////////////////////////////////////////////// 2// 3/// \file common.h 4/// \brief Definitions common to the whole liblzma library 5// 6// Author: Lasse Collin 7// 8// This file has been put into the public domain. 9// You can do whatever you want with this file. 10// 11/////////////////////////////////////////////////////////////////////////////// 12 13#ifndef LZMA_COMMON_H 14#define LZMA_COMMON_H 15 16#include "sysdefs.h" 17#include "mythread.h" 18#include "tuklib_integer.h" 19 20#if defined(_WIN32) || defined(__CYGWIN__) 21# ifdef DLL_EXPORT 22# define LZMA_API_EXPORT __declspec(dllexport) 23# else 24# define LZMA_API_EXPORT 25# endif 26// Don't use ifdef or defined() below. 27#elif HAVE_VISIBILITY 28# define LZMA_API_EXPORT __attribute__((__visibility__("default"))) 29#else 30# define LZMA_API_EXPORT 31#endif 32 33#define LZMA_API(type) LZMA_API_EXPORT type LZMA_API_CALL 34 35#include "lzma.h" 36 37// These allow helping the compiler in some often-executed branches, whose 38// result is almost always the same. 39#ifdef __GNUC__ 40# define likely(expr) __builtin_expect(expr, true) 41# define unlikely(expr) __builtin_expect(expr, false) 42#else 43# define likely(expr) (expr) 44# define unlikely(expr) (expr) 45#endif 46 47 48/// Size of temporary buffers needed in some filters 49#define LZMA_BUFFER_SIZE 4096 50 51 52/// Starting value for memory usage estimates. Instead of calculating size 53/// of _every_ structure and taking into account malloc() overhead etc., we 54/// add a base size to all memory usage estimates. It's not very accurate 55/// but should be easily good enough. 56#define LZMA_MEMUSAGE_BASE (UINT64_C(1) << 15) 57 58/// Start of internal Filter ID space. These IDs must never be used 59/// in Streams. 60#define LZMA_FILTER_RESERVED_START (LZMA_VLI_C(1) << 62) 61 62 63/// Supported flags that can be passed to lzma_stream_decoder() 64/// or lzma_auto_decoder(). 65#define LZMA_SUPPORTED_FLAGS \ 66 ( LZMA_TELL_NO_CHECK \ 67 | LZMA_TELL_UNSUPPORTED_CHECK \ 68 | LZMA_TELL_ANY_CHECK \ 69 | LZMA_CONCATENATED ) 70 71 72/// Type of encoder/decoder specific data; the actual structure is defined 73/// differently in different coders. 74typedef struct lzma_coder_s lzma_coder; 75 76typedef struct lzma_next_coder_s lzma_next_coder; 77 78typedef struct lzma_filter_info_s lzma_filter_info; 79 80 81/// Type of a function used to initialize a filter encoder or decoder 82typedef lzma_ret (*lzma_init_function)( 83 lzma_next_coder *next, lzma_allocator *allocator, 84 const lzma_filter_info *filters); 85 86/// Type of a function to do some kind of coding work (filters, Stream, 87/// Block encoders/decoders etc.). Some special coders use don't use both 88/// input and output buffers, but for simplicity they still use this same 89/// function prototype. 90typedef lzma_ret (*lzma_code_function)( 91 lzma_coder *coder, lzma_allocator *allocator, 92 const uint8_t *restrict in, size_t *restrict in_pos, 93 size_t in_size, uint8_t *restrict out, 94 size_t *restrict out_pos, size_t out_size, 95 lzma_action action); 96 97/// Type of a function to free the memory allocated for the coder 98typedef void (*lzma_end_function)( 99 lzma_coder *coder, lzma_allocator *allocator); 100 101 102/// Raw coder validates and converts an array of lzma_filter structures to 103/// an array of lzma_filter_info structures. This array is used with 104/// lzma_next_filter_init to initialize the filter chain. 105struct lzma_filter_info_s { 106 /// Filter ID. This is used only by the encoder 107 /// with lzma_filters_update(). 108 lzma_vli id; 109 110 /// Pointer to function used to initialize the filter. 111 /// This is NULL to indicate end of array. 112 lzma_init_function init; 113 114 /// Pointer to filter's options structure 115 void *options; 116}; 117 118 119/// Hold data and function pointers of the next filter in the chain. 120struct lzma_next_coder_s { 121 /// Pointer to coder-specific data 122 lzma_coder *coder; 123 124 /// Filter ID. This is LZMA_VLI_UNKNOWN when this structure doesn't 125 /// point to a filter coder. 126 lzma_vli id; 127 128 /// "Pointer" to init function. This is never called here. 129 /// We need only to detect if we are initializing a coder 130 /// that was allocated earlier. See lzma_next_coder_init and 131 /// lzma_next_strm_init macros in this file. 132 uintptr_t init; 133 134 /// Pointer to function to do the actual coding 135 lzma_code_function code; 136 137 /// Pointer to function to free lzma_next_coder.coder. This can 138 /// be NULL; in that case, lzma_free is called to free 139 /// lzma_next_coder.coder. 140 lzma_end_function end; 141 142 /// Pointer to function to return the type of the integrity check. 143 /// Most coders won't support this. 144 lzma_check (*get_check)(const lzma_coder *coder); 145 146 /// Pointer to function to get and/or change the memory usage limit. 147 /// If new_memlimit == 0, the limit is not changed. 148 lzma_ret (*memconfig)(lzma_coder *coder, uint64_t *memusage, 149 uint64_t *old_memlimit, uint64_t new_memlimit); 150 151 /// Update the filter-specific options or the whole filter chain 152 /// in the encoder. 153 lzma_ret (*update)(lzma_coder *coder, lzma_allocator *allocator, 154 const lzma_filter *filters, 155 const lzma_filter *reversed_filters); 156}; 157 158 159/// Macro to initialize lzma_next_coder structure 160#define LZMA_NEXT_CODER_INIT \ 161 (lzma_next_coder){ \ 162 .coder = NULL, \ 163 .init = (uintptr_t)(NULL), \ 164 .id = LZMA_VLI_UNKNOWN, \ 165 .code = NULL, \ 166 .end = NULL, \ 167 .get_check = NULL, \ 168 .memconfig = NULL, \ 169 .update = NULL, \ 170 } 171 172 173/// Internal data for lzma_strm_init, lzma_code, and lzma_end. A pointer to 174/// this is stored in lzma_stream. 175struct lzma_internal_s { 176 /// The actual coder that should do something useful 177 lzma_next_coder next; 178 179 /// Track the state of the coder. This is used to validate arguments 180 /// so that the actual coders can rely on e.g. that LZMA_SYNC_FLUSH 181 /// is used on every call to lzma_code until next.code has returned 182 /// LZMA_STREAM_END. 183 enum { 184 ISEQ_RUN, 185 ISEQ_SYNC_FLUSH, 186 ISEQ_FULL_FLUSH, 187 ISEQ_FINISH, 188 ISEQ_END, 189 ISEQ_ERROR, 190 } sequence; 191 192 /// A copy of lzma_stream avail_in. This is used to verify that the 193 /// amount of input doesn't change once e.g. LZMA_FINISH has been 194 /// used. 195 size_t avail_in; 196 197 /// Indicates which lzma_action values are allowed by next.code. 198 bool supported_actions[4]; 199 200 /// If true, lzma_code will return LZMA_BUF_ERROR if no progress was 201 /// made (no input consumed and no output produced by next.code). 202 bool allow_buf_error; 203}; 204 205 206/// Allocates memory 207extern void *lzma_alloc(size_t size, lzma_allocator *allocator) 208 lzma_attribute((__malloc__)) lzma_attr_alloc_size(1); 209 210/// Frees memory 211extern void lzma_free(void *ptr, lzma_allocator *allocator); 212 213 214/// Allocates strm->internal if it is NULL, and initializes *strm and 215/// strm->internal. This function is only called via lzma_next_strm_init macro. 216extern lzma_ret lzma_strm_init(lzma_stream *strm); 217 218/// Initializes the next filter in the chain, if any. This takes care of 219/// freeing the memory of previously initialized filter if it is different 220/// than the filter being initialized now. This way the actual filter 221/// initialization functions don't need to use lzma_next_coder_init macro. 222extern lzma_ret lzma_next_filter_init(lzma_next_coder *next, 223 lzma_allocator *allocator, const lzma_filter_info *filters); 224 225/// Update the next filter in the chain, if any. This checks that 226/// the application is not trying to change the Filter IDs. 227extern lzma_ret lzma_next_filter_update( 228 lzma_next_coder *next, lzma_allocator *allocator, 229 const lzma_filter *reversed_filters); 230 231/// Frees the memory allocated for next->coder either using next->end or, 232/// if next->end is NULL, using lzma_free. 233extern void lzma_next_end(lzma_next_coder *next, lzma_allocator *allocator); 234 235 236/// Copy as much data as possible from in[] to out[] and update *in_pos 237/// and *out_pos accordingly. Returns the number of bytes copied. 238extern size_t lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos, 239 size_t in_size, uint8_t *restrict out, 240 size_t *restrict out_pos, size_t out_size); 241 242 243/// \brief Return if expression doesn't evaluate to LZMA_OK 244/// 245/// There are several situations where we want to return immediately 246/// with the value of expr if it isn't LZMA_OK. This macro shortens 247/// the code a little. 248#define return_if_error(expr) \ 249do { \ 250 const lzma_ret ret_ = (expr); \ 251 if (ret_ != LZMA_OK) \ 252 return ret_; \ 253} while (0) 254 255 256/// If next isn't already initialized, free the previous coder. Then mark 257/// that next is _possibly_ initialized for the coder using this macro. 258/// "Possibly" means that if e.g. allocation of next->coder fails, the 259/// structure isn't actually initialized for this coder, but leaving 260/// next->init to func is still OK. 261#define lzma_next_coder_init(func, next, allocator) \ 262do { \ 263 if ((uintptr_t)(func) != (next)->init) \ 264 lzma_next_end(next, allocator); \ 265 (next)->init = (uintptr_t)(func); \ 266} while (0) 267 268 269/// Initializes lzma_strm and calls func() to initialize strm->internal->next. 270/// (The function being called will use lzma_next_coder_init()). If 271/// initialization fails, memory that wasn't freed by func() is freed 272/// along strm->internal. 273#define lzma_next_strm_init(func, strm, ...) \ 274do { \ 275 return_if_error(lzma_strm_init(strm)); \ 276 const lzma_ret ret_ = func(&(strm)->internal->next, \ 277 (strm)->allocator, __VA_ARGS__); \ 278 if (ret_ != LZMA_OK) { \ 279 lzma_end(strm); \ 280 return ret_; \ 281 } \ 282} while (0) 283 284#endif 285