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// LZMA_API_EXPORT is used to mark the exported API functions. 21// It's used to define the LZMA_API macro. 22// 23// lzma_attr_visibility_hidden is used for marking *declarations* of extern 24// variables that are internal to liblzma (-fvisibility=hidden alone is 25// enough to hide the *definitions*). Such markings allow slightly more 26// efficient code to accesses those variables in ELF shared libraries. 27#if defined(_WIN32) || defined(__CYGWIN__) 28# ifdef DLL_EXPORT 29# define LZMA_API_EXPORT __declspec(dllexport) 30# else 31# define LZMA_API_EXPORT 32# endif 33# define lzma_attr_visibility_hidden 34// Don't use ifdef or defined() below. 35#elif HAVE_VISIBILITY 36# define LZMA_API_EXPORT __attribute__((__visibility__("default"))) 37# define lzma_attr_visibility_hidden \ 38 __attribute__((__visibility__("hidden"))) 39#else 40# define LZMA_API_EXPORT 41# define lzma_attr_visibility_hidden 42#endif 43 44#define LZMA_API(type) LZMA_API_EXPORT type LZMA_API_CALL 45 46#include "lzma.h" 47 48// This is for detecting modern GCC and Clang attributes 49// like __symver__ in GCC >= 10. 50#ifdef __has_attribute 51# define lzma_has_attribute(attr) __has_attribute(attr) 52#else 53# define lzma_has_attribute(attr) 0 54#endif 55 56// The extra symbol versioning in the C files may only be used when 57// building a shared library. If HAVE_SYMBOL_VERSIONS_LINUX is defined 58// to 2 then symbol versioning is done only if also PIC is defined. 59// By default Libtool defines PIC when building a shared library and 60// doesn't define it when building a static library but it can be 61// overridden with --with-pic and --without-pic. configure let's rely 62// on PIC if neither --with-pic or --without-pic was used. 63#if defined(HAVE_SYMBOL_VERSIONS_LINUX) \ 64 && (HAVE_SYMBOL_VERSIONS_LINUX == 2 && !defined(PIC)) 65# undef HAVE_SYMBOL_VERSIONS_LINUX 66#endif 67 68#ifdef HAVE_SYMBOL_VERSIONS_LINUX 69// To keep link-time optimization (LTO, -flto) working with GCC, 70// the __symver__ attribute must be used instead of __asm__(".symver ..."). 71// Otherwise the symbol versions may be lost, resulting in broken liblzma 72// that has wrong default versions in the exported symbol list! 73// The attribute was added in GCC 10; LTO with older GCC is not supported. 74// 75// To keep -Wmissing-prototypes happy, use LZMA_SYMVER_API only with function 76// declarations (including those with __alias__ attribute) and LZMA_API with 77// the function definitions. This means a little bit of silly copy-and-paste 78// between declarations and definitions though. 79// 80// As of GCC 12.2, the __symver__ attribute supports only @ and @@ but the 81// very convenient @@@ isn't supported (it's supported by GNU assembler 82// since 2000). When using @@ instead of @@@, the internal name must not be 83// the same as the external name to avoid problems in some situations. This 84// is why "#define foo_52 foo" is needed for the default symbol versions. 85// 86// __has_attribute is supported before GCC 10 and it is supported in Clang 14 87// too (which doesn't support __symver__) so use it to detect if __symver__ 88// is available. This should be far more reliable than looking at compiler 89// version macros as nowadays especially __GNUC__ is defined by many compilers. 90# if lzma_has_attribute(__symver__) 91# define LZMA_SYMVER_API(extnamever, type, intname) \ 92 extern __attribute__((__symver__(extnamever))) \ 93 LZMA_API(type) intname 94# else 95# define LZMA_SYMVER_API(extnamever, type, intname) \ 96 __asm__(".symver " #intname "," extnamever); \ 97 extern LZMA_API(type) intname 98# endif 99#endif 100 101// MSVC has __forceinline which shouldn't be combined with the inline keyword 102// (results in a warning). 103// 104// GCC 3.1 added always_inline attribute so we don't need to check 105// for __GNUC__ version. Similarly, all relevant Clang versions 106// support it (at least Clang 3.0.0 does already). 107// Other compilers might support too which also support __has_attribute 108// (Solaris Studio) so do that check too. 109#if defined(_MSC_VER) 110# define lzma_always_inline __forceinline 111#elif defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) \ 112 || lzma_has_attribute(__always_inline__) 113# define lzma_always_inline inline __attribute__((__always_inline__)) 114#else 115# define lzma_always_inline inline 116#endif 117 118// These allow helping the compiler in some often-executed branches, whose 119// result is almost always the same. 120#ifdef __GNUC__ 121# define likely(expr) __builtin_expect(expr, true) 122# define unlikely(expr) __builtin_expect(expr, false) 123#else 124# define likely(expr) (expr) 125# define unlikely(expr) (expr) 126#endif 127 128 129/// Size of temporary buffers needed in some filters 130#define LZMA_BUFFER_SIZE 4096 131 132 133/// Maximum number of worker threads within one multithreaded component. 134/// The limit exists solely to make it simpler to prevent integer overflows 135/// when allocating structures etc. This should be big enough for now... 136/// the code won't scale anywhere close to this number anyway. 137#define LZMA_THREADS_MAX 16384 138 139 140/// Starting value for memory usage estimates. Instead of calculating size 141/// of _every_ structure and taking into account malloc() overhead etc., we 142/// add a base size to all memory usage estimates. It's not very accurate 143/// but should be easily good enough. 144#define LZMA_MEMUSAGE_BASE (UINT64_C(1) << 15) 145 146/// Start of internal Filter ID space. These IDs must never be used 147/// in Streams. 148#define LZMA_FILTER_RESERVED_START (LZMA_VLI_C(1) << 62) 149 150 151/// Supported flags that can be passed to lzma_stream_decoder(), 152/// lzma_auto_decoder(), or lzma_stream_decoder_mt(). 153#define LZMA_SUPPORTED_FLAGS \ 154 ( LZMA_TELL_NO_CHECK \ 155 | LZMA_TELL_UNSUPPORTED_CHECK \ 156 | LZMA_TELL_ANY_CHECK \ 157 | LZMA_IGNORE_CHECK \ 158 | LZMA_CONCATENATED \ 159 | LZMA_FAIL_FAST ) 160 161 162/// Largest valid lzma_action value as unsigned integer. 163#define LZMA_ACTION_MAX ((unsigned int)(LZMA_FULL_BARRIER)) 164 165 166/// Special return value (lzma_ret) to indicate that a timeout was reached 167/// and lzma_code() must not return LZMA_BUF_ERROR. This is converted to 168/// LZMA_OK in lzma_code(). 169#define LZMA_TIMED_OUT LZMA_RET_INTERNAL1 170 171/// Special return value (lzma_ret) for use in stream_decoder_mt.c to 172/// indicate Index was detected instead of a Block Header. 173#define LZMA_INDEX_DETECTED LZMA_RET_INTERNAL2 174 175 176typedef struct lzma_next_coder_s lzma_next_coder; 177 178typedef struct lzma_filter_info_s lzma_filter_info; 179 180 181/// Type of a function used to initialize a filter encoder or decoder 182typedef lzma_ret (*lzma_init_function)( 183 lzma_next_coder *next, const lzma_allocator *allocator, 184 const lzma_filter_info *filters); 185 186/// Type of a function to do some kind of coding work (filters, Stream, 187/// Block encoders/decoders etc.). Some special coders use don't use both 188/// input and output buffers, but for simplicity they still use this same 189/// function prototype. 190typedef lzma_ret (*lzma_code_function)( 191 void *coder, const lzma_allocator *allocator, 192 const uint8_t *restrict in, size_t *restrict in_pos, 193 size_t in_size, uint8_t *restrict out, 194 size_t *restrict out_pos, size_t out_size, 195 lzma_action action); 196 197/// Type of a function to free the memory allocated for the coder 198typedef void (*lzma_end_function)( 199 void *coder, const lzma_allocator *allocator); 200 201 202/// Raw coder validates and converts an array of lzma_filter structures to 203/// an array of lzma_filter_info structures. This array is used with 204/// lzma_next_filter_init to initialize the filter chain. 205struct lzma_filter_info_s { 206 /// Filter ID. This can be used to share the same initiazation 207 /// function *and* data structures with different Filter IDs 208 /// (LZMA_FILTER_LZMA1EXT does it), and also by the encoder 209 /// with lzma_filters_update() if filter chain is updated 210 /// in the middle of a raw stream or Block (LZMA_SYNC_FLUSH). 211 lzma_vli id; 212 213 /// Pointer to function used to initialize the filter. 214 /// This is NULL to indicate end of array. 215 lzma_init_function init; 216 217 /// Pointer to filter's options structure 218 void *options; 219}; 220 221 222/// Hold data and function pointers of the next filter in the chain. 223struct lzma_next_coder_s { 224 /// Pointer to coder-specific data 225 void *coder; 226 227 /// Filter ID. This is LZMA_VLI_UNKNOWN when this structure doesn't 228 /// point to a filter coder. 229 lzma_vli id; 230 231 /// "Pointer" to init function. This is never called here. 232 /// We need only to detect if we are initializing a coder 233 /// that was allocated earlier. See lzma_next_coder_init and 234 /// lzma_next_strm_init macros in this file. 235 uintptr_t init; 236 237 /// Pointer to function to do the actual coding 238 lzma_code_function code; 239 240 /// Pointer to function to free lzma_next_coder.coder. This can 241 /// be NULL; in that case, lzma_free is called to free 242 /// lzma_next_coder.coder. 243 lzma_end_function end; 244 245 /// Pointer to a function to get progress information. If this is NULL, 246 /// lzma_stream.total_in and .total_out are used instead. 247 void (*get_progress)(void *coder, 248 uint64_t *progress_in, uint64_t *progress_out); 249 250 /// Pointer to function to return the type of the integrity check. 251 /// Most coders won't support this. 252 lzma_check (*get_check)(const void *coder); 253 254 /// Pointer to function to get and/or change the memory usage limit. 255 /// If new_memlimit == 0, the limit is not changed. 256 lzma_ret (*memconfig)(void *coder, uint64_t *memusage, 257 uint64_t *old_memlimit, uint64_t new_memlimit); 258 259 /// Update the filter-specific options or the whole filter chain 260 /// in the encoder. 261 lzma_ret (*update)(void *coder, const lzma_allocator *allocator, 262 const lzma_filter *filters, 263 const lzma_filter *reversed_filters); 264 265 /// Set how many bytes of output this coder may produce at maximum. 266 /// On success LZMA_OK must be returned. 267 /// If the filter chain as a whole cannot support this feature, 268 /// this must return LZMA_OPTIONS_ERROR. 269 /// If no input has been given to the coder and the requested limit 270 /// is too small, this must return LZMA_BUF_ERROR. If input has been 271 /// seen, LZMA_OK is allowed too. 272 lzma_ret (*set_out_limit)(void *coder, uint64_t *uncomp_size, 273 uint64_t out_limit); 274}; 275 276 277/// Macro to initialize lzma_next_coder structure 278#define LZMA_NEXT_CODER_INIT \ 279 (lzma_next_coder){ \ 280 .coder = NULL, \ 281 .init = (uintptr_t)(NULL), \ 282 .id = LZMA_VLI_UNKNOWN, \ 283 .code = NULL, \ 284 .end = NULL, \ 285 .get_progress = NULL, \ 286 .get_check = NULL, \ 287 .memconfig = NULL, \ 288 .update = NULL, \ 289 .set_out_limit = NULL, \ 290 } 291 292 293/// Internal data for lzma_strm_init, lzma_code, and lzma_end. A pointer to 294/// this is stored in lzma_stream. 295struct lzma_internal_s { 296 /// The actual coder that should do something useful 297 lzma_next_coder next; 298 299 /// Track the state of the coder. This is used to validate arguments 300 /// so that the actual coders can rely on e.g. that LZMA_SYNC_FLUSH 301 /// is used on every call to lzma_code until next.code has returned 302 /// LZMA_STREAM_END. 303 enum { 304 ISEQ_RUN, 305 ISEQ_SYNC_FLUSH, 306 ISEQ_FULL_FLUSH, 307 ISEQ_FINISH, 308 ISEQ_FULL_BARRIER, 309 ISEQ_END, 310 ISEQ_ERROR, 311 } sequence; 312 313 /// A copy of lzma_stream avail_in. This is used to verify that the 314 /// amount of input doesn't change once e.g. LZMA_FINISH has been 315 /// used. 316 size_t avail_in; 317 318 /// Indicates which lzma_action values are allowed by next.code. 319 bool supported_actions[LZMA_ACTION_MAX + 1]; 320 321 /// If true, lzma_code will return LZMA_BUF_ERROR if no progress was 322 /// made (no input consumed and no output produced by next.code). 323 bool allow_buf_error; 324}; 325 326 327/// Allocates memory 328lzma_attr_alloc_size(1) 329extern void *lzma_alloc(size_t size, const lzma_allocator *allocator); 330 331/// Allocates memory and zeroes it (like calloc()). This can be faster 332/// than lzma_alloc() + memzero() while being backward compatible with 333/// custom allocators. 334lzma_attr_alloc_size(1) 335extern void *lzma_alloc_zero(size_t size, const lzma_allocator *allocator); 336 337/// Frees memory 338extern void lzma_free(void *ptr, const lzma_allocator *allocator); 339 340 341/// Allocates strm->internal if it is NULL, and initializes *strm and 342/// strm->internal. This function is only called via lzma_next_strm_init macro. 343extern lzma_ret lzma_strm_init(lzma_stream *strm); 344 345/// Initializes the next filter in the chain, if any. This takes care of 346/// freeing the memory of previously initialized filter if it is different 347/// than the filter being initialized now. This way the actual filter 348/// initialization functions don't need to use lzma_next_coder_init macro. 349extern lzma_ret lzma_next_filter_init(lzma_next_coder *next, 350 const lzma_allocator *allocator, 351 const lzma_filter_info *filters); 352 353/// Update the next filter in the chain, if any. This checks that 354/// the application is not trying to change the Filter IDs. 355extern lzma_ret lzma_next_filter_update( 356 lzma_next_coder *next, const lzma_allocator *allocator, 357 const lzma_filter *reversed_filters); 358 359/// Frees the memory allocated for next->coder either using next->end or, 360/// if next->end is NULL, using lzma_free. 361extern void lzma_next_end(lzma_next_coder *next, 362 const lzma_allocator *allocator); 363 364 365/// Copy as much data as possible from in[] to out[] and update *in_pos 366/// and *out_pos accordingly. Returns the number of bytes copied. 367extern size_t lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos, 368 size_t in_size, uint8_t *restrict out, 369 size_t *restrict out_pos, size_t out_size); 370 371 372/// \brief Return if expression doesn't evaluate to LZMA_OK 373/// 374/// There are several situations where we want to return immediately 375/// with the value of expr if it isn't LZMA_OK. This macro shortens 376/// the code a little. 377#define return_if_error(expr) \ 378do { \ 379 const lzma_ret ret_ = (expr); \ 380 if (ret_ != LZMA_OK) \ 381 return ret_; \ 382} while (0) 383 384 385/// If next isn't already initialized, free the previous coder. Then mark 386/// that next is _possibly_ initialized for the coder using this macro. 387/// "Possibly" means that if e.g. allocation of next->coder fails, the 388/// structure isn't actually initialized for this coder, but leaving 389/// next->init to func is still OK. 390#define lzma_next_coder_init(func, next, allocator) \ 391do { \ 392 if ((uintptr_t)(func) != (next)->init) \ 393 lzma_next_end(next, allocator); \ 394 (next)->init = (uintptr_t)(func); \ 395} while (0) 396 397 398/// Initializes lzma_strm and calls func() to initialize strm->internal->next. 399/// (The function being called will use lzma_next_coder_init()). If 400/// initialization fails, memory that wasn't freed by func() is freed 401/// along strm->internal. 402#define lzma_next_strm_init(func, strm, ...) \ 403do { \ 404 return_if_error(lzma_strm_init(strm)); \ 405 const lzma_ret ret_ = func(&(strm)->internal->next, \ 406 (strm)->allocator, __VA_ARGS__); \ 407 if (ret_ != LZMA_OK) { \ 408 lzma_end(strm); \ 409 return ret_; \ 410 } \ 411} while (0) 412 413#endif 414