1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file       index_encoder.c
4 /// \brief      Encodes the Index field
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 "index_encoder.h"
14 #include "index.h"
15 #include "check.h"
16 
17 
18 typedef struct {
19 	enum {
20 		SEQ_INDICATOR,
21 		SEQ_COUNT,
22 		SEQ_UNPADDED,
23 		SEQ_UNCOMPRESSED,
24 		SEQ_NEXT,
25 		SEQ_PADDING,
26 		SEQ_CRC32,
27 	} sequence;
28 
29 	/// Index being encoded
30 	const lzma_index *index;
31 
32 	/// Iterator for the Index being encoded
33 	lzma_index_iter iter;
34 
35 	/// Position in integers
36 	size_t pos;
37 
38 	/// CRC32 of the List of Records field
39 	uint32_t crc32;
40 } lzma_index_coder;
41 
42 
43 static lzma_ret
44 index_encode(void *coder_ptr,
45 		const lzma_allocator *allocator lzma_attribute((__unused__)),
46 		const uint8_t *restrict in lzma_attribute((__unused__)),
47 		size_t *restrict in_pos lzma_attribute((__unused__)),
48 		size_t in_size lzma_attribute((__unused__)),
49 		uint8_t *restrict out, size_t *restrict out_pos,
50 		size_t out_size,
51 		lzma_action action lzma_attribute((__unused__)))
52 {
53 	lzma_index_coder *coder = coder_ptr;
54 
55 	// Position where to start calculating CRC32. The idea is that we
56 	// need to call lzma_crc32() only once per call to index_encode().
57 	const size_t out_start = *out_pos;
58 
59 	// Return value to use if we return at the end of this function.
60 	// We use "goto out" to jump out of the while-switch construct
61 	// instead of returning directly, because that way we don't need
62 	// to copypaste the lzma_crc32() call to many places.
63 	lzma_ret ret = LZMA_OK;
64 
65 	while (*out_pos < out_size)
66 	switch (coder->sequence) {
67 	case SEQ_INDICATOR:
68 		out[*out_pos] = INDEX_INDICATOR;
69 		++*out_pos;
70 		coder->sequence = SEQ_COUNT;
71 		break;
72 
73 	case SEQ_COUNT: {
74 		const lzma_vli count = lzma_index_block_count(coder->index);
75 		ret = lzma_vli_encode(count, &coder->pos,
76 				out, out_pos, out_size);
77 		if (ret != LZMA_STREAM_END)
78 			goto out;
79 
80 		ret = LZMA_OK;
81 		coder->pos = 0;
82 		coder->sequence = SEQ_NEXT;
83 		break;
84 	}
85 
86 	case SEQ_NEXT:
87 		if (lzma_index_iter_next(
88 				&coder->iter, LZMA_INDEX_ITER_BLOCK)) {
89 			// Get the size of the Index Padding field.
90 			coder->pos = lzma_index_padding_size(coder->index);
91 			assert(coder->pos <= 3);
92 			coder->sequence = SEQ_PADDING;
93 			break;
94 		}
95 
96 		coder->sequence = SEQ_UNPADDED;
97 
98 	// Fall through
99 
100 	case SEQ_UNPADDED:
101 	case SEQ_UNCOMPRESSED: {
102 		const lzma_vli size = coder->sequence == SEQ_UNPADDED
103 				? coder->iter.block.unpadded_size
104 				: coder->iter.block.uncompressed_size;
105 
106 		ret = lzma_vli_encode(size, &coder->pos,
107 				out, out_pos, out_size);
108 		if (ret != LZMA_STREAM_END)
109 			goto out;
110 
111 		ret = LZMA_OK;
112 		coder->pos = 0;
113 
114 		// Advance to SEQ_UNCOMPRESSED or SEQ_NEXT.
115 		++coder->sequence;
116 		break;
117 	}
118 
119 	case SEQ_PADDING:
120 		if (coder->pos > 0) {
121 			--coder->pos;
122 			out[(*out_pos)++] = 0x00;
123 			break;
124 		}
125 
126 		// Finish the CRC32 calculation.
127 		coder->crc32 = lzma_crc32(out + out_start,
128 				*out_pos - out_start, coder->crc32);
129 
130 		coder->sequence = SEQ_CRC32;
131 
132 	// Fall through
133 
134 	case SEQ_CRC32:
135 		// We don't use the main loop, because we don't want
136 		// coder->crc32 to be touched anymore.
137 		do {
138 			if (*out_pos == out_size)
139 				return LZMA_OK;
140 
141 			out[*out_pos] = (coder->crc32 >> (coder->pos * 8))
142 					& 0xFF;
143 			++*out_pos;
144 
145 		} while (++coder->pos < 4);
146 
147 		return LZMA_STREAM_END;
148 
149 	default:
150 		assert(0);
151 		return LZMA_PROG_ERROR;
152 	}
153 
154 out:
155 	// Update the CRC32.
156 	//
157 	// Avoid null pointer + 0 (undefined behavior) in "out + out_start".
158 	// In such a case we had no input and thus out_used == 0.
159 	{
160 		const size_t out_used = *out_pos - out_start;
161 		if (out_used > 0)
162 			coder->crc32 = lzma_crc32(out + out_start,
163 					out_used, coder->crc32);
164 	}
165 
166 	return ret;
167 }
168 
169 
170 static void
171 index_encoder_end(void *coder, const lzma_allocator *allocator)
172 {
173 	lzma_free(coder, allocator);
174 	return;
175 }
176 
177 
178 static void
179 index_encoder_reset(lzma_index_coder *coder, const lzma_index *i)
180 {
181 	lzma_index_iter_init(&coder->iter, i);
182 
183 	coder->sequence = SEQ_INDICATOR;
184 	coder->index = i;
185 	coder->pos = 0;
186 	coder->crc32 = 0;
187 
188 	return;
189 }
190 
191 
192 extern lzma_ret
193 lzma_index_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
194 		const lzma_index *i)
195 {
196 	lzma_next_coder_init(&lzma_index_encoder_init, next, allocator);
197 
198 	if (i == NULL)
199 		return LZMA_PROG_ERROR;
200 
201 	if (next->coder == NULL) {
202 		next->coder = lzma_alloc(sizeof(lzma_index_coder), allocator);
203 		if (next->coder == NULL)
204 			return LZMA_MEM_ERROR;
205 
206 		next->code = &index_encode;
207 		next->end = &index_encoder_end;
208 	}
209 
210 	index_encoder_reset(next->coder, i);
211 
212 	return LZMA_OK;
213 }
214 
215 
216 extern LZMA_API(lzma_ret)
217 lzma_index_encoder(lzma_stream *strm, const lzma_index *i)
218 {
219 	lzma_next_strm_init(lzma_index_encoder_init, strm, i);
220 
221 	strm->internal->supported_actions[LZMA_RUN] = true;
222 	strm->internal->supported_actions[LZMA_FINISH] = true;
223 
224 	return LZMA_OK;
225 }
226 
227 
228 extern LZMA_API(lzma_ret)
229 lzma_index_buffer_encode(const lzma_index *i,
230 		uint8_t *out, size_t *out_pos, size_t out_size)
231 {
232 	// Validate the arguments.
233 	if (i == NULL || out == NULL || out_pos == NULL || *out_pos > out_size)
234 		return LZMA_PROG_ERROR;
235 
236 	// Don't try to encode if there's not enough output space.
237 	if (out_size - *out_pos < lzma_index_size(i))
238 		return LZMA_BUF_ERROR;
239 
240 	// The Index encoder needs just one small data structure so we can
241 	// allocate it on stack.
242 	lzma_index_coder coder;
243 	index_encoder_reset(&coder, i);
244 
245 	// Do the actual encoding. This should never fail, but store
246 	// the original *out_pos just in case.
247 	const size_t out_start = *out_pos;
248 	lzma_ret ret = index_encode(&coder, NULL, NULL, NULL, 0,
249 			out, out_pos, out_size, LZMA_RUN);
250 
251 	if (ret == LZMA_STREAM_END) {
252 		ret = LZMA_OK;
253 	} else {
254 		// We should never get here, but just in case, restore the
255 		// output position and set the error accordingly if something
256 		// goes wrong and debugging isn't enabled.
257 		assert(0);
258 		*out_pos = out_start;
259 		ret = LZMA_PROG_ERROR;
260 	}
261 
262 	return ret;
263 }
264