/src/CMake/Utilities/cmliblzma/liblzma/common/common.c

Source
// SPDX-License-Identifier: 0BSD

///////////////////////////////////////////////////////////////////////////////
//
/// \file       common.c
/// \brief      Common functions needed in many places in liblzma
//
//  Author:     Lasse Collin
//
///////////////////////////////////////////////////////////////////////////////

#include "common.h"


/////////////
// Version //
/////////////

extern LZMA_API(uint32_t)
lzma_version_number(void)
{
  return LZMA_VERSION;
}


extern LZMA_API(const char *)
lzma_version_string(void)
{
  return LZMA_VERSION_STRING;
}


///////////////////////
// Memory allocation //
///////////////////////

lzma_attr_alloc_size(1)
extern void *
lzma_alloc(size_t size, const lzma_allocator *allocator)
{
  // Some malloc() variants return NULL if called with size == 0.
  if (size == 0)
    size = 1;

  void *ptr;

  if (allocator != NULL && allocator->alloc != NULL)
    ptr = allocator->alloc(allocator->opaque, 1, size);
  else
    ptr = malloc(size);

  return ptr;
}


lzma_attr_alloc_size(1)
extern void *
lzma_alloc_zero(size_t size, const lzma_allocator *allocator)
{
  // Some calloc() variants return NULL if called with size == 0.
  if (size == 0)
    size = 1;

  void *ptr;

  if (allocator != NULL && allocator->alloc != NULL) {
    ptr = allocator->alloc(allocator->opaque, 1, size);
    if (ptr != NULL)
      memzero(ptr, size);
  } else {
    ptr = calloc(1, size);
  }

  return ptr;
}


extern void
lzma_free(void *ptr, const lzma_allocator *allocator)
{
  if (allocator != NULL && allocator->free != NULL)
    allocator->free(allocator->opaque, ptr);
  else
    free(ptr);

  return;
}


//////////
// Misc //
//////////

extern size_t
lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos,
    size_t in_size, uint8_t *restrict out,
    size_t *restrict out_pos, size_t out_size)
{
  const size_t in_avail = in_size - *in_pos;
  const size_t out_avail = out_size - *out_pos;
  const size_t copy_size = my_min(in_avail, out_avail);

  // Call memcpy() only if there is something to copy. If there is
  // nothing to copy, in or out might be NULL and then the memcpy()
  // call would trigger undefined behavior.
  if (copy_size > 0)
    memcpy(out + *out_pos, in + *in_pos, copy_size);

  *in_pos += copy_size;
  *out_pos += copy_size;

  return copy_size;
}


extern lzma_ret
lzma_next_filter_init(lzma_next_coder *next, const lzma_allocator *allocator,
    const lzma_filter_info *filters)
{
  lzma_next_coder_init(filters[0].init, next, allocator);
  next->id = filters[0].id;
  return filters[0].init == NULL
      ? LZMA_OK : filters[0].init(next, allocator, filters);
}


extern lzma_ret
lzma_next_filter_update(lzma_next_coder *next, const lzma_allocator *allocator,
    const lzma_filter *reversed_filters)
{
  // Check that the application isn't trying to change the Filter ID.
  // End of filters is indicated with LZMA_VLI_UNKNOWN in both
  // reversed_filters[0].id and next->id.
  if (reversed_filters[0].id != next->id)
    return LZMA_PROG_ERROR;

  if (reversed_filters[0].id == LZMA_VLI_UNKNOWN)
    return LZMA_OK;

  assert(next->update != NULL);
  return next->update(next->coder, allocator, NULL, reversed_filters);
}


extern void
lzma_next_end(lzma_next_coder *next, const lzma_allocator *allocator)
{
  if (next->init != (uintptr_t)(NULL)) {
    // To avoid tiny end functions that simply call
    // lzma_free(coder, allocator), we allow leaving next->end
    // NULL and call lzma_free() here.
    if (next->end != NULL)
      next->end(next->coder, allocator);
    else
      lzma_free(next->coder, allocator);

    // Reset the variables so the we don't accidentally think
    // that it is an already initialized coder.
    *next = LZMA_NEXT_CODER_INIT;
  }

  return;
}


