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