?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
python:tests: Use ‘False’ in boolean expression rather than ‘None’
[Samba.git] / librpc / ndr / ndr_compression.c
blob6630b5170effe2269a56fb4e6586b966a7e10716
1 /*
2 Unix SMB/CIFS implementation.
3
4 libndr compression support
5
6 Copyright (C) Stefan Metzmacher 2005
7 Copyright (C) Matthieu Suiche 2008
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "../lib/compression/lzxpress.h"
25 #include "../lib/compression/lzxpress_huffman.h"
26 #include "librpc/ndr/libndr.h"
27 #include "../librpc/ndr/ndr_compression.h"
28 #include <zlib.h>
29
30 struct ndr_compression_state {
31 enum ndr_compression_alg type;
32 union {
33 struct {
34 struct z_stream_s *z;
35 uint8_t *dict;
36 size_t dict_size;
37 } mszip;
38 struct {
39 struct lzxhuff_compressor_mem *mem;
40 } lzxpress_huffman;
41 } alg;
42 };
43
44 static voidpf ndr_zlib_alloc(voidpf opaque, uInt items, uInt size)
45 {
46 return talloc_zero_size(opaque, items * size);
47 }
48
49 static void ndr_zlib_free(voidpf opaque, voidpf address)
50 {
51 talloc_free(address);
52 }
53
54 static enum ndr_err_code ndr_pull_compression_mszip_cab_chunk(struct ndr_pull *ndrpull,
55 struct ndr_push *ndrpush,
56 struct ndr_compression_state *state,
57 ssize_t decompressed_len,
58 ssize_t compressed_len)
59 {
60 DATA_BLOB comp_chunk;
61 uint32_t comp_chunk_offset;
62 uint32_t comp_chunk_size;
63 DATA_BLOB plain_chunk;
64 uint32_t plain_chunk_offset;
65 uint32_t plain_chunk_size;
66 z_stream *z = state->alg.mszip.z;
67 int z_ret;
68
69 plain_chunk_size = decompressed_len;
70
71 if (plain_chunk_size > 0x00008000) {
72 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
73 "Bad MSZIP CAB plain chunk size %08"PRIX32" > 0x00008000 (PULL)",
74 plain_chunk_size);
75 }
76
77
78 comp_chunk_size = compressed_len;
79
80 DEBUG(9,("MSZIP CAB plain_chunk_size: %08"PRIX32" (%"PRIu32") comp_chunk_size: %08"PRIX32" (%"PRIu32")\n",
81 plain_chunk_size, plain_chunk_size, comp_chunk_size, comp_chunk_size));
82
83 comp_chunk_offset = ndrpull->offset;
84 NDR_CHECK(ndr_pull_advance(ndrpull, comp_chunk_size));
85 comp_chunk.length = comp_chunk_size;
86 comp_chunk.data = ndrpull->data + comp_chunk_offset;
87
88 plain_chunk_offset = ndrpush->offset;
89 NDR_CHECK(ndr_push_zero(ndrpush, plain_chunk_size));
90 plain_chunk.length = plain_chunk_size;
91 plain_chunk.data = ndrpush->data + plain_chunk_offset;
92
93 if (comp_chunk.length < 2) {
94 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
95 "Bad MSZIP CAB comp chunk size %zu < 2 (PULL)",
96 comp_chunk.length);
97 }
98 /* CK = Chris Kirmse, official Microsoft purloiner */
99 if (comp_chunk.data[0] != 'C' ||
100 comp_chunk.data[1] != 'K') {
101 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
102 "Bad MSZIP CAB invalid prefix [%c%c] != [CK]",
103 comp_chunk.data[0], comp_chunk.data[1]);
104 }
105
106 /*
107 * This is a MSZIP block. It is actually using the deflate
108 * algorithm which can be decompressed by zlib. zlib will try
109 * to decompress as much as it can in each run. If we provide
110 * all the input and enough room for the uncompressed output,
111 * one call is enough. It will loop over all the sub-blocks
112 * that make up a deflate block.
113 *
114 * See corresponding push function for more info.
115 */
116
117 z->next_in = comp_chunk.data + 2;
118 z->avail_in = comp_chunk.length - 2;
119 z->next_out = plain_chunk.data;
120 z->avail_out = plain_chunk.length;
121
122 /*
123 * Each MSZIP CDATA contains a complete deflate stream
124 * i.e. the stream starts and ends in the CFDATA but the
125 * _dictionary_ is shared between all CFDATA of a CFFOLDER.
126 *
127 * When decompressing, the initial dictionary of the first
128 * CDATA is empty. All other CFDATA use the previous CFDATA
129 * uncompressed output as dictionary.
130 */
131
132 if (state->alg.mszip.dict_size) {
133 z_ret = inflateSetDictionary(z, state->alg.mszip.dict, state->alg.mszip.dict_size);
134 if (z_ret != Z_OK) {
135 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
136 "zlib inflateSetDictionary error %s (%d) %s (PULL)",
137 zError(z_ret), z_ret, z->msg);
138 }
139 }
140
141 z_ret = inflate(z, Z_FINISH);
142 if (z_ret == Z_OK) {
143 /*
144 * Z_OK here means there was no error but the stream
145 * hasn't been fully decompressed because there was
146 * not enough room for the output, which should not
147 * happen
148 */
149 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
150 "zlib inflate error not enough space for output (PULL)");
151 }
152 if (z_ret != Z_STREAM_END) {
153 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
154 "zlib inflate error %s (%d) %s (PULL)", zError(z_ret), z_ret, z->msg);
155 }
156
157 if (z->total_out < plain_chunk.length) {
158 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
159 "zlib uncompressed output is smaller than expected (%lu < %zu) (PULL)",
160 z->total_out, plain_chunk.length);
161 }
162
163 /*
164 * Keep a copy of the output to set as dictionary for the
165 * next decompression call.
166 *
167 * The input pointer seems to be still valid between calls, so
168 * we can just store that instead of copying the memory over
169 * the dict temp buffer.
170 */
171 state->alg.mszip.dict = plain_chunk.data;
172 state->alg.mszip.dict_size = plain_chunk.length;
173
174 z_ret = inflateReset(z);
175 if (z_ret != Z_OK) {
176 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
177 "zlib inflateReset error %s (%d) %s (PULL)",
178 zError(z_ret), z_ret, z->msg);
179 }
180
181 return NDR_ERR_SUCCESS;
182 }
183
184 static enum ndr_err_code ndr_push_compression_mszip_cab_chunk(struct ndr_push *ndrpush,
185 struct ndr_pull *ndrpull,
186 struct ndr_compression_state *state)
187 {
188 DATA_BLOB comp_chunk;
189 uint32_t comp_chunk_size;
190 DATA_BLOB plain_chunk;
191 uint32_t plain_chunk_size;
192 uint32_t plain_chunk_offset;
193 uint32_t max_plain_size = 0x00008000;
194 /*
195 * The maximum compressed size of each MSZIP block is 32k + 12 bytes
196 * header size.
197 */
198 uint32_t max_comp_size = 0x00008000 + 12;
199 int z_ret;
200 z_stream *z;
201
202 if (ndrpull->data_size <= ndrpull->offset) {
203 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
204 "strange NDR pull size and offset (integer overflow?)");
205
206 }
207
208 plain_chunk_size = MIN(max_plain_size, ndrpull->data_size - ndrpull->offset);
209 plain_chunk_offset = ndrpull->offset;
210 NDR_CHECK(ndr_pull_advance(ndrpull, plain_chunk_size));
211
212 plain_chunk.data = ndrpull->data + plain_chunk_offset;
213 plain_chunk.length = plain_chunk_size;
214
215 NDR_CHECK(ndr_push_expand(ndrpush, max_comp_size));
216
217 comp_chunk.data = ndrpush->data + ndrpush->offset;
218 comp_chunk.length = max_comp_size;
219
220 /* CK = Chris Kirmse, official Microsoft purloiner */
221 comp_chunk.data[0] = 'C';
222 comp_chunk.data[1] = 'K';
223
224 z = state->alg.mszip.z;
225 z->next_in = plain_chunk.data;
226 z->avail_in = plain_chunk.length;
227 z->total_in = 0;
228
229 z->next_out = comp_chunk.data + 2;
230 z->avail_out = comp_chunk.length;
231 z->total_out = 0;
232
233 /*
234 * See pull function for explanations of the MSZIP format.
235 *
236 * The CFDATA block contains a full deflate stream. Each stream
237 * uses the uncompressed input of the previous CFDATA in the
238 * same CFFOLDER as a dictionary for the compression.
239 */
240
241 if (state->alg.mszip.dict_size) {
242 z_ret = deflateSetDictionary(z, state->alg.mszip.dict, state->alg.mszip.dict_size);
243 if (z_ret != Z_OK) {
244 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
245 "zlib deflateSetDictionary error %s (%d) %s (PUSH)",
246 zError(z_ret), z_ret, z->msg);
247 }
248 }
249
250 /*
251 * Z_FINISH should make deflate process all of the input in
252 * one call. If the stream is not finished there was an error
253 * e.g. not enough room to store the compressed output.
254 */
255 z_ret = deflate(z, Z_FINISH);
256 if (z_ret != Z_STREAM_END) {
257 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
258 "zlib deflate error %s (%d) %s (PUSH)",
259 zError(z_ret), z_ret, z->msg);
260 }
261
262 if (z->avail_in) {
263 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
264 "MSZIP not all avail_in[%u] bytes consumed (PUSH)",
265 z->avail_in);
266 }
267
268 comp_chunk_size = 2 + z->total_out;
269 if (comp_chunk_size < z->total_out) {
270 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
271 "strange NDR push compressed size (integer overflow?)");
272 }
273
274 z_ret = deflateReset(z);
275 if (z_ret != Z_OK) {
276 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
277 "zlib deflateReset error %s (%d) %s (PUSH)",
278 zError(z_ret), z_ret, z->msg);
279 }
280
281 if (plain_chunk.length > talloc_array_length(state->alg.mszip.dict)) {
282 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
283 "zlib dict buffer is too big (PUSH)");
284 }
285
286 /*
287 * Keep a copy of the input to set as dictionary for the next
288 * compression call.
289 *
290 * Ideally we would just store the input pointer and length
291 * without copying but the memory gets invalidated between the
292 * calls, so we just copy to a dedicated buffer we know is
293 * still going to be valid for the lifetime of the
294 * compressions state object.
295 */
296 memcpy(state->alg.mszip.dict, plain_chunk.data, plain_chunk.length);
297 state->alg.mszip.dict_size = plain_chunk.length;
298
299 DEBUG(9,("MSZIP comp plain_chunk_size: %08zX (%zu) comp_chunk_size: %08"PRIX32" (%"PRIu32")\n",
300 plain_chunk.length,
301 plain_chunk.length,
302 comp_chunk_size, comp_chunk_size));
303
304 ndrpush->offset += comp_chunk_size;
305 return NDR_ERR_SUCCESS;
306 }
307
308
309 static enum ndr_err_code ndr_pull_compression_mszip_chunk(struct ndr_pull *ndrpull,
310 struct ndr_push *ndrpush,
311 z_stream *z,
312 bool *last)
313 {
314 DATA_BLOB comp_chunk;
315 uint32_t comp_chunk_offset;
316 uint32_t comp_chunk_size;
317 DATA_BLOB plain_chunk;
318 uint32_t plain_chunk_offset;
319 uint32_t plain_chunk_size;
320 int z_ret;
321
322 NDR_CHECK(ndr_pull_uint32(ndrpull, NDR_SCALARS, &plain_chunk_size));
323 if (plain_chunk_size > 0x00008000) {
324 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION, "Bad MSZIP plain chunk size %08"PRIX32" > 0x00008000 (PULL)",
325 plain_chunk_size);
326 }
327
328 NDR_CHECK(ndr_pull_uint32(ndrpull, NDR_SCALARS, &comp_chunk_size));
329
330 DEBUG(9,("MSZIP plain_chunk_size: %08"PRIX32" (%"PRIu32") comp_chunk_size: %08"PRIX32" (%"PRIu32")\n",
331 plain_chunk_size, plain_chunk_size, comp_chunk_size, comp_chunk_size));
332
333 comp_chunk_offset = ndrpull->offset;
334 NDR_CHECK(ndr_pull_advance(ndrpull, comp_chunk_size));
335 comp_chunk.length = comp_chunk_size;
336 comp_chunk.data = ndrpull->data + comp_chunk_offset;
337
338 plain_chunk_offset = ndrpush->offset;
339 NDR_CHECK(ndr_push_zero(ndrpush, plain_chunk_size));
340 plain_chunk.length = plain_chunk_size;
341 plain_chunk.data = ndrpush->data + plain_chunk_offset;
342
343 if (comp_chunk.length < 2) {
344 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
345 "Bad MSZIP comp chunk size %zu < 2 (PULL)",
346 comp_chunk.length);
347 }
348 /* CK = Chris Kirmse, official Microsoft purloiner */
349 if (comp_chunk.data[0] != 'C' ||
350 comp_chunk.data[1] != 'K') {
351 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
352 "Bad MSZIP invalid prefix [%c%c] != [CK]",
353 comp_chunk.data[0], comp_chunk.data[1]);
354 }
355
356 z->next_in = comp_chunk.data + 2;
357 z->avail_in = comp_chunk.length -2;
358 z->total_in = 0;
359
360 z->next_out = plain_chunk.data;
361 z->avail_out = plain_chunk.length;
362 z->total_out = 0;
363
364 if (!z->opaque) {
365 /* the first time we need to initialize completely */
366 z->zalloc = ndr_zlib_alloc;
367 z->zfree = ndr_zlib_free;
368 z->opaque = ndrpull;
369
370 z_ret = inflateInit2(z, -MAX_WBITS);
371 if (z_ret != Z_OK) {
372 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
373 "Bad inflateInit2 error %s(%d) (PULL)",
374 zError(z_ret), z_ret);
375
376 }
377 }
378
379 /* call inflate until we get Z_STREAM_END or an error */
380 while (true) {
381 z_ret = inflate(z, Z_BLOCK);
382 if (z_ret != Z_OK) break;
383 }
384
385 if (z_ret != Z_STREAM_END) {
386 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
387 "Bad inflate(Z_BLOCK) error %s(%d) (PULL)",
388 zError(z_ret), z_ret);
389 }
390
391 if (z->avail_in) {
392 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
393 "MSZIP not all avail_in[%u] bytes consumed (PULL)",
394 z->avail_in);
395 }
396
397 if (z->avail_out) {
398 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
399 "MSZIP not all avail_out[%u] bytes consumed (PULL)",
400 z->avail_out);
401 }
402
403 if ((plain_chunk_size < 0x00008000) || (ndrpull->offset+4 >= ndrpull->data_size)) {
404 /* this is the last chunk */
405 *last = true;
406 }
407
408 z_ret = inflateReset(z);
409 if (z_ret != Z_OK) {
410 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
411 "Bad inflateReset error %s(%d) (PULL)",
412 zError(z_ret), z_ret);
413 }
414
415 z_ret = inflateSetDictionary(z, plain_chunk.data, plain_chunk.length);
416 if (z_ret != Z_OK) {
417 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
418 "Bad inflateSetDictionary error %s(%d) (PULL)",
419 zError(z_ret), z_ret);
420 }
421
422 return NDR_ERR_SUCCESS;
423 }
424
425 static enum ndr_err_code ndr_push_compression_mszip_chunk(struct ndr_push *ndrpush,
426 struct ndr_pull *ndrpull,
427 z_stream *z,
428 bool *last)
429 {
430 DATA_BLOB comp_chunk;
431 uint32_t comp_chunk_size;
432 uint32_t comp_chunk_size_offset;
433 DATA_BLOB plain_chunk;
434 uint32_t plain_chunk_size;
435 uint32_t plain_chunk_offset;
436 uint32_t max_plain_size = 0x00008000;
437 /*
438 * The maximum compressed size of each MSZIP block is 32k + 12 bytes
439 * header size.
440 */
441 uint32_t max_comp_size = 0x00008000 + 12;
442 uint32_t tmp_offset;
443 int z_ret;
444
445 plain_chunk_size = MIN(max_plain_size, ndrpull->data_size - ndrpull->offset);
446 plain_chunk_offset = ndrpull->offset;
447 NDR_CHECK(ndr_pull_advance(ndrpull, plain_chunk_size));
448
449 plain_chunk.data = ndrpull->data + plain_chunk_offset;
450 plain_chunk.length = plain_chunk_size;
451
452 if (plain_chunk_size < max_plain_size) {
453 *last = true;
454 }
455
456 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, plain_chunk_size));
457 comp_chunk_size_offset = ndrpush->offset;
458 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, 0xFEFEFEFE));
459
460 NDR_CHECK(ndr_push_expand(ndrpush, max_comp_size));
461
462 comp_chunk.data = ndrpush->data + ndrpush->offset;
463 comp_chunk.length = max_comp_size;
464
465 /* CK = Chris Kirmse, official Microsoft purloiner */
466 comp_chunk.data[0] = 'C';
467 comp_chunk.data[1] = 'K';
468
469 z->next_in = plain_chunk.data;
470 z->avail_in = plain_chunk.length;
471 z->total_in = 0;
472
473 z->next_out = comp_chunk.data + 2;
474 z->avail_out = comp_chunk.length;
475 z->total_out = 0;
476
477 if (!z->opaque) {
478 /* the first time we need to initialize completely */
479 z->zalloc = ndr_zlib_alloc;
480 z->zfree = ndr_zlib_free;
481 z->opaque = ndrpull;
482
483 /* TODO: find how to trigger the same parameters windows uses */
484 z_ret = deflateInit2(z,
485 Z_DEFAULT_COMPRESSION,
486 Z_DEFLATED,
487 -MAX_WBITS,
488 8, /* memLevel */
489 Z_DEFAULT_STRATEGY);
490 if (z_ret != Z_OK) {
491 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
492 "Bad deflateInit2 error %s(%d) (PUSH)",
493 zError(z_ret), z_ret);
494
495 }
496 }
497
498 /* call deflate until we get Z_STREAM_END or an error */
499 while (true) {
500 z_ret = deflate(z, Z_FINISH);
501 if (z_ret != Z_OK) break;
502 }
503 if (z_ret != Z_STREAM_END) {
504 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
505 "Bad deflate(Z_BLOCK) error %s(%d) (PUSH)",
506 zError(z_ret), z_ret);
507 }
508
509 if (z->avail_in) {
510 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
511 "MSZIP not all avail_in[%u] bytes consumed (PUSH)",
512 z->avail_in);
513 }
514
515 comp_chunk_size = 2 + z->total_out;
516
517 z_ret = deflateReset(z);
518 if (z_ret != Z_OK) {
519 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
520 "Bad deflateReset error %s(%d) (PULL)",
521 zError(z_ret), z_ret);
522 }
523
524 z_ret = deflateSetDictionary(z, plain_chunk.data, plain_chunk.length);
525 if (z_ret != Z_OK) {
526 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
527 "Bad deflateSetDictionary error %s(%d) (PULL)",
528 zError(z_ret), z_ret);
529 }
530
531 tmp_offset = ndrpush->offset;
532 ndrpush->offset = comp_chunk_size_offset;
533 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, comp_chunk_size));
534 ndrpush->offset = tmp_offset;
535
536 DEBUG(9,("MSZIP comp plain_chunk_size: %08zX (%zu) comp_chunk_size: %08"PRIX32" (%"PRIu32")\n",
537 plain_chunk.length,
538 plain_chunk.length,
539 comp_chunk_size, comp_chunk_size));
540
541 ndrpush->offset += comp_chunk_size;
542 return NDR_ERR_SUCCESS;
543 }
544
545 static enum ndr_err_code ndr_pull_compression_xpress_chunk(struct ndr_pull *ndrpull,
546 struct ndr_push *ndrpush,
547 bool *last)
548 {
549 DATA_BLOB comp_chunk;
550 DATA_BLOB plain_chunk;
551 uint32_t comp_chunk_offset;
552 uint32_t plain_chunk_offset;
553 uint32_t comp_chunk_size;
554 uint32_t plain_chunk_size;
555 ssize_t ret;
556
557 NDR_CHECK(ndr_pull_uint32(ndrpull, NDR_SCALARS, &plain_chunk_size));
558 if (plain_chunk_size > 0x00010000) {
559 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION, "Bad XPRESS plain chunk size %08"PRIX32" > 0x00010000 (PULL)",
560 plain_chunk_size);
561 }
562
563 NDR_CHECK(ndr_pull_uint32(ndrpull, NDR_SCALARS, &comp_chunk_size));
564
565 comp_chunk_offset = ndrpull->offset;
566 NDR_CHECK(ndr_pull_advance(ndrpull, comp_chunk_size));
567 comp_chunk.length = comp_chunk_size;
568 comp_chunk.data = ndrpull->data + comp_chunk_offset;
569
570 plain_chunk_offset = ndrpush->offset;
571 NDR_CHECK(ndr_push_zero(ndrpush, plain_chunk_size));
572 plain_chunk.length = plain_chunk_size;
573 plain_chunk.data = ndrpush->data + plain_chunk_offset;
574
575 DEBUG(9,("XPRESS plain_chunk_size: %08"PRIX32" (%"PRIu32") comp_chunk_size: %08"PRIX32" (%"PRIu32")\n",
576 plain_chunk_size, plain_chunk_size, comp_chunk_size, comp_chunk_size));
577
578 /* Uncompressing the buffer using LZ Xpress algorithm */
579 ret = lzxpress_decompress(comp_chunk.data,
580 comp_chunk.length,
581 plain_chunk.data,
582 plain_chunk.length);
583 if (ret < 0) {
584 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
585 "XPRESS lzxpress_decompress() returned %zd\n",
586 ret);
587 }
588 plain_chunk.length = ret;
589
590 if ((plain_chunk_size < 0x00010000) || (ndrpull->offset+4 >= ndrpull->data_size)) {
591 /* this is the last chunk */
592 *last = true;
593 }
594
595 return NDR_ERR_SUCCESS;
596 }
597
598 static enum ndr_err_code ndr_push_compression_xpress_chunk(struct ndr_push *ndrpush,
599 struct ndr_pull *ndrpull,
600 bool *last)
601 {
602 DATA_BLOB comp_chunk;
603 uint32_t comp_chunk_size_offset;
604 DATA_BLOB plain_chunk;
605 uint32_t plain_chunk_size;
606 uint32_t plain_chunk_offset;
607 uint32_t max_plain_size = 0x00010000;
608 uint32_t max_comp_size = 0x00020000 + 2; /* TODO: use the correct value here */
609 uint32_t tmp_offset;
610 ssize_t ret;
611
612 plain_chunk_size = MIN(max_plain_size, ndrpull->data_size - ndrpull->offset);
613 plain_chunk_offset = ndrpull->offset;
614 NDR_CHECK(ndr_pull_advance(ndrpull, plain_chunk_size));
615
616 plain_chunk.data = ndrpull->data + plain_chunk_offset;
617 plain_chunk.length = plain_chunk_size;
618
619 if (plain_chunk_size < max_plain_size) {
620 *last = true;
621 }
622
623 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, plain_chunk_size));
624 comp_chunk_size_offset = ndrpush->offset;
625 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, 0xFEFEFEFE));
626
627 NDR_CHECK(ndr_push_expand(ndrpush, max_comp_size));
628
629 comp_chunk.data = ndrpush->data + ndrpush->offset;
630 comp_chunk.length = max_comp_size;
631
632 /* Compressing the buffer using LZ Xpress algorithm */
633 ret = lzxpress_compress(plain_chunk.data,
634 plain_chunk.length,
635 comp_chunk.data,
636 comp_chunk.length);
637 if (ret < 0) {
638 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
639 "XPRESS lzxpress_compress() returned %zd\n",
640 ret);
641 }
642 comp_chunk.length = ret;
643
644 tmp_offset = ndrpush->offset;
645 ndrpush->offset = comp_chunk_size_offset;
646 NDR_CHECK(ndr_push_uint32(ndrpush, NDR_SCALARS, comp_chunk.length));
647 ndrpush->offset = tmp_offset;
648
649 ndrpush->offset += comp_chunk.length;
650 return NDR_ERR_SUCCESS;
651 }
652
653 static enum ndr_err_code ndr_pull_compression_none(struct ndr_pull *ndrpull,
654 struct ndr_push *ndrpush,
655 ssize_t decompressed_len,
656 ssize_t compressed_len)
657 {
658 DATA_BLOB comp_chunk;
659 uint32_t comp_chunk_size = compressed_len;
660 uint32_t comp_chunk_offset;
661
662 if (decompressed_len != compressed_len) {
663 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
664 "decompressed len %zd != compressed_len %zd in 'NONE' compression!",
665 decompressed_len,
666 compressed_len);
667 }
668
669 if (comp_chunk_size != compressed_len) {
670 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
671 "compressed_len %zd overflows uint32_t in 'NONE' compression!",
672 compressed_len);
673 }
674
675 comp_chunk_offset = ndrpull->offset;
676 NDR_CHECK(ndr_pull_advance(ndrpull, comp_chunk_size));
677 comp_chunk.length = comp_chunk_size;
678 comp_chunk.data = ndrpull->data + comp_chunk_offset;
679
680 NDR_CHECK(ndr_push_array_uint8(ndrpush,
681 NDR_SCALARS,
682 comp_chunk.data,
683 comp_chunk.length));
684
685 return NDR_ERR_SUCCESS;
686 }
687
688 static enum ndr_err_code ndr_push_compression_none(struct ndr_push *ndrpush,
689 struct ndr_pull *ndrpull)
690 {
691 DATA_BLOB plain_chunk;
692 uint32_t plain_chunk_size;
693 uint32_t plain_chunk_offset;
694
695 plain_chunk_size = ndrpull->data_size - ndrpull->offset;
696 plain_chunk_offset = ndrpull->offset;
697 NDR_CHECK(ndr_pull_advance(ndrpull, plain_chunk_size));
698
699 plain_chunk.data = ndrpull->data + plain_chunk_offset;
700 plain_chunk.length = plain_chunk_size;
701
702 NDR_CHECK(ndr_push_array_uint8(ndrpush,
703 NDR_SCALARS,
704 plain_chunk.data,
705 plain_chunk.length));
706 return NDR_ERR_SUCCESS;
707 }
708
709 static enum ndr_err_code ndr_pull_compression_xpress_huff_raw_chunk(struct ndr_pull *ndrpull,
710 struct ndr_push *ndrpush,
711 ssize_t decompressed_len,
712 ssize_t compressed_len)
713 {
714 DATA_BLOB comp_chunk;
715 uint32_t comp_chunk_offset;
716 uint32_t comp_chunk_size;
717 DATA_BLOB plain_chunk;
718 uint32_t plain_chunk_offset;
719 uint32_t plain_chunk_size;
720 ssize_t ret;
721
722 plain_chunk_size = decompressed_len;
723 comp_chunk_size = compressed_len;
724
725 DEBUG(9,("XPRESS_HUFF plain_chunk_size: %08X (%u) comp_chunk_size: %08X (%u)\n",
726 plain_chunk_size, plain_chunk_size, comp_chunk_size, comp_chunk_size));
727
728 comp_chunk_offset = ndrpull->offset;
729 NDR_CHECK(ndr_pull_advance(ndrpull, comp_chunk_size));
730 comp_chunk.length = comp_chunk_size;
731 comp_chunk.data = ndrpull->data + comp_chunk_offset;
732
733 plain_chunk_offset = ndrpush->offset;
734 NDR_CHECK(ndr_push_zero(ndrpush, plain_chunk_size));
735 plain_chunk.length = plain_chunk_size;
736 plain_chunk.data = ndrpush->data + plain_chunk_offset;
737
738 /* Decompressing the buffer using LZ Xpress w/ Huffman algorithm */
739 ret = lzxpress_huffman_decompress(comp_chunk.data,
740 comp_chunk.length,
741 plain_chunk.data,
742 plain_chunk.length);
743 if (ret < 0) {
744 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
745 "XPRESS HUFF lzxpress_huffman_decompress() returned %zd\n",
746 ret);
747 }
748
749 if (plain_chunk.length != ret) {
750 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
751 "XPRESS HUFF lzxpress_huffman_decompress() output is not as expected (%zd != %zu) (PULL)",
752 ret, plain_chunk.length);
753 }
754
755 return NDR_ERR_SUCCESS;
756 }
757
758 static enum ndr_err_code ndr_push_compression_xpress_huff_raw_chunk(struct ndr_push *ndrpush,
759 struct ndr_pull *ndrpull,
760 struct ndr_compression_state *state)
761 {
762 DATA_BLOB comp_chunk;
763 DATA_BLOB plain_chunk;
764 uint32_t plain_chunk_size;
765 uint32_t plain_chunk_offset;
766 ssize_t ret;
767
768 struct lzxhuff_compressor_mem *mem = state->alg.lzxpress_huffman.mem;
769
770 if (ndrpull->data_size <= ndrpull->offset) {
771 return ndr_push_error(ndrpush, NDR_ERR_COMPRESSION,
772 "strange NDR pull size and offset (integer overflow?)");
773
774 }
775
776 plain_chunk_size = ndrpull->data_size - ndrpull->offset;
777 plain_chunk_offset = ndrpull->offset;
778 NDR_CHECK(ndr_pull_advance(ndrpull, plain_chunk_size));
779
780 plain_chunk.data = ndrpull->data + plain_chunk_offset;
781 plain_chunk.length = plain_chunk_size;
782
783 comp_chunk.length = lzxpress_huffman_max_compressed_size(plain_chunk_size);
784 NDR_CHECK(ndr_push_expand(ndrpush, comp_chunk.length));
785
786 comp_chunk.data = ndrpush->data + ndrpush->offset;
787
788
789 /* Compressing the buffer using LZ Xpress w/ Huffman algorithm */
790 ret = lzxpress_huffman_compress(mem,
791 plain_chunk.data,
792 plain_chunk.length,
793 comp_chunk.data,
794 comp_chunk.length);
795 if (ret < 0) {
796 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
797 "XPRESS HUFF lzxpress_huffman_compress() returned %zd\n",
798 ret);
799 }
800
801 if (ret > comp_chunk.length) {
802 return ndr_pull_error(ndrpull, NDR_ERR_COMPRESSION,
803 "XPRESS HUFF lzxpress_huffman_compress() output is not as expected (%zd > %zu) (PULL)",
804 ret, comp_chunk.length);
805 }
806
807 ndrpush->offset += ret;
808 return NDR_ERR_SUCCESS;
809 }
810
811
812 /*
813 handle compressed subcontext buffers, which in midl land are user-marshalled, but
814 we use magic in pidl to make them easier to cope with
815 */
816 enum ndr_err_code ndr_pull_compression_start(struct ndr_pull *subndr,
817 struct ndr_pull **_comndr,
818 enum ndr_compression_alg compression_alg,
819 ssize_t decompressed_len,
820 ssize_t compressed_len)
821 {
822 struct ndr_push *ndrpush;
823 struct ndr_pull *comndr;
824 DATA_BLOB uncompressed;
825 bool last = false;
826 z_stream z;
827
828 ndrpush = ndr_push_init_ctx(subndr);
829 NDR_ERR_HAVE_NO_MEMORY(ndrpush);
830
831 switch (compression_alg) {
832 case NDR_COMPRESSION_NONE:
833 NDR_CHECK(ndr_pull_compression_none(subndr, ndrpush,
834 decompressed_len,
835 compressed_len));
836 break;
837 case NDR_COMPRESSION_MSZIP_CAB:
838 NDR_CHECK(ndr_pull_compression_mszip_cab_chunk(subndr, ndrpush,
839 subndr->cstate,
840 decompressed_len,
841 compressed_len));
842 break;
843 case NDR_COMPRESSION_MSZIP:
844 ZERO_STRUCT(z);
845 while (!last) {
846 NDR_CHECK(ndr_pull_compression_mszip_chunk(subndr, ndrpush, &z, &last));
847 }
848 break;
849
850 case NDR_COMPRESSION_XPRESS:
851 while (!last) {
852 NDR_CHECK(ndr_pull_compression_xpress_chunk(subndr, ndrpush, &last));
853 }
854 break;
855
856 case NDR_COMPRESSION_XPRESS_HUFF_RAW:
857 NDR_CHECK(ndr_pull_compression_xpress_huff_raw_chunk(subndr, ndrpush,
858 decompressed_len,
859 compressed_len));
860 break;
861
862 default:
863 return ndr_pull_error(subndr, NDR_ERR_COMPRESSION, "Bad compression algorithm %d (PULL)",
864 compression_alg);
865 }
866
867 uncompressed = ndr_push_blob(ndrpush);
868 if (uncompressed.length != decompressed_len) {
869 return ndr_pull_error(subndr, NDR_ERR_COMPRESSION,
870 "Bad uncompressed_len [%zu] != [%zd](0x%08zX) (PULL)",
871 uncompressed.length,
872 decompressed_len,
873 decompressed_len);
874 }
875
876 comndr = talloc_zero(subndr, struct ndr_pull);
877 NDR_ERR_HAVE_NO_MEMORY(comndr);
878 comndr->flags = subndr->flags;
879 comndr->current_mem_ctx = subndr->current_mem_ctx;
880
881 comndr->data = uncompressed.data;
882 comndr->data_size = uncompressed.length;
883 comndr->offset = 0;
884
885 *_comndr = comndr;
886 return NDR_ERR_SUCCESS;
887 }
888
889 enum ndr_err_code ndr_pull_compression_end(struct ndr_pull *subndr,
890 struct ndr_pull *comndr,
891 enum ndr_compression_alg compression_alg,
892 ssize_t decompressed_len)
893 {
894 return NDR_ERR_SUCCESS;
895 }
896
897 /*
898 push a compressed subcontext
899 */
900 enum ndr_err_code ndr_push_compression_start(struct ndr_push *subndr,
901 struct ndr_push **_uncomndr)
902 {
903 struct ndr_push *uncomndr;
904 enum ndr_compression_alg compression_alg = subndr->cstate->type;
905
906 switch (compression_alg) {
907 case NDR_COMPRESSION_NONE:
908 case NDR_COMPRESSION_MSZIP_CAB:
909 case NDR_COMPRESSION_MSZIP:
910 case NDR_COMPRESSION_XPRESS:
911 case NDR_COMPRESSION_XPRESS_HUFF_RAW:
912 break;
913 default:
914 return ndr_push_error(subndr, NDR_ERR_COMPRESSION,
915 "Bad compression algorithm %d (PUSH)",
916 compression_alg);
917 }
918
919 uncomndr = ndr_push_init_ctx(subndr);
920 NDR_ERR_HAVE_NO_MEMORY(uncomndr);
921 uncomndr->flags = subndr->flags;
922
923 *_uncomndr = uncomndr;
924 return NDR_ERR_SUCCESS;
925 }
926
927 /*
928 push a compressed subcontext
929 */
930 enum ndr_err_code ndr_push_compression_end(struct ndr_push *subndr,
931 struct ndr_push *uncomndr)
932 {
933 struct ndr_pull *ndrpull;
934 bool last = false;
935 z_stream z;
936
937 enum ndr_compression_alg compression_alg = subndr->cstate->type;
938
939 ndrpull = talloc_zero(uncomndr, struct ndr_pull);
940 NDR_ERR_HAVE_NO_MEMORY(ndrpull);
941 ndrpull->flags = uncomndr->flags;
942 ndrpull->data = uncomndr->data;
943 ndrpull->data_size = uncomndr->offset;
944 ndrpull->offset = 0;
945
946 switch (compression_alg) {
947 case NDR_COMPRESSION_NONE:
948 NDR_CHECK(ndr_push_compression_none(subndr, ndrpull));
949 break;
950
951 case NDR_COMPRESSION_MSZIP_CAB:
952 NDR_CHECK(ndr_push_compression_mszip_cab_chunk(subndr, ndrpull, subndr->cstate));
953 break;
954
955 case NDR_COMPRESSION_MSZIP:
956 ZERO_STRUCT(z);
957 while (!last) {
958 NDR_CHECK(ndr_push_compression_mszip_chunk(subndr, ndrpull, &z, &last));
959 }
960 break;
961
962 case NDR_COMPRESSION_XPRESS:
963 while (!last) {
964 NDR_CHECK(ndr_push_compression_xpress_chunk(subndr, ndrpull, &last));
965 }
966 break;
967
968 case NDR_COMPRESSION_XPRESS_HUFF_RAW:
969 NDR_CHECK(ndr_push_compression_xpress_huff_raw_chunk(subndr, ndrpull, subndr->cstate));
970 break;
971
972 default:
973 return ndr_push_error(subndr, NDR_ERR_COMPRESSION, "Bad compression algorithm %d (PUSH)",
974 compression_alg);
975 }
976
977 talloc_free(uncomndr);
978 return NDR_ERR_SUCCESS;
979 }
980
981 static enum ndr_err_code generic_mszip_init(struct ndr_compression_state *state)
982 {
983 z_stream *z = talloc_zero(state, z_stream);
984 NDR_ERR_HAVE_NO_MEMORY(z);
985
986 z->zalloc = ndr_zlib_alloc;
987 z->zfree = ndr_zlib_free;
988 z->opaque = state;
989
990 state->alg.mszip.z = z;
991 state->alg.mszip.dict_size = 0;
992 /* pre-alloc dictionary */
993 state->alg.mszip.dict = talloc_array(state, uint8_t, 0x8000);
994 NDR_ERR_HAVE_NO_MEMORY(state->alg.mszip.dict);
995
996 return NDR_ERR_SUCCESS;
997 }
998
999 enum ndr_err_code ndr_pull_compression_state_init(struct ndr_pull *ndr,
1000 enum ndr_compression_alg compression_alg,
1001 struct ndr_compression_state **state)
1002 {
1003 struct ndr_compression_state *s;
1004 int z_ret;
1005
1006 s = talloc_zero(ndr, struct ndr_compression_state);
1007 NDR_ERR_HAVE_NO_MEMORY(s);
1008 s->type = compression_alg;
1009
1010 switch (compression_alg) {
1011 case NDR_COMPRESSION_NONE:
1012 case NDR_COMPRESSION_MSZIP:
1013 case NDR_COMPRESSION_XPRESS:
1014 case NDR_COMPRESSION_XPRESS_HUFF_RAW:
1015 break;
1016 case NDR_COMPRESSION_MSZIP_CAB:
1017 NDR_CHECK(generic_mszip_init(s));
1018 z_ret = inflateInit2(s->alg.mszip.z, -MAX_WBITS);
1019 if (z_ret != Z_OK) {
1020 return ndr_pull_error(ndr, NDR_ERR_COMPRESSION,
1021 "zlib inflateinit2 error %s (%d) %s (PULL)",
1022 zError(z_ret), z_ret, s->alg.mszip.z->msg);
1023 }
1024 break;
1025 default:
1026 return ndr_pull_error(ndr, NDR_ERR_COMPRESSION,
1027 "Bad compression algorithm %d (PULL)",
1028 compression_alg);
1029 break;
1030 }
1031
1032 *state = s;
1033
1034 return NDR_ERR_SUCCESS;
1035 }
1036
1037 enum ndr_err_code ndr_push_compression_state_init(struct ndr_push *ndr,
1038 enum ndr_compression_alg compression_alg)
1039 {
1040 struct ndr_compression_state *s;
1041 int z_ret;
1042
1043 /*
1044 * Avoid confusion, NULL out ndr->cstate at the start of the
1045 * compression block
1046 */
1047 ndr->cstate = NULL;
1048
1049 s = talloc_zero(ndr, struct ndr_compression_state);
1050 NDR_ERR_HAVE_NO_MEMORY(s);
1051 s->type = compression_alg;
1052
1053 switch (compression_alg) {
1054 case NDR_COMPRESSION_NONE:
1055 case NDR_COMPRESSION_XPRESS:
1056 break;
1057
1058 case NDR_COMPRESSION_XPRESS_HUFF_RAW:
1059 s->alg.lzxpress_huffman.mem = talloc(s, struct lzxhuff_compressor_mem);
1060 if (s->alg.lzxpress_huffman.mem == NULL) {
1061 return NDR_ERR_ALLOC;
1062 }
1063 break;
1064
1065 case NDR_COMPRESSION_MSZIP:
1066 break;
1067 case NDR_COMPRESSION_MSZIP_CAB:
1068 NDR_CHECK(generic_mszip_init(s));
1069 z_ret = deflateInit2(s->alg.mszip.z,
1070 Z_DEFAULT_COMPRESSION,
1071 Z_DEFLATED,
1072 -MAX_WBITS,
1073 8, /* memLevel */
1074 Z_DEFAULT_STRATEGY);
1075 if (z_ret != Z_OK) {
1076 return ndr_push_error(ndr, NDR_ERR_COMPRESSION,
1077 "zlib inflateinit2 error %s (%d) %s (PUSH)",
1078 zError(z_ret), z_ret, s->alg.mszip.z->msg);
1079 }
1080 break;
1081 default:
1082 return ndr_push_error(ndr, NDR_ERR_COMPRESSION,
1083 "Bad compression algorithm %d (PUSH)",
1084 compression_alg);
1085 break;
1086 }
1087
1088 ndr->cstate = s;
1089
1090 return NDR_ERR_SUCCESS;
1091 }
1092
Samba GIT mirror