//////////////////////////////////////
// External to internal API wrapper //
//////////////////////////////////////

extern lzma_ret
lzma_strm_init(lzma_stream *strm)
{
  if (strm == NULL)
    return LZMA_PROG_ERROR;

  if (strm->internal == NULL) {
    strm->internal = lzma_alloc(sizeof(lzma_internal),
        strm->allocator);
    if (strm->internal == NULL)
      return LZMA_MEM_ERROR;

    strm->internal->next = LZMA_NEXT_CODER_INIT;
  }

  memzero(strm->internal->supported_actions,
      sizeof(strm->internal->supported_actions));
  strm->internal->sequence = ISEQ_RUN;
  strm->internal->allow_buf_error = false;

  strm->total_in = 0;
  strm->total_out = 0;

  return LZMA_OK;
}


extern LZMA_API(lzma_ret)
lzma_code(lzma_stream *strm, lzma_action action)
{
  // Sanity checks
  if ((strm->next_in == NULL && strm->avail_in != 0)
      || (strm->next_out == NULL && strm->avail_out != 0)
      || strm->internal == NULL
      || strm->internal->next.code == NULL
      || (unsigned int)(action) > LZMA_ACTION_MAX
      || !strm->internal->supported_actions[action])
    return LZMA_PROG_ERROR;

  // Check if unsupported members have been set to non-zero or non-NULL,
  // which would indicate that some new feature is wanted.
  if (strm->reserved_ptr1 != NULL
      || strm->reserved_ptr2 != NULL
      || strm->reserved_ptr3 != NULL
      || strm->reserved_ptr4 != NULL
      || strm->reserved_int2 != 0
      || strm->reserved_int3 != 0
      || strm->reserved_int4 != 0
      || strm->reserved_enum1 != LZMA_RESERVED_ENUM
      || strm->reserved_enum2 != LZMA_RESERVED_ENUM)
    return LZMA_OPTIONS_ERROR;

  switch (strm->internal->sequence) {
  case ISEQ_RUN:
    switch (action) {
    case LZMA_RUN:
      break;

    case LZMA_SYNC_FLUSH:
      strm->internal->sequence = ISEQ_SYNC_FLUSH;
      break;

    case LZMA_FULL_FLUSH:
      strm->internal->sequence = ISEQ_FULL_FLUSH;
      break;

    case LZMA_FINISH:
      strm->internal->sequence = ISEQ_FINISH;
      break;

    case LZMA_FULL_BARRIER:
      strm->internal->sequence = ISEQ_FULL_BARRIER;
      break;
    }

    break;

  case ISEQ_SYNC_FLUSH:
    // The same action must be used until we return
    // LZMA_STREAM_END, and the amount of input must not change.
    if (action != LZMA_SYNC_FLUSH
        || strm->internal->avail_in != strm->avail_in)
      return LZMA_PROG_ERROR;

    break;

  case ISEQ_FULL_FLUSH:
    if (action != LZMA_FULL_FLUSH
        || strm->internal->avail_in != strm->avail_in)
      return LZMA_PROG_ERROR;

    break;

  case ISEQ_FINISH:
    if (action != LZMA_FINISH
        || strm->internal->avail_in != strm->avail_in)
      return LZMA_PROG_ERROR;

    break;

  case ISEQ_FULL_BARRIER:
    if (action != LZMA_FULL_BARRIER
        || strm->internal->avail_in != strm->avail_in)
      return LZMA_PROG_ERROR;

    break;

  case ISEQ_END:
    return LZMA_STREAM_END;

  case ISEQ_ERROR:
  default:
    return LZMA_PROG_ERROR;
  }

  size_t in_pos = 0;
  size_t out_pos = 0;
  lzma_ret ret = strm->internal->next.code(
      strm->internal->next.coder, strm->allocator,
      strm->next_in, &in_pos, strm->avail_in,
      strm->next_out, &out_pos, strm->avail_out, action);

  // Updating next_in and next_out has to be skipped when they are NULL
  // to avoid null pointer + 0 (undefined behavior). Do this by checking
  // in_pos > 0 and out_pos > 0 because this way NULL + non-zero (a bug)
  // will get caught one way or other.
  if (in_pos > 0) {
    strm->next_in += in_pos;
    strm->avail_in -= in_pos;
    strm->total_in += in_pos;
  }

  if (out_pos > 0) {
    strm->next_out += out_pos;
    strm->avail_out -= out_pos;
    strm->total_out += out_pos;
  }

  strm->internal->avail_in = strm->avail_in;

  switch (ret) {
  case LZMA_OK:
    // Don't return LZMA_BUF_ERROR when it happens the first time.
    // This is to avoid returning LZMA_BUF_ERROR when avail_out
    // was zero but still there was no more data left to written
    // to next_out.
    if (out_pos == 0 && in_pos == 0) {
      if (strm->internal->allow_buf_error)
        ret = LZMA_BUF_ERROR;
      else
        strm->internal->allow_buf_error = true;
    } else {
      strm->internal->allow_buf_error = false;
    }
    break;

  case LZMA_TIMED_OUT:
    strm->internal->allow_buf_error = false;
    ret = LZMA_OK;
    break;

  case LZMA_SEEK_NEEDED:
    strm->internal->allow_buf_error = false;

    // If LZMA_FINISH was used, reset it back to the
    // LZMA_RUN-based state so that new input can be supplied
    // by the application.
    if (strm->internal->sequence == ISEQ_FINISH)
      strm->internal->sequence = ISEQ_RUN;

    break;

  case LZMA_STREAM_END:
    if (strm->internal->sequence == ISEQ_SYNC_FLUSH
        || strm->internal->sequence == ISEQ_FULL_FLUSH
        || strm->internal->sequence
          == ISEQ_FULL_BARRIER)
      strm->internal->sequence = ISEQ_RUN;
    else
      strm->internal->sequence = ISEQ_END;

  // Fall through

  case LZMA_NO_CHECK:
  case LZMA_UNSUPPORTED_CHECK:
  case LZMA_GET_CHECK:
  case LZMA_MEMLIMIT_ERROR:
    // Something else than LZMA_OK, but not a fatal error,
    // that is, coding may be continued (except if ISEQ_END).
    strm->internal->allow_buf_error = false;
    break;

  default:
    // All the other errors are fatal; coding cannot be continued.
    assert(ret != LZMA_BUF_ERROR);
    strm->internal->sequence = ISEQ_ERROR;
    break;
  }

  return ret;
}


