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
176 typedef struct lzma_next_coder_s lzma_next_coder;
177
178 typedef struct lzma_filter_info_s lzma_filter_info;
179
180
181 /// Type of a function used to initialize a filter encoder or decoder
182 typedef 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.
190 typedef 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
198 typedef 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.
205 struct 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.
223 struct 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.
295 struct 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
328 lzma_attr_alloc_size(1)
329 extern 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.
334 lzma_attr_alloc_size(1)
335 extern void *lzma_alloc_zero(size_t size, const lzma_allocator *allocator);
336
337 /// Frees memory
338 extern 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.
343 extern 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.
349 extern 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.
355 extern 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.
361 extern 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.
367 extern 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) \
378 do { \
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) \
391 do { \
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, ...) \
403 do { \
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