src/liblzma/common/common.c - jrn/xz - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       common.h
 /// \brief      Common functions needed in many places in liblzma
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
 ///////////////////////////////////////////////////////////////////////////////

 #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 //
 ///////////////////////

 extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
 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;
 }


 extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
 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);

 	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_int1 != 0
 			|| 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);

 	strm->next_in += in_pos;
 	strm->avail_in -= in_pos;
 	strm->total_in += in_pos;

 	strm->next_out += out_pos;
 	strm->avail_out -= out_pos;
 	strm->total_out += out_pos;

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

 	// Cast is needed to silence a warning about LZMA_TIMED_OUT, which
 	// isn't part of lzma_ret enumeration.
 	switch ((unsigned int)(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_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;
 }


 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;

 	if (new_memlimit != 0 && new_memlimit < LZMA_MEMUSAGE_BASE)
 		return LZMA_MEMLIMIT_ERROR;

 	return strm->internal->next.memconfig(strm->internal->next.coder,
 			&memusage, &old_memlimit, new_memlimit);
 }
	///////////////////////////////////////////////////////////////////////////////
	//
	/// \file common.h
	/// \brief Common functions needed in many places in liblzma
	//
	// Author: Lasse Collin
	//
	// This file has been put into the public domain.
	// You can do whatever you want with this file.
	//
	///////////////////////////////////////////////////////////////////////////////

	#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 //
	///////////////////////

	extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
	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;
	}


	extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
	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);

	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_int1 != 0
	\|\| 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);

	strm->next_in += in_pos;
	strm->avail_in -= in_pos;
	strm->total_in += in_pos;

	strm->next_out += out_pos;
	strm->avail_out -= out_pos;
	strm->total_out += out_pos;

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

	// Cast is needed to silence a warning about LZMA_TIMED_OUT, which
	// isn't part of lzma_ret enumeration.
	switch ((unsigned int)(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_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;
	}


	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;

	if (new_memlimit != 0 && new_memlimit < LZMA_MEMUSAGE_BASE)
	return LZMA_MEMLIMIT_ERROR;

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