extern LZMA_API(void)
lzma_end(lzma_stream *strm)
{
  if (strm != NULL && strm->internal != NULL) {
    lzma_next_end(&strm->internal->next, strm->allocator);
    lzma_free(strm->internal, strm->allocator);
    strm->internal = NULL;
  }

  return;
}


#ifdef HAVE_SYMBOL_VERSIONS_LINUX
// This is for compatibility with binaries linked against liblzma that
// has been patched with xz-5.2.2-compat-libs.patch from RHEL/CentOS 7.
LZMA_SYMVER_API("lzma_get_progress@XZ_5.2.2",
  void, lzma_get_progress_522)(lzma_stream *strm,
    uint64_t *progress_in, uint64_t *progress_out) lzma_nothrow
    __attribute__((__alias__("lzma_get_progress_52")));

LZMA_SYMVER_API("lzma_get_progress@@XZ_5.2",
  void, lzma_get_progress_52)(lzma_stream *strm,
    uint64_t *progress_in, uint64_t *progress_out) lzma_nothrow;

#define lzma_get_progress lzma_get_progress_52
#endif
extern LZMA_API(void)
lzma_get_progress(lzma_stream *strm,
    uint64_t *progress_in, uint64_t *progress_out)
{
  if (strm->internal->next.get_progress != NULL) {
    strm->internal->next.get_progress(strm->internal->next.coder,
        progress_in, progress_out);
  } else {
    *progress_in = strm->total_in;
    *progress_out = strm->total_out;
  }

  return;
}


