1 ///////////////////////////////////////////////////////////////////////////////
4 /// \brief Common functions needed in many places in liblzma
6 // Author: Lasse Collin
8 // This file has been put into the public domain.
9 // You can do whatever you want with this file.
11 ///////////////////////////////////////////////////////////////////////////////
20 extern LZMA_API(uint32_t)
21 lzma_version_number(void)
27 extern LZMA_API(const char *)
28 lzma_version_string(void)
30 return LZMA_VERSION_STRING
;
34 ///////////////////////
35 // Memory allocation //
36 ///////////////////////
38 extern void * lzma_attribute((__malloc__
)) lzma_attr_alloc_size(1)
39 lzma_alloc(size_t size
, lzma_allocator
*allocator
)
41 // Some malloc() variants return NULL if called with size == 0.
47 if (allocator
!= NULL
&& allocator
->alloc
!= NULL
)
48 ptr
= allocator
->alloc(allocator
->opaque
, 1, size
);
57 lzma_free(void *ptr
, lzma_allocator
*allocator
)
59 if (allocator
!= NULL
&& allocator
->free
!= NULL
)
60 allocator
->free(allocator
->opaque
, ptr
);
73 lzma_bufcpy(const uint8_t *restrict in
, size_t *restrict in_pos
,
74 size_t in_size
, uint8_t *restrict out
,
75 size_t *restrict out_pos
, size_t out_size
)
77 const size_t in_avail
= in_size
- *in_pos
;
78 const size_t out_avail
= out_size
- *out_pos
;
79 const size_t copy_size
= my_min(in_avail
, out_avail
);
81 memcpy(out
+ *out_pos
, in
+ *in_pos
, copy_size
);
84 *out_pos
+= copy_size
;
91 lzma_next_filter_init(lzma_next_coder
*next
, lzma_allocator
*allocator
,
92 const lzma_filter_info
*filters
)
94 lzma_next_coder_init(filters
[0].init
, next
, allocator
);
95 next
->id
= filters
[0].id
;
96 return filters
[0].init
== NULL
97 ? LZMA_OK
: filters
[0].init(next
, allocator
, filters
);
102 lzma_next_filter_update(lzma_next_coder
*next
, lzma_allocator
*allocator
,
103 const lzma_filter
*reversed_filters
)
105 // Check that the application isn't trying to change the Filter ID.
106 // End of filters is indicated with LZMA_VLI_UNKNOWN in both
107 // reversed_filters[0].id and next->id.
108 if (reversed_filters
[0].id
!= next
->id
)
109 return LZMA_PROG_ERROR
;
111 if (reversed_filters
[0].id
== LZMA_VLI_UNKNOWN
)
114 assert(next
->update
!= NULL
);
115 return next
->update(next
->coder
, allocator
, NULL
, reversed_filters
);
120 lzma_next_end(lzma_next_coder
*next
, lzma_allocator
*allocator
)
122 if (next
->init
!= (uintptr_t)(NULL
)) {
123 // To avoid tiny end functions that simply call
124 // lzma_free(coder, allocator), we allow leaving next->end
125 // NULL and call lzma_free() here.
126 if (next
->end
!= NULL
)
127 next
->end(next
->coder
, allocator
);
129 lzma_free(next
->coder
, allocator
);
131 // Reset the variables so the we don't accidentally think
132 // that it is an already initialized coder.
133 *next
= LZMA_NEXT_CODER_INIT
;
140 //////////////////////////////////////
141 // External to internal API wrapper //
142 //////////////////////////////////////
145 lzma_strm_init(lzma_stream
*strm
)
148 return LZMA_PROG_ERROR
;
150 if (strm
->internal
== NULL
) {
151 strm
->internal
= lzma_alloc(sizeof(lzma_internal
),
153 if (strm
->internal
== NULL
)
154 return LZMA_MEM_ERROR
;
156 strm
->internal
->next
= LZMA_NEXT_CODER_INIT
;
159 strm
->internal
->supported_actions
[LZMA_RUN
] = false;
160 strm
->internal
->supported_actions
[LZMA_SYNC_FLUSH
] = false;
161 strm
->internal
->supported_actions
[LZMA_FULL_FLUSH
] = false;
162 strm
->internal
->supported_actions
[LZMA_FINISH
] = false;
163 strm
->internal
->sequence
= ISEQ_RUN
;
164 strm
->internal
->allow_buf_error
= false;
173 extern LZMA_API(lzma_ret
)
174 lzma_code(lzma_stream
*strm
, lzma_action action
)
177 if ((strm
->next_in
== NULL
&& strm
->avail_in
!= 0)
178 || (strm
->next_out
== NULL
&& strm
->avail_out
!= 0)
179 || strm
->internal
== NULL
180 || strm
->internal
->next
.code
== NULL
181 || (unsigned int)(action
) > LZMA_FINISH
182 || !strm
->internal
->supported_actions
[action
])
183 return LZMA_PROG_ERROR
;
185 // Check if unsupported members have been set to non-zero or non-NULL,
186 // which would indicate that some new feature is wanted.
187 if (strm
->reserved_ptr1
!= NULL
188 || strm
->reserved_ptr2
!= NULL
189 || strm
->reserved_ptr3
!= NULL
190 || strm
->reserved_ptr4
!= NULL
191 || strm
->reserved_int1
!= 0
192 || strm
->reserved_int2
!= 0
193 || strm
->reserved_int3
!= 0
194 || strm
->reserved_int4
!= 0
195 || strm
->reserved_enum1
!= LZMA_RESERVED_ENUM
196 || strm
->reserved_enum2
!= LZMA_RESERVED_ENUM
)
197 return LZMA_OPTIONS_ERROR
;
199 switch (strm
->internal
->sequence
) {
205 case LZMA_SYNC_FLUSH
:
206 strm
->internal
->sequence
= ISEQ_SYNC_FLUSH
;
209 case LZMA_FULL_FLUSH
:
210 strm
->internal
->sequence
= ISEQ_FULL_FLUSH
;
214 strm
->internal
->sequence
= ISEQ_FINISH
;
220 case ISEQ_SYNC_FLUSH
:
221 // The same action must be used until we return
222 // LZMA_STREAM_END, and the amount of input must not change.
223 if (action
!= LZMA_SYNC_FLUSH
224 || strm
->internal
->avail_in
!= strm
->avail_in
)
225 return LZMA_PROG_ERROR
;
229 case ISEQ_FULL_FLUSH
:
230 if (action
!= LZMA_FULL_FLUSH
231 || strm
->internal
->avail_in
!= strm
->avail_in
)
232 return LZMA_PROG_ERROR
;
237 if (action
!= LZMA_FINISH
238 || strm
->internal
->avail_in
!= strm
->avail_in
)
239 return LZMA_PROG_ERROR
;
244 return LZMA_STREAM_END
;
248 return LZMA_PROG_ERROR
;
253 lzma_ret ret
= strm
->internal
->next
.code(
254 strm
->internal
->next
.coder
, strm
->allocator
,
255 strm
->next_in
, &in_pos
, strm
->avail_in
,
256 strm
->next_out
, &out_pos
, strm
->avail_out
, action
);
258 strm
->next_in
+= in_pos
;
259 strm
->avail_in
-= in_pos
;
260 strm
->total_in
+= in_pos
;
262 strm
->next_out
+= out_pos
;
263 strm
->avail_out
-= out_pos
;
264 strm
->total_out
+= out_pos
;
266 strm
->internal
->avail_in
= strm
->avail_in
;
270 // Don't return LZMA_BUF_ERROR when it happens the first time.
271 // This is to avoid returning LZMA_BUF_ERROR when avail_out
272 // was zero but still there was no more data left to written
274 if (out_pos
== 0 && in_pos
== 0) {
275 if (strm
->internal
->allow_buf_error
)
276 ret
= LZMA_BUF_ERROR
;
278 strm
->internal
->allow_buf_error
= true;
280 strm
->internal
->allow_buf_error
= false;
284 case LZMA_STREAM_END
:
285 if (strm
->internal
->sequence
== ISEQ_SYNC_FLUSH
286 || strm
->internal
->sequence
== ISEQ_FULL_FLUSH
)
287 strm
->internal
->sequence
= ISEQ_RUN
;
289 strm
->internal
->sequence
= ISEQ_END
;
294 case LZMA_UNSUPPORTED_CHECK
:
296 case LZMA_MEMLIMIT_ERROR
:
297 // Something else than LZMA_OK, but not a fatal error,
298 // that is, coding may be continued (except if ISEQ_END).
299 strm
->internal
->allow_buf_error
= false;
303 // All the other errors are fatal; coding cannot be continued.
304 assert(ret
!= LZMA_BUF_ERROR
);
305 strm
->internal
->sequence
= ISEQ_ERROR
;
313 extern LZMA_API(void)
314 lzma_end(lzma_stream
*strm
)
316 if (strm
!= NULL
&& strm
->internal
!= NULL
) {
317 lzma_next_end(&strm
->internal
->next
, strm
->allocator
);
318 lzma_free(strm
->internal
, strm
->allocator
);
319 strm
->internal
= NULL
;
326 extern LZMA_API(lzma_check
)
327 lzma_get_check(const lzma_stream
*strm
)
329 // Return LZMA_CHECK_NONE if we cannot know the check type.
330 // It's a bug in the application if this happens.
331 if (strm
->internal
->next
.get_check
== NULL
)
332 return LZMA_CHECK_NONE
;
334 return strm
->internal
->next
.get_check(strm
->internal
->next
.coder
);
338 extern LZMA_API(uint64_t)
339 lzma_memusage(const lzma_stream
*strm
)
342 uint64_t old_memlimit
;
344 if (strm
== NULL
|| strm
->internal
== NULL
345 || strm
->internal
->next
.memconfig
== NULL
346 || strm
->internal
->next
.memconfig(
347 strm
->internal
->next
.coder
,
348 &memusage
, &old_memlimit
, 0) != LZMA_OK
)
355 extern LZMA_API(uint64_t)
356 lzma_memlimit_get(const lzma_stream
*strm
)
358 uint64_t old_memlimit
;
361 if (strm
== NULL
|| strm
->internal
== NULL
362 || strm
->internal
->next
.memconfig
== NULL
363 || strm
->internal
->next
.memconfig(
364 strm
->internal
->next
.coder
,
365 &memusage
, &old_memlimit
, 0) != LZMA_OK
)
372 extern LZMA_API(lzma_ret
)
373 lzma_memlimit_set(lzma_stream
*strm
, uint64_t new_memlimit
)
375 // Dummy variables to simplify memconfig functions
376 uint64_t old_memlimit
;
379 if (strm
== NULL
|| strm
->internal
== NULL
380 || strm
->internal
->next
.memconfig
== NULL
)
381 return LZMA_PROG_ERROR
;
383 if (new_memlimit
!= 0 && new_memlimit
< LZMA_MEMUSAGE_BASE
)
384 return LZMA_MEMLIMIT_ERROR
;
386 return strm
->internal
->next
.memconfig(strm
->internal
->next
.coder
,
387 &memusage
, &old_memlimit
, new_memlimit
);