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] = 0x00;
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 	coder->crc32 = lzma_crc32(out + out_start,
157 			*out_pos - out_start, coder->crc32);
158 
159 	return ret;
160 }
161 
162 
163 static void
164 index_encoder_end(void *coder, const lzma_allocator *allocator)
165 {
166 	lzma_free(coder, allocator);
167 	return;
168 }
169 
170 
171 static void
172 index_encoder_reset(lzma_index_coder *coder, const lzma_index *i)
173 {
174 	lzma_index_iter_init(&coder->iter, i);
175 
176 	coder->sequence = SEQ_INDICATOR;
177 	coder->index = i;
178 	coder->pos = 0;
179 	coder->crc32 = 0;
180 
181 	return;
182 }
183 
184 
185 extern lzma_ret
186 lzma_index_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
187 		const lzma_index *i)
188 {
189 	lzma_next_coder_init(&lzma_index_encoder_init, next, allocator);
190 
191 	if (i == NULL)
192 		return LZMA_PROG_ERROR;
193 
194 	if (next->coder == NULL) {
195 		next->coder = lzma_alloc(sizeof(lzma_index_coder), allocator);
196 		if (next->coder == NULL)
197 			return LZMA_MEM_ERROR;
198 
199 		next->code = &index_encode;
200 		next->end = &index_encoder_end;
201 	}
202 
203 	index_encoder_reset(next->coder, i);
204 
205 	return LZMA_OK;
206 }
207 
208 
209 extern LZMA_API(lzma_ret)
210 lzma_index_encoder(lzma_stream *strm, const lzma_index *i)
211 {
212 	lzma_next_strm_init(lzma_index_encoder_init, strm, i);
213 
214 	strm->internal->supported_actions[LZMA_RUN] = true;
215 	strm->internal->supported_actions[LZMA_FINISH] = true;
216 
217 	return LZMA_OK;
218 }
219 
220 
221 extern LZMA_API(lzma_ret)
222 lzma_index_buffer_encode(const lzma_index *i,
223 		uint8_t *out, size_t *out_pos, size_t out_size)
224 {
225 	// Validate the arguments.
226 	if (i == NULL || out == NULL || out_pos == NULL || *out_pos > out_size)
227 		return LZMA_PROG_ERROR;
228 
229 	// Don't try to encode if there's not enough output space.
230 	if (out_size - *out_pos < lzma_index_size(i))
231 		return LZMA_BUF_ERROR;
232 
233 	// The Index encoder needs just one small data structure so we can
234 	// allocate it on stack.
235 	lzma_index_coder coder;
236 	index_encoder_reset(&coder, i);
237 
238 	// Do the actual encoding. This should never fail, but store
239 	// the original *out_pos just in case.
240 	const size_t out_start = *out_pos;
241 	lzma_ret ret = index_encode(&coder, NULL, NULL, NULL, 0,
242 			out, out_pos, out_size, LZMA_RUN);
243 
244 	if (ret == LZMA_STREAM_END) {
245 		ret = LZMA_OK;
246 	} else {
247 		// We should never get here, but just in case, restore the
248 		// output position and set the error accordingly if something
249 		// goes wrong and debugging isn't enabled.
250 		assert(0);
251 		*out_pos = out_start;
252 		ret = LZMA_PROG_ERROR;
253 	}
254 
255 	return ret;
256 }
257