extern LZMA_API(lzma_check)
lzma_get_check(const lzma_stream *strm)
{
  // Return LZMA_CHECK_NONE if we cannot know the check type.
  // It's a bug in the application if this happens.
  if (strm->internal->next.get_check == NULL)
    return LZMA_CHECK_NONE;

  return strm->internal->next.get_check(strm->internal->next.coder);
}


extern LZMA_API(uint64_t)
lzma_memusage(const lzma_stream *strm)
{
  uint64_t memusage;
  uint64_t old_memlimit;

  if (strm == NULL || strm->internal == NULL
      || strm->internal->next.memconfig == NULL
      || strm->internal->next.memconfig(
        strm->internal->next.coder,
        &memusage, &old_memlimit, 0) != LZMA_OK)
    return 0;

  return memusage;
}


extern LZMA_API(uint64_t)
lzma_memlimit_get(const lzma_stream *strm)
{
  uint64_t old_memlimit;
  uint64_t memusage;

  if (strm == NULL || strm->internal == NULL
      || strm->internal->next.memconfig == NULL
      || strm->internal->next.memconfig(
        strm->internal->next.coder,
        &memusage, &old_memlimit, 0) != LZMA_OK)
    return 0;

  return old_memlimit;
}


extern LZMA_API(lzma_ret)
lzma_memlimit_set(lzma_stream *strm, uint64_t new_memlimit)
{
  // Dummy variables to simplify memconfig functions
  uint64_t old_memlimit;
  uint64_t memusage;

  if (strm == NULL || strm->internal == NULL
      || strm->internal->next.memconfig == NULL)
    return LZMA_PROG_ERROR;

  // Zero is a special value that cannot be used as an actual limit.
  // If 0 was specified, use 1 instead.
  if (new_memlimit == 0)
    new_memlimit = 1;

  return strm->internal->next.memconfig(strm->internal->next.coder,
      &memusage, &old_memlimit, new_memlimit);
}

Coverage Report

Created: 2026-03-12 06:35

