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