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