Line	Count	Source
1		// SPDX-License-Identifier: 0BSD
2
3		///////////////////////////////////////////////////////////////////////////////
4		//
5		/// \file common.c
6		/// \brief Common functions needed in many places in liblzma
7		//
8		// Author: Lasse Collin
9		//
10		///////////////////////////////////////////////////////////////////////////////
11
12		#include "common.h"
13
14
15		/////////////
16		// Version //
17		/////////////
18
19		extern LZMA_API(uint32_t)
20		lzma_version_number(void)
21	0	{
22	0	return LZMA_VERSION;
23	0	}
24
25
26		extern LZMA_API(const char *)
27		lzma_version_string(void)
28	0	{
29	0	return LZMA_VERSION_STRING;
30	0	}
31
32
33		///////////////////////
34		// Memory allocation //
35		///////////////////////
36
37		lzma_attr_alloc_size(1)
38		extern void *
39		lzma_alloc(size_t size, const lzma_allocator *allocator)
40	33.2k	{
41		// Some malloc() variants return NULL if called with size == 0.
42	33.2k	if (size == 0)
43	0	size = 1;
44
45	33.2k	void *ptr;
46
47	33.2k	if (allocator != NULL && allocator->alloc != NULL)
48	0	ptr = allocator->alloc(allocator->opaque, 1, size);
49	33.2k	else
50	33.2k	ptr = malloc(size);
51
52	33.2k	return ptr;
53	33.2k	}
54
55
56		lzma_attr_alloc_size(1)
57		extern void *
58		lzma_alloc_zero(size_t size, const lzma_allocator *allocator)
59	0	{
60		// Some calloc() variants return NULL if called with size == 0.
61	0	if (size == 0)
62	0	size = 1;
63
64	0	void *ptr;
65
66	0	if (allocator != NULL && allocator->alloc != NULL) {
67	0	ptr = allocator->alloc(allocator->opaque, 1, size);
68	0	if (ptr != NULL)
69	0	memzero(ptr, size);
70	0	} else {
71	0	ptr = calloc(1, size);
72	0	}
73
74	0	return ptr;
75	0	}
76
77
78		extern void
79		lzma_free(void ptr, const lzma_allocator allocator)
80	36.1k	{
81	36.1k	if (allocator != NULL && allocator->free != NULL)
82	0	allocator->free(allocator->opaque, ptr);
83	36.1k	else
84	36.1k	free(ptr);
85
86	36.1k	return;
87	36.1k	}
88
89
90		//////////
91		// Misc //
92		//////////
93
94		extern size_t
95		lzma_bufcpy(const uint8_t restrict in, size_t restrict in_pos,
96		size_t in_size, uint8_t *restrict out,
97		size_t *restrict out_pos, size_t out_size)
98	4.87k	{
99	4.87k	const size_t in_avail = in_size - *in_pos;
100	4.87k	const size_t out_avail = out_size - *out_pos;
101	4.87k	const size_t copy_size = my_min(in_avail, out_avail);
102
103		// Call memcpy() only if there is something to copy. If there is
104		// nothing to copy, in or out might be NULL and then the memcpy()
105		// call would trigger undefined behavior.
106	4.87k	if (copy_size > 0)
107	4.04k	memcpy(out + out_pos, in + in_pos, copy_size);
108
109	4.87k	*in_pos += copy_size;
110	4.87k	*out_pos += copy_size;
111
112	4.87k	return copy_size;
113	4.87k	}
114
115
116		extern lzma_ret
117		lzma_next_filter_init(lzma_next_coder next, const lzma_allocator allocator,
118		const lzma_filter_info *filters)
119	10.7k	{
120	10.7k	lzma_next_coder_init(filters[0].init, next, allocator);
121	10.7k	next->id = filters[0].id;
122	10.7k	return filters[0].init == NULL
123	10.7k	? LZMA_OK : filters[0].init(next, allocator, filters);
124	10.7k	}
125
126
127		extern lzma_ret
128		lzma_next_filter_update(lzma_next_coder next, const lzma_allocator allocator,
129		const lzma_filter *reversed_filters)
130	0	{
131		// Check that the application isn't trying to change the Filter ID.
132		// End of filters is indicated with LZMA_VLI_UNKNOWN in both
133		// reversed_filters[0].id and next->id.
134	0	if (reversed_filters[0].id != next->id)
135	0	return LZMA_PROG_ERROR;
136
137	0	if (reversed_filters[0].id == LZMA_VLI_UNKNOWN)
138	0	return LZMA_OK;
139
140	0	assert(next->update != NULL);
141	0	return next->update(next->coder, allocator, NULL, reversed_filters);
142	0	}
143
144
145		extern void
146		lzma_next_end(lzma_next_coder next, const lzma_allocator allocator)
147	24.3k	{
148	24.3k	if (next->init != (uintptr_t)(NULL)) {
149		// To avoid tiny end functions that simply call
150		// lzma_free(coder, allocator), we allow leaving next->end
151		// NULL and call lzma_free() here.
152	9.03k	if (next->end != NULL)
153	9.03k	next->end(next->coder, allocator);
154	0	else
155	0	lzma_free(next->coder, allocator);
156
157		// Reset the variables so the we don't accidentally think
158		// that it is an already initialized coder.
159	9.03k	*next = LZMA_NEXT_CODER_INIT;
160	9.03k	}
161
162	24.3k	return;
163	24.3k	}
164
165
166		//////////////////////////////////////
167		// External to internal API wrapper //
168		//////////////////////////////////////
169
170		extern lzma_ret
171		lzma_strm_init(lzma_stream *strm)
172	6.22k	{
173	6.22k	if (strm == NULL)
174	0	return LZMA_PROG_ERROR;
175
176	6.22k	if (strm->internal == NULL) {
177	6.22k	strm->internal = lzma_alloc(sizeof(lzma_internal),
178	6.22k	strm->allocator);
179	6.22k	if (strm->internal == NULL)
180	0	return LZMA_MEM_ERROR;
181
182	6.22k	strm->internal->next = LZMA_NEXT_CODER_INIT;
183	6.22k	}
184
185	6.22k	memzero(strm->internal->supported_actions,
186	6.22k	sizeof(strm->internal->supported_actions));
187	6.22k	strm->internal->sequence = ISEQ_RUN;
188	6.22k	strm->internal->allow_buf_error = false;
189
190	6.22k	strm->total_in = 0;
191	6.22k	strm->total_out = 0;
192
193	6.22k	return LZMA_OK;
194	6.22k	}
195
196
197		extern LZMA_API(lzma_ret)
198		lzma_code(lzma_stream *strm, lzma_action action)
199	12.5k	{
200		// Sanity checks
201	12.5k	if ((strm->next_in == NULL && strm->avail_in != 0)
202	12.5k	\|\| (strm->next_out == NULL && strm->avail_out != 0)
203	12.5k	\|\| strm->internal == NULL
204	12.5k	\|\| strm->internal->next.code == NULL
205	12.5k	\|\| (unsigned int)(action) > LZMA_ACTION_MAX
206	12.5k	\|\| !strm->internal->supported_actions[action])
207	0	return LZMA_PROG_ERROR;
208
209		// Check if unsupported members have been set to non-zero or non-NULL,
210		// which would indicate that some new feature is wanted.
211	12.5k	if (strm->reserved_ptr1 != NULL
212	12.5k	\|\| strm->reserved_ptr2 != NULL
213	12.5k	\|\| strm->reserved_ptr3 != NULL
214	12.5k	\|\| strm->reserved_ptr4 != NULL
215	12.5k	\|\| strm->reserved_int2 != 0
216	12.5k	\|\| strm->reserved_int3 != 0
217	12.5k	\|\| strm->reserved_int4 != 0
218	12.5k	\|\| strm->reserved_enum1 != LZMA_RESERVED_ENUM
219	12.5k	\|\| strm->reserved_enum2 != LZMA_RESERVED_ENUM)
220	0	return LZMA_OPTIONS_ERROR;
221
222	12.5k	switch (strm->internal->sequence) {
223	9.57k	case ISEQ_RUN:
224	9.57k	switch (action) {
225	6.59k	case LZMA_RUN:
226	6.59k	break;
227
228	0	case LZMA_SYNC_FLUSH:
229	0	strm->internal->sequence = ISEQ_SYNC_FLUSH;
230	0	break;
231
232	0	case LZMA_FULL_FLUSH:
233	0	strm->internal->sequence = ISEQ_FULL_FLUSH;
234	0	break;
235
236	2.98k	case LZMA_FINISH:
237	2.98k	strm->internal->sequence = ISEQ_FINISH;
238	2.98k	break;
239
240	0	case LZMA_FULL_BARRIER:
241	0	strm->internal->sequence = ISEQ_FULL_BARRIER;
242	0	break;
243	9.57k	}
244
245	9.57k	break;
246
247	9.57k	case ISEQ_SYNC_FLUSH:
248		// The same action must be used until we return
249		// LZMA_STREAM_END, and the amount of input must not change.
250	0	if (action != LZMA_SYNC_FLUSH
251	0	\|\| strm->internal->avail_in != strm->avail_in)
252	0	return LZMA_PROG_ERROR;
253
254	0	break;
255
256	0	case ISEQ_FULL_FLUSH:
257	0	if (action != LZMA_FULL_FLUSH
258	0	\|\| strm->internal->avail_in != strm->avail_in)
259	0	return LZMA_PROG_ERROR;
260
261	0	break;
262
263	2.99k	case ISEQ_FINISH:
264	2.99k	if (action != LZMA_FINISH
265	2.99k	\|\| strm->internal->avail_in != strm->avail_in)
266	0	return LZMA_PROG_ERROR;
267
268	2.99k	break;
269
270	2.99k	case ISEQ_FULL_BARRIER:
271	0	if (action != LZMA_FULL_BARRIER
272	0	\|\| strm->internal->avail_in != strm->avail_in)
273	0	return LZMA_PROG_ERROR;
274
275	0	break;
276
277	0	case ISEQ_END:
278	0	return LZMA_STREAM_END;
279
280	0	case ISEQ_ERROR:
281	0	default:
282	0	return LZMA_PROG_ERROR;
283	12.5k	}
284
285	12.5k	size_t in_pos = 0;
286	12.5k	size_t out_pos = 0;
287	12.5k	lzma_ret ret = strm->internal->next.code(
288	12.5k	strm->internal->next.coder, strm->allocator,
289	12.5k	strm->next_in, &in_pos, strm->avail_in,
290	12.5k	strm->next_out, &out_pos, strm->avail_out, action);
291
292		// Updating next_in and next_out has to be skipped when they are NULL
293		// to avoid null pointer + 0 (undefined behavior). Do this by checking
294		// in_pos > 0 and out_pos > 0 because this way NULL + non-zero (a bug)
295		// will get caught one way or other.
296	12.5k	if (in_pos > 0) {
297	6.28k	strm->next_in += in_pos;
298	6.28k	strm->avail_in -= in_pos;
299	6.28k	strm->total_in += in_pos;
300	6.28k	}
301
302	12.5k	if (out_pos > 0) {
303	4.35k	strm->next_out += out_pos;
304	4.35k	strm->avail_out -= out_pos;
305	4.35k	strm->total_out += out_pos;
306	4.35k	}
307
308	12.5k	strm->internal->avail_in = strm->avail_in;
309
310	12.5k	switch (ret) {
311	9.49k	case LZMA_OK:
312		// Don't return LZMA_BUF_ERROR when it happens the first time.
313		// This is to avoid returning LZMA_BUF_ERROR when avail_out
314		// was zero but still there was no more data left to written
315		// to next_out.
316	9.49k	if (out_pos == 0 && in_pos == 0) {
317	6.20k	if (strm->internal->allow_buf_error)
318	3.10k	ret = LZMA_BUF_ERROR;
319	3.10k	else
320	3.10k	strm->internal->allow_buf_error = true;
321	6.20k	} else {
322	3.29k	strm->internal->allow_buf_error = false;
323	3.29k	}
324	9.49k	break;
325
326	0	case LZMA_TIMED_OUT:
327	0	strm->internal->allow_buf_error = false;
328	0	ret = LZMA_OK;
329	0	break;
330
331	0	case LZMA_SEEK_NEEDED:
332	0	strm->internal->allow_buf_error = false;
333
334		// If LZMA_FINISH was used, reset it back to the
335		// LZMA_RUN-based state so that new input can be supplied
336		// by the application.
337	0	if (strm->internal->sequence == ISEQ_FINISH)
338	0	strm->internal->sequence = ISEQ_RUN;
339
340	0	break;
341
342	40	case LZMA_STREAM_END:
343	40	if (strm->internal->sequence == ISEQ_SYNC_FLUSH
344	40	\|\| strm->internal->sequence == ISEQ_FULL_FLUSH
345	40	\|\| strm->internal->sequence
346	40	== ISEQ_FULL_BARRIER)
347	0	strm->internal->sequence = ISEQ_RUN;
348	40	else
349	40	strm->internal->sequence = ISEQ_END;
350
351		// Fall through
352
353	40	case LZMA_NO_CHECK:
354	40	case LZMA_UNSUPPORTED_CHECK:
355	40	case LZMA_GET_CHECK:
356	40	case LZMA_MEMLIMIT_ERROR:
357		// Something else than LZMA_OK, but not a fatal error,
358		// that is, coding may be continued (except if ISEQ_END).
359	40	strm->internal->allow_buf_error = false;
360	40	break;
361
362	3.03k	default:
363		// All the other errors are fatal; coding cannot be continued.
364	3.03k	assert(ret != LZMA_BUF_ERROR);
365	3.03k	strm->internal->sequence = ISEQ_ERROR;
366	3.03k	break;
367	12.5k	}
368
369	12.5k	return ret;
370	12.5k	}
371
372
373		extern LZMA_API(void)
374		lzma_end(lzma_stream *strm)
375	6.22k	{
376	6.22k	if (strm != NULL && strm->internal != NULL) {
377	6.22k	lzma_next_end(&strm->internal->next, strm->allocator);
378	6.22k	lzma_free(strm->internal, strm->allocator);
379	6.22k	strm->internal = NULL;
380	6.22k	}
381
382	6.22k	return;
383	6.22k	}
384
385
386		#ifdef HAVE_SYMBOL_VERSIONS_LINUX
387		// This is for compatibility with binaries linked against liblzma that
388		// has been patched with xz-5.2.2-compat-libs.patch from RHEL/CentOS 7.
389		LZMA_SYMVER_API("lzma_get_progress@XZ_5.2.2",
390		void, lzma_get_progress_522)(lzma_stream *strm,
391		uint64_t progress_in, uint64_t progress_out) lzma_nothrow
392		__attribute__((__alias__("lzma_get_progress_52")));
393
394		LZMA_SYMVER_API("lzma_get_progress@@XZ_5.2",
395		void, lzma_get_progress_52)(lzma_stream *strm,
396		uint64_t progress_in, uint64_t progress_out) lzma_nothrow;
397
398		#define lzma_get_progress lzma_get_progress_52
399		#endif
400		extern LZMA_API(void)
401		lzma_get_progress(lzma_stream *strm,
402		uint64_t progress_in, uint64_t progress_out)
403	0	{
404	0	if (strm->internal->next.get_progress != NULL) {
405	0	strm->internal->next.get_progress(strm->internal->next.coder,
406	0	progress_in, progress_out);
407	0	} else {
408	0	*progress_in = strm->total_in;
409	0	*progress_out = strm->total_out;
410	0	}
411
412	0	return;
413	0	}
414
415
416		extern LZMA_API(lzma_check)
417		lzma_get_check(const lzma_stream *strm)
418	0	{
419		// Return LZMA_CHECK_NONE if we cannot know the check type.
420		// It's a bug in the application if this happens.
421	0	if (strm->internal->next.get_check == NULL)
422	0	return LZMA_CHECK_NONE;
423
424	0	return strm->internal->next.get_check(strm->internal->next.coder);
425	0	}
426
427
428		extern LZMA_API(uint64_t)
429		lzma_memusage(const lzma_stream *strm)
430	0	{
431	0	uint64_t memusage;
432	0	uint64_t old_memlimit;
433
434	0	if (strm == NULL \|\| strm->internal == NULL
435	0	\|\| strm->internal->next.memconfig == NULL
436	0	\|\| strm->internal->next.memconfig(
437	0	strm->internal->next.coder,
438	0	&memusage, &old_memlimit, 0) != LZMA_OK)
439	0	return 0;
440
441	0	return memusage;
442	0	}
443
444
445		extern LZMA_API(uint64_t)
446		lzma_memlimit_get(const lzma_stream *strm)
447	0	{
448	0	uint64_t old_memlimit;
449	0	uint64_t memusage;
450
451	0	if (strm == NULL \|\| strm->internal == NULL
452	0	\|\| strm->internal->next.memconfig == NULL
453	0	\|\| strm->internal->next.memconfig(
454	0	strm->internal->next.coder,
455	0	&memusage, &old_memlimit, 0) != LZMA_OK)
456	0	return 0;
457
458	0	return old_memlimit;
459	0	}
460
461
462		extern LZMA_API(lzma_ret)
463		lzma_memlimit_set(lzma_stream *strm, uint64_t new_memlimit)
464	0	{
465		// Dummy variables to simplify memconfig functions
466	0	uint64_t old_memlimit;
467	0	uint64_t memusage;
468
469	0	if (strm == NULL \|\| strm->internal == NULL
470	0	\|\| strm->internal->next.memconfig == NULL)
471	0	return LZMA_PROG_ERROR;
472
473		// Zero is a special value that cannot be used as an actual limit.
474		// If 0 was specified, use 1 instead.
475	0	if (new_memlimit == 0)
476	0	new_memlimit = 1;
477
478	0	return strm->internal->next.memconfig(strm->internal->next.coder,
479	0	&memusage, &old_memlimit, new_memlimit);
480	0	}