1// SPDX-License-Identifier: 0BSD
2
3///////////////////////////////////////////////////////////////////////////////
4//
5/// \file       auto_decoder.c
6/// \brief      Autodetect between .xz, .lzma (LZMA_Alone), and .lz (lzip)
7//
8//  Author:     Lasse Collin
9//
10///////////////////////////////////////////////////////////////////////////////
11
12#include "stream_decoder.h"
13#include "alone_decoder.h"
14#ifdef HAVE_LZIP_DECODER
15#	include "lzip_decoder.h"
16#endif
17
18
19typedef struct {
20	/// .xz Stream decoder, LZMA_Alone decoder, or lzip decoder
21	lzma_next_coder next;
22
23	uint64_t memlimit;
24	uint32_t flags;
25
26	enum {
27		SEQ_INIT,
28		SEQ_CODE,
29		SEQ_FINISH,
30	} sequence;
31} lzma_auto_coder;
32
33
34static lzma_ret
35auto_decode(void *coder_ptr, const lzma_allocator *allocator,
36		const uint8_t *restrict in, size_t *restrict in_pos,
37		size_t in_size, uint8_t *restrict out,
38		size_t *restrict out_pos, size_t out_size, lzma_action action)
39{
40	lzma_auto_coder *coder = coder_ptr;
41
42	switch (coder->sequence) {
43	case SEQ_INIT:
44		if (*in_pos >= in_size)
45			return LZMA_OK;
46
47		// Update the sequence now, because we want to continue from
48		// SEQ_CODE even if we return some LZMA_*_CHECK.
49		coder->sequence = SEQ_CODE;
50
51		// Detect the file format. .xz files start with 0xFD which
52		// cannot be the first byte of .lzma (LZMA_Alone) format.
53		// The .lz format starts with 0x4C which could be the
54		// first byte of a .lzma file but luckily it would mean
55		// lc/lp/pb being 4/3/1 which liblzma doesn't support because
56		// lc + lp > 4. So using just 0x4C to detect .lz is OK here.
57		if (in[*in_pos] == 0xFD) {
58			return_if_error(lzma_stream_decoder_init(
59					&coder->next, allocator,
60					coder->memlimit, coder->flags));
61#ifdef HAVE_LZIP_DECODER
62		} else if (in[*in_pos] == 0x4C) {
63			return_if_error(lzma_lzip_decoder_init(
64					&coder->next, allocator,
65					coder->memlimit, coder->flags));
66#endif
67		} else {
68			return_if_error(lzma_alone_decoder_init(&coder->next,
69					allocator, coder->memlimit, true));
70
71			// If the application wants to know about missing
72			// integrity check or about the check in general, we
73			// need to handle it here, because LZMA_Alone decoder
74			// doesn't accept any flags.
75			if (coder->flags & LZMA_TELL_NO_CHECK)
76				return LZMA_NO_CHECK;
77
78			if (coder->flags & LZMA_TELL_ANY_CHECK)
79				return LZMA_GET_CHECK;
80		}
81
82	// Fall through
83
84	case SEQ_CODE: {
85		const lzma_ret ret = coder->next.code(
86				coder->next.coder, allocator,
87				in, in_pos, in_size,
88				out, out_pos, out_size, action);
89		if (ret != LZMA_STREAM_END
90				|| (coder->flags & LZMA_CONCATENATED) == 0)
91			return ret;
92
93		coder->sequence = SEQ_FINISH;
94	}
95
96	// Fall through
97
98	case SEQ_FINISH:
99		// When LZMA_CONCATENATED was used and we were decoding
100		// a LZMA_Alone file, we need to check that there is no
101		// trailing garbage and wait for LZMA_FINISH.
102		if (*in_pos < in_size)
103			return LZMA_DATA_ERROR;
104
105		return action == LZMA_FINISH ? LZMA_STREAM_END : LZMA_OK;
106
107	default:
108		assert(0);
109		return LZMA_PROG_ERROR;
110	}
111}
112
113
114static void
115auto_decoder_end(void *coder_ptr, const lzma_allocator *allocator)
116{
117	lzma_auto_coder *coder = coder_ptr;
118	lzma_next_end(&coder->next, allocator);
119	lzma_free(coder, allocator);
120	return;
121}
122
123
124static lzma_check
125auto_decoder_get_check(const void *coder_ptr)
126{
127	const lzma_auto_coder *coder = coder_ptr;
128
129	// It is LZMA_Alone if get_check is NULL.
130	return coder->next.get_check == NULL ? LZMA_CHECK_NONE
131			: coder->next.get_check(coder->next.coder);
132}
133
134
135static lzma_ret
136auto_decoder_memconfig(void *coder_ptr, uint64_t *memusage,
137		uint64_t *old_memlimit, uint64_t new_memlimit)
138{
139	lzma_auto_coder *coder = coder_ptr;
140
141	lzma_ret ret;
142
143	if (coder->next.memconfig != NULL) {
144		ret = coder->next.memconfig(coder->next.coder,
145				memusage, old_memlimit, new_memlimit);
146		assert(*old_memlimit == coder->memlimit);
147	} else {
148		// No coder is configured yet. Use the base value as
149		// the current memory usage.
150		*memusage = LZMA_MEMUSAGE_BASE;
151		*old_memlimit = coder->memlimit;
152
153		ret = LZMA_OK;
154		if (new_memlimit != 0 && new_memlimit < *memusage)
155			ret = LZMA_MEMLIMIT_ERROR;
156	}
157
158	if (ret == LZMA_OK && new_memlimit != 0)
159		coder->memlimit = new_memlimit;
160
161	return ret;
162}
163
164
165static lzma_ret
166auto_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
167		uint64_t memlimit, uint32_t flags)
168{
169	lzma_next_coder_init(&auto_decoder_init, next, allocator);
170
171	if (flags & ~LZMA_SUPPORTED_FLAGS)
172		return LZMA_OPTIONS_ERROR;
173
174	lzma_auto_coder *coder = next->coder;
175	if (coder == NULL) {
176		coder = lzma_alloc(sizeof(lzma_auto_coder), allocator);
177		if (coder == NULL)
178			return LZMA_MEM_ERROR;
179
180		next->coder = coder;
181		next->code = &auto_decode;
182		next->end = &auto_decoder_end;
183		next->get_check = &auto_decoder_get_check;
184		next->memconfig = &auto_decoder_memconfig;
185		coder->next = LZMA_NEXT_CODER_INIT;
186	}
187
188	coder->memlimit = my_max(1, memlimit);
189	coder->flags = flags;
190	coder->sequence = SEQ_INIT;
191
192	return LZMA_OK;
193}
194
195
196extern LZMA_API(lzma_ret)
197lzma_auto_decoder(lzma_stream *strm, uint64_t memlimit, uint32_t flags)
198{
199	lzma_next_strm_init(auto_decoder_init, strm, memlimit, flags);
200
201	strm->internal->supported_actions[LZMA_RUN] = true;
202	strm->internal->supported_actions[LZMA_FINISH] = true;
203
204	return LZMA_OK;
205}
206