2 * Copyright (c) 2012 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #include "archive_platform.h"
28 __FBSDID("$FreeBSD$");
29 //#undef HAVE_LZO_LZOCONF_H
30 //#undef HAVE_LZO_LZO1X_H
42 #ifdef HAVE_LZO_LZOCONF_H
43 #include <lzo/lzoconf.h>
45 #ifdef HAVE_LZO_LZO1X_H
46 #include <lzo/lzo1x.h>
50 #include "archive_string.h"
51 #include "archive_endian.h"
52 #include "archive_write_private.h"
56 METHOD_LZO1X_1_15 = 2,
60 int compression_level;
61 #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H)
62 unsigned char *uncompressed;
63 size_t uncompressed_buffer_size;
64 size_t uncompressed_avail_bytes;
65 unsigned char *compressed;
66 size_t compressed_buffer_size;
67 enum lzo_method method;
69 lzo_voidp work_buffer;
70 lzo_uint32 work_buffer_size;
73 struct archive_write_program_data *pdata;
77 static int archive_write_lzop_open(struct archive_write_filter *);
78 static int archive_write_lzop_options(struct archive_write_filter *,
79 const char *, const char *);
80 static int archive_write_lzop_write(struct archive_write_filter *,
81 const void *, size_t);
82 static int archive_write_lzop_close(struct archive_write_filter *);
83 static int archive_write_lzop_free(struct archive_write_filter *);
85 #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H)
86 /* Maximum block size. */
87 #define BLOCK_SIZE (256 * 1024)
88 /* Block information is composed of uncompressed size(4 bytes),
89 * compressed size(4 bytes) and the checksum of uncompressed data(4 bytes)
90 * in this lzop writer. */
91 #define BLOCK_INfO_SIZE 12
93 #define HEADER_VERSION 9
94 #define HEADER_LIBVERSION 11
95 #define HEADER_METHOD 15
96 #define HEADER_LEVEL 16
97 #define HEADER_MTIME_LOW 25
98 #define HEADER_MTIME_HIGH 29
99 #define HEADER_H_CHECKSUM 34
104 static const unsigned char header[] = {
105 /* LZOP Magic code 9 bytes */
106 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a,
107 /* LZOP utility version(fake data) 2 bytes */
109 /* LZO library version 2 bytes */
111 /* Minimum required LZO library version 2 bytes */
121 * -Adler32 used for uncompressed data 4 bytes */
122 0x03, 0x00, 0x00, 0x0d,
123 /* Mode (AE_IFREG | 0644) 4 bytes */
124 0x00, 0x00, 0x81, 0xa4,
125 /* Mtime low 4 bytes */
126 0x00, 0x00, 0x00, 0x00,
127 /* Mtime high 4 bytes */
128 0x00, 0x00, 0x00, 0x00,
129 /* Filename length */
131 /* Header checksum 4 bytes */
132 0x00, 0x00, 0x00, 0x00,
137 archive_write_add_filter_lzop(struct archive *_a)
139 struct archive_write_filter *f = __archive_write_allocate_filter(_a);
140 struct write_lzop *data;
142 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
143 ARCHIVE_STATE_NEW, "archive_write_add_filter_lzop");
145 data = calloc(1, sizeof(*data));
147 archive_set_error(_a, ENOMEM, "Can't allocate memory");
148 return (ARCHIVE_FATAL);
152 f->code = ARCHIVE_FILTER_LZOP;
154 f->open = archive_write_lzop_open;
155 f->options = archive_write_lzop_options;
156 f->write = archive_write_lzop_write;
157 f->close = archive_write_lzop_close;
158 f->free = archive_write_lzop_free;
159 #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H)
160 if (lzo_init() != LZO_E_OK) {
162 archive_set_error(_a, ARCHIVE_ERRNO_MISC,
163 "lzo_init(type check) failed");
164 return (ARCHIVE_FATAL);
166 if (lzo_version() < 0x940) {
168 archive_set_error(_a, ARCHIVE_ERRNO_MISC,
169 "liblzo library is too old(%s < 0.940)",
170 lzo_version_string());
171 return (ARCHIVE_FATAL);
173 data->compression_level = 5;
176 data->pdata = __archive_write_program_allocate("lzop");
177 if (data->pdata == NULL) {
179 archive_set_error(_a, ENOMEM, "Can't allocate memory");
180 return (ARCHIVE_FATAL);
182 data->compression_level = 0;
183 /* Note: We return "warn" to inform of using an external lzop
185 archive_set_error(_a, ARCHIVE_ERRNO_MISC,
186 "Using external lzop program for lzop compression");
187 return (ARCHIVE_WARN);
192 archive_write_lzop_free(struct archive_write_filter *f)
194 struct write_lzop *data = (struct write_lzop *)f->data;
196 #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H)
197 free(data->uncompressed);
198 free(data->compressed);
199 free(data->work_buffer);
201 __archive_write_program_free(data->pdata);
208 archive_write_lzop_options(struct archive_write_filter *f, const char *key,
211 struct write_lzop *data = (struct write_lzop *)f->data;
213 if (strcmp(key, "compression-level") == 0) {
214 if (value == NULL || !(value[0] >= '1' && value[0] <= '9') ||
216 return (ARCHIVE_WARN);
217 data->compression_level = value[0] - '0';
220 /* Note: The "warn" return is just to inform the options
221 * supervisor that we didn't handle it. It will generate
222 * a suitable error if no one used this option. */
223 return (ARCHIVE_WARN);
226 #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H)
228 archive_write_lzop_open(struct archive_write_filter *f)
230 struct write_lzop *data = (struct write_lzop *)f->data;
232 switch (data->compression_level) {
234 data->method = METHOD_LZO1X_1_15; data->level = 1; break;
236 case 2: case 3: case 4: case 5: case 6:
237 data->method = METHOD_LZO1X_1; data->level = 5; break;
239 data->method = METHOD_LZO1X_999; data->level = 7; break;
241 data->method = METHOD_LZO1X_999; data->level = 8; break;
243 data->method = METHOD_LZO1X_999; data->level = 9; break;
245 switch (data->method) {
247 data->work_buffer_size = LZO1X_1_MEM_COMPRESS; break;
248 case METHOD_LZO1X_1_15:
249 data->work_buffer_size = LZO1X_1_15_MEM_COMPRESS; break;
250 case METHOD_LZO1X_999:
251 data->work_buffer_size = LZO1X_999_MEM_COMPRESS; break;
253 if (data->work_buffer == NULL) {
254 data->work_buffer = (lzo_voidp)malloc(data->work_buffer_size);
255 if (data->work_buffer == NULL) {
256 archive_set_error(f->archive, ENOMEM,
257 "Can't allocate data for compression buffer");
258 return (ARCHIVE_FATAL);
261 if (data->compressed == NULL) {
262 data->compressed_buffer_size = sizeof(header) +
263 BLOCK_SIZE + (BLOCK_SIZE >> 4) + 64 + 3;
264 data->compressed = (unsigned char *)
265 malloc(data->compressed_buffer_size);
266 if (data->compressed == NULL) {
267 archive_set_error(f->archive, ENOMEM,
268 "Can't allocate data for compression buffer");
269 return (ARCHIVE_FATAL);
272 if (data->uncompressed == NULL) {
273 data->uncompressed_buffer_size = BLOCK_SIZE;
274 data->uncompressed = (unsigned char *)
275 malloc(data->uncompressed_buffer_size);
276 if (data->uncompressed == NULL) {
277 archive_set_error(f->archive, ENOMEM,
278 "Can't allocate data for compression buffer");
279 return (ARCHIVE_FATAL);
281 data->uncompressed_avail_bytes = BLOCK_SIZE;
287 make_header(struct archive_write_filter *f)
289 struct write_lzop *data = (struct write_lzop *)f->data;
293 memcpy(data->compressed, header, sizeof(header));
294 /* Overwrite library version. */
295 data->compressed[HEADER_LIBVERSION] = (unsigned char )
296 (lzo_version() >> 8) & 0xff;
297 data->compressed[HEADER_LIBVERSION + 1] = (unsigned char )
298 lzo_version() & 0xff;
299 /* Overwrite method and level. */
300 data->compressed[HEADER_METHOD] = (unsigned char)data->method;
301 data->compressed[HEADER_LEVEL] = data->level;
302 /* Overwrite mtime with current time. */
303 t = (int64_t)time(NULL);
304 archive_be32enc(&data->compressed[HEADER_MTIME_LOW],
305 (uint32_t)(t & 0xffffffff));
306 archive_be32enc(&data->compressed[HEADER_MTIME_HIGH],
307 (uint32_t)((t >> 32) & 0xffffffff));
308 /* Overwrite header checksum with calculated value. */
309 checksum = lzo_adler32(1, data->compressed + HEADER_VERSION,
310 (lzo_uint)(HEADER_H_CHECKSUM - HEADER_VERSION));
311 archive_be32enc(&data->compressed[HEADER_H_CHECKSUM], checksum);
312 return (sizeof(header));
316 drive_compressor(struct archive_write_filter *f)
318 struct write_lzop *data = (struct write_lzop *)f->data;
320 const int block_info_bytes = 12;
322 lzo_uint usize, csize;
325 if (!data->header_written) {
326 header_bytes = make_header(f);
327 data->header_written = 1;
330 p = data->compressed;
333 (data->uncompressed_buffer_size - data->uncompressed_avail_bytes);
335 switch (data->method) {
338 r = lzo1x_1_compress(data->uncompressed, usize,
339 p + header_bytes + block_info_bytes, &csize,
342 case METHOD_LZO1X_1_15:
343 r = lzo1x_1_15_compress(data->uncompressed, usize,
344 p + header_bytes + block_info_bytes, &csize,
347 case METHOD_LZO1X_999:
348 r = lzo1x_999_compress_level(data->uncompressed, usize,
349 p + header_bytes + block_info_bytes, &csize,
350 data->work_buffer, NULL, 0, 0, data->level);
354 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
355 "Lzop compression failed: returned status %d", r);
356 return (ARCHIVE_FATAL);
359 /* Store uncompressed size. */
360 archive_be32enc(p + header_bytes, (uint32_t)usize);
361 /* Store the checksum of the uncompressed data. */
362 checksum = lzo_adler32(1, data->uncompressed, usize);
363 archive_be32enc(p + header_bytes + 8, checksum);
366 /* Store compressed size. */
367 archive_be32enc(p + header_bytes + 4, (uint32_t)csize);
368 r = __archive_write_filter(f->next_filter, data->compressed,
369 header_bytes + block_info_bytes + csize);
372 * This case, we output uncompressed data instead.
374 /* Store uncompressed size as compressed size. */
375 archive_be32enc(p + header_bytes + 4, (uint32_t)usize);
376 r = __archive_write_filter(f->next_filter, data->compressed,
377 header_bytes + block_info_bytes);
379 return (ARCHIVE_FATAL);
380 r = __archive_write_filter(f->next_filter, data->uncompressed,
385 return (ARCHIVE_FATAL);
390 archive_write_lzop_write(struct archive_write_filter *f,
391 const void *buff, size_t length)
393 struct write_lzop *data = (struct write_lzop *)f->data;
394 const char *p = buff;
398 if (data->uncompressed_avail_bytes > length) {
399 memcpy(data->uncompressed
400 + data->uncompressed_buffer_size
401 - data->uncompressed_avail_bytes,
403 data->uncompressed_avail_bytes -= length;
407 memcpy(data->uncompressed + data->uncompressed_buffer_size
408 - data->uncompressed_avail_bytes,
409 p, data->uncompressed_avail_bytes);
410 length -= data->uncompressed_avail_bytes;
411 p += data->uncompressed_avail_bytes;
412 data->uncompressed_avail_bytes = 0;
414 r = drive_compressor(f);
415 if (r != ARCHIVE_OK) return (r);
416 data->uncompressed_avail_bytes = BLOCK_SIZE;
423 archive_write_lzop_close(struct archive_write_filter *f)
425 struct write_lzop *data = (struct write_lzop *)f->data;
426 const uint32_t endmark = 0;
429 if (data->uncompressed_avail_bytes < BLOCK_SIZE) {
430 /* Compress and output remaining data. */
431 r = drive_compressor(f);
435 /* Write a zero uncompressed size as the end mark of the series of
436 * compressed block. */
437 return __archive_write_filter(f->next_filter, &endmark, sizeof(endmark));
442 archive_write_lzop_open(struct archive_write_filter *f)
444 struct write_lzop *data = (struct write_lzop *)f->data;
445 struct archive_string as;
448 archive_string_init(&as);
449 archive_strcpy(&as, "lzop");
450 /* Specify compression level. */
451 if (data->compression_level > 0) {
452 archive_strappend_char(&as, ' ');
453 archive_strappend_char(&as, '-');
454 archive_strappend_char(&as, '0' + data->compression_level);
457 r = __archive_write_program_open(f, data->pdata, as.s);
458 archive_string_free(&as);
463 archive_write_lzop_write(struct archive_write_filter *f,
464 const void *buff, size_t length)
466 struct write_lzop *data = (struct write_lzop *)f->data;
468 return __archive_write_program_write(f, data->pdata, buff, length);
472 archive_write_lzop_close(struct archive_write_filter *f)
474 struct write_lzop *data = (struct write_lzop *)f->data;
476 return __archive_write_program_close(f, data->pdata);