2 * Copyright (c) 2003-2010 Tim Kientzle
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"
27 __FBSDID("$FreeBSD: head/lib/libarchive/archive_write.c 201099 2009-12-28 03:03:00Z kientzle $");
30 * This file contains the "essential" portions of the write API, that
31 * is, stuff that will essentially always be used by any client that
32 * actually needs to write an archive. Optional pieces have been, as
33 * far as possible, separated out into separate files to reduce
34 * needlessly bloating statically-linked clients.
37 #ifdef HAVE_SYS_WAIT_H
59 #include "archive_entry.h"
60 #include "archive_private.h"
61 #include "archive_write_private.h"
63 static struct archive_vtable
*archive_write_vtable(void);
65 static int _archive_filter_code(struct archive
*, int);
66 static const char *_archive_filter_name(struct archive
*, int);
67 static int64_t _archive_filter_bytes(struct archive
*, int);
68 static int _archive_write_filter_count(struct archive
*);
69 static int _archive_write_close(struct archive
*);
70 static int _archive_write_free(struct archive
*);
71 static int _archive_write_header(struct archive
*, struct archive_entry
*);
72 static int _archive_write_finish_entry(struct archive
*);
73 static ssize_t
_archive_write_data(struct archive
*, const void *, size_t);
82 static struct archive_vtable
*
83 archive_write_vtable(void)
85 static struct archive_vtable av
;
86 static int inited
= 0;
89 av
.archive_close
= _archive_write_close
;
90 av
.archive_filter_bytes
= _archive_filter_bytes
;
91 av
.archive_filter_code
= _archive_filter_code
;
92 av
.archive_filter_name
= _archive_filter_name
;
93 av
.archive_filter_count
= _archive_write_filter_count
;
94 av
.archive_free
= _archive_write_free
;
95 av
.archive_write_header
= _archive_write_header
;
96 av
.archive_write_finish_entry
= _archive_write_finish_entry
;
97 av
.archive_write_data
= _archive_write_data
;
104 * Allocate, initialize and return an archive object.
107 archive_write_new(void)
109 struct archive_write
*a
;
110 unsigned char *nulls
;
112 a
= (struct archive_write
*)malloc(sizeof(*a
));
115 memset(a
, 0, sizeof(*a
));
116 a
->archive
.magic
= ARCHIVE_WRITE_MAGIC
;
117 a
->archive
.state
= ARCHIVE_STATE_NEW
;
118 a
->archive
.vtable
= archive_write_vtable();
120 * The value 10240 here matches the traditional tar default,
121 * but is otherwise arbitrary.
122 * TODO: Set the default block size from the format selected.
124 a
->bytes_per_block
= 10240;
125 a
->bytes_in_last_block
= -1; /* Default */
127 /* Initialize a block of nulls for padding purposes. */
128 a
->null_length
= 1024;
129 nulls
= (unsigned char *)malloc(a
->null_length
);
134 memset(nulls
, 0, a
->null_length
);
136 return (&a
->archive
);
140 * Set the block size. Returns 0 if successful.
143 archive_write_set_bytes_per_block(struct archive
*_a
, int bytes_per_block
)
145 struct archive_write
*a
= (struct archive_write
*)_a
;
146 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
147 ARCHIVE_STATE_NEW
, "archive_write_set_bytes_per_block");
148 a
->bytes_per_block
= bytes_per_block
;
153 * Get the current block size. -1 if it has never been set.
156 archive_write_get_bytes_per_block(struct archive
*_a
)
158 struct archive_write
*a
= (struct archive_write
*)_a
;
159 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
160 ARCHIVE_STATE_ANY
, "archive_write_get_bytes_per_block");
161 return (a
->bytes_per_block
);
165 * Set the size for the last block.
166 * Returns 0 if successful.
169 archive_write_set_bytes_in_last_block(struct archive
*_a
, int bytes
)
171 struct archive_write
*a
= (struct archive_write
*)_a
;
172 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
173 ARCHIVE_STATE_ANY
, "archive_write_set_bytes_in_last_block");
174 a
->bytes_in_last_block
= bytes
;
179 * Return the value set above. -1 indicates it has not been set.
182 archive_write_get_bytes_in_last_block(struct archive
*_a
)
184 struct archive_write
*a
= (struct archive_write
*)_a
;
185 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
186 ARCHIVE_STATE_ANY
, "archive_write_get_bytes_in_last_block");
187 return (a
->bytes_in_last_block
);
191 * dev/ino of a file to be rejected. Used to prevent adding
192 * an archive to itself recursively.
195 archive_write_set_skip_file(struct archive
*_a
, int64_t d
, int64_t i
)
197 struct archive_write
*a
= (struct archive_write
*)_a
;
198 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
199 ARCHIVE_STATE_ANY
, "archive_write_set_skip_file");
200 a
->skip_file_set
= 1;
201 a
->skip_file_dev
= d
;
202 a
->skip_file_ino
= i
;
207 * Allocate and return the next filter structure.
209 struct archive_write_filter
*
210 __archive_write_allocate_filter(struct archive
*_a
)
212 struct archive_write
*a
= (struct archive_write
*)_a
;
213 struct archive_write_filter
*f
;
215 f
= calloc(1, sizeof(*f
));
217 if (a
->filter_first
== NULL
)
220 a
->filter_last
->next_filter
= f
;
226 * Write data to a particular filter.
229 __archive_write_filter(struct archive_write_filter
*f
,
230 const void *buff
, size_t length
)
235 if (f
->write
== NULL
)
236 /* If unset, a fatal error has already ocuured, so this filter
237 * didn't open. We cannot write anything. */
238 return(ARCHIVE_FATAL
);
239 r
= (f
->write
)(f
, buff
, length
);
240 f
->bytes_written
+= length
;
248 __archive_write_open_filter(struct archive_write_filter
*f
)
259 __archive_write_close_filter(struct archive_write_filter
*f
)
261 if (f
->close
!= NULL
)
262 return (f
->close
)(f
);
263 if (f
->next_filter
!= NULL
)
264 return (__archive_write_close_filter(f
->next_filter
));
269 __archive_write_output(struct archive_write
*a
, const void *buff
, size_t length
)
271 return (__archive_write_filter(a
->filter_first
, buff
, length
));
275 __archive_write_nulls(struct archive_write
*a
, size_t length
)
281 size_t to_write
= length
< a
->null_length
? length
: a
->null_length
;
282 int r
= __archive_write_output(a
, a
->nulls
, to_write
);
291 archive_write_client_open(struct archive_write_filter
*f
)
293 struct archive_write
*a
= (struct archive_write
*)f
->archive
;
294 struct archive_none
*state
;
298 f
->bytes_per_block
= archive_write_get_bytes_per_block(f
->archive
);
299 f
->bytes_in_last_block
=
300 archive_write_get_bytes_in_last_block(f
->archive
);
301 buffer_size
= f
->bytes_per_block
;
303 state
= (struct archive_none
*)calloc(1, sizeof(*state
));
304 buffer
= (char *)malloc(buffer_size
);
305 if (state
== NULL
|| buffer
== NULL
) {
308 archive_set_error(f
->archive
, ENOMEM
,
309 "Can't allocate data for output buffering");
310 return (ARCHIVE_FATAL
);
313 state
->buffer_size
= buffer_size
;
314 state
->buffer
= buffer
;
315 state
->next
= state
->buffer
;
316 state
->avail
= state
->buffer_size
;
319 if (a
->client_opener
== NULL
)
321 return (a
->client_opener(f
->archive
, a
->client_data
));
325 archive_write_client_write(struct archive_write_filter
*f
,
326 const void *_buff
, size_t length
)
328 struct archive_write
*a
= (struct archive_write
*)f
->archive
;
329 struct archive_none
*state
= (struct archive_none
*)f
->data
;
330 const char *buff
= (const char *)_buff
;
331 ssize_t remaining
, to_copy
;
332 ssize_t bytes_written
;
337 * If there is no buffer for blocking, just pass the data
338 * straight through to the client write callback. In
339 * particular, this supports "no write delay" operation for
340 * special applications. Just set the block size to zero.
342 if (state
->buffer_size
== 0) {
343 while (remaining
> 0) {
344 bytes_written
= (a
->client_writer
)(&a
->archive
,
345 a
->client_data
, buff
, remaining
);
346 if (bytes_written
<= 0)
347 return (ARCHIVE_FATAL
);
348 remaining
-= bytes_written
;
349 buff
+= bytes_written
;
354 /* If the copy buffer isn't empty, try to fill it. */
355 if (state
->avail
< state
->buffer_size
) {
356 /* If buffer is not empty... */
357 /* ... copy data into buffer ... */
358 to_copy
= ((size_t)remaining
> state
->avail
) ?
359 state
->avail
: (size_t)remaining
;
360 memcpy(state
->next
, buff
, to_copy
);
361 state
->next
+= to_copy
;
362 state
->avail
-= to_copy
;
364 remaining
-= to_copy
;
365 /* ... if it's full, write it out. */
366 if (state
->avail
== 0) {
367 char *p
= state
->buffer
;
368 size_t to_write
= state
->buffer_size
;
369 while (to_write
> 0) {
370 bytes_written
= (a
->client_writer
)(&a
->archive
,
371 a
->client_data
, p
, to_write
);
372 if (bytes_written
<= 0)
373 return (ARCHIVE_FATAL
);
374 if ((size_t)bytes_written
> to_write
) {
375 archive_set_error(&(a
->archive
),
376 -1, "write overrun");
377 return (ARCHIVE_FATAL
);
380 to_write
-= bytes_written
;
382 state
->next
= state
->buffer
;
383 state
->avail
= state
->buffer_size
;
387 while ((size_t)remaining
>= state
->buffer_size
) {
388 /* Write out full blocks directly to client. */
389 bytes_written
= (a
->client_writer
)(&a
->archive
,
390 a
->client_data
, buff
, state
->buffer_size
);
391 if (bytes_written
<= 0)
392 return (ARCHIVE_FATAL
);
393 buff
+= bytes_written
;
394 remaining
-= bytes_written
;
398 /* Copy last bit into copy buffer. */
399 memcpy(state
->next
, buff
, remaining
);
400 state
->next
+= remaining
;
401 state
->avail
-= remaining
;
407 archive_write_client_close(struct archive_write_filter
*f
)
409 struct archive_write
*a
= (struct archive_write
*)f
->archive
;
410 struct archive_none
*state
= (struct archive_none
*)f
->data
;
411 ssize_t block_length
;
412 ssize_t target_block_length
;
413 ssize_t bytes_written
;
414 int ret
= ARCHIVE_OK
;
416 /* If there's pending data, pad and write the last block */
417 if (state
->next
!= state
->buffer
) {
418 block_length
= state
->buffer_size
- state
->avail
;
420 /* Tricky calculation to determine size of last block */
421 if (a
->bytes_in_last_block
<= 0)
422 /* Default or Zero: pad to full block */
423 target_block_length
= a
->bytes_per_block
;
425 /* Round to next multiple of bytes_in_last_block. */
426 target_block_length
= a
->bytes_in_last_block
*
427 ( (block_length
+ a
->bytes_in_last_block
- 1) /
428 a
->bytes_in_last_block
);
429 if (target_block_length
> a
->bytes_per_block
)
430 target_block_length
= a
->bytes_per_block
;
431 if (block_length
< target_block_length
) {
432 memset(state
->next
, 0,
433 target_block_length
- block_length
);
434 block_length
= target_block_length
;
436 bytes_written
= (a
->client_writer
)(&a
->archive
,
437 a
->client_data
, state
->buffer
, block_length
);
438 ret
= bytes_written
<= 0 ? ARCHIVE_FATAL
: ARCHIVE_OK
;
440 if (a
->client_closer
)
441 (*a
->client_closer
)(&a
->archive
, a
->client_data
);
444 /* Clear the close handler myself not to be called again. */
446 a
->client_data
= NULL
;
447 /* Clear passphrase. */
448 if (a
->passphrase
!= NULL
) {
449 memset(a
->passphrase
, 0, strlen(a
->passphrase
));
451 a
->passphrase
= NULL
;
457 * Open the archive using the current settings.
460 archive_write_open(struct archive
*_a
, void *client_data
,
461 archive_open_callback
*opener
, archive_write_callback
*writer
,
462 archive_close_callback
*closer
)
464 struct archive_write
*a
= (struct archive_write
*)_a
;
465 struct archive_write_filter
*client_filter
;
468 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
469 ARCHIVE_STATE_NEW
, "archive_write_open");
470 archive_clear_error(&a
->archive
);
472 a
->client_writer
= writer
;
473 a
->client_opener
= opener
;
474 a
->client_closer
= closer
;
475 a
->client_data
= client_data
;
477 client_filter
= __archive_write_allocate_filter(_a
);
478 client_filter
->open
= archive_write_client_open
;
479 client_filter
->write
= archive_write_client_write
;
480 client_filter
->close
= archive_write_client_close
;
482 ret
= __archive_write_open_filter(a
->filter_first
);
483 if (ret
< ARCHIVE_WARN
) {
484 r1
= __archive_write_close_filter(a
->filter_first
);
485 return (r1
< ret
? r1
: ret
);
488 a
->archive
.state
= ARCHIVE_STATE_HEADER
;
490 ret
= (a
->format_init
)(a
);
495 * Close out the archive.
498 _archive_write_close(struct archive
*_a
)
500 struct archive_write
*a
= (struct archive_write
*)_a
;
501 int r
= ARCHIVE_OK
, r1
= ARCHIVE_OK
;
503 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
504 ARCHIVE_STATE_ANY
| ARCHIVE_STATE_FATAL
,
505 "archive_write_close");
506 if (a
->archive
.state
== ARCHIVE_STATE_NEW
507 || a
->archive
.state
== ARCHIVE_STATE_CLOSED
)
508 return (ARCHIVE_OK
); /* Okay to close() when not open. */
510 archive_clear_error(&a
->archive
);
512 /* Finish the last entry if a finish callback is specified */
513 if (a
->archive
.state
== ARCHIVE_STATE_DATA
514 && a
->format_finish_entry
!= NULL
)
515 r
= ((a
->format_finish_entry
)(a
));
517 /* Finish off the archive. */
518 /* TODO: have format closers invoke compression close. */
519 if (a
->format_close
!= NULL
) {
520 r1
= (a
->format_close
)(a
);
525 /* Finish the compression and close the stream. */
526 r1
= __archive_write_close_filter(a
->filter_first
);
530 if (a
->archive
.state
!= ARCHIVE_STATE_FATAL
)
531 a
->archive
.state
= ARCHIVE_STATE_CLOSED
;
536 _archive_write_filter_count(struct archive
*_a
)
538 struct archive_write
*a
= (struct archive_write
*)_a
;
539 struct archive_write_filter
*p
= a
->filter_first
;
549 __archive_write_filters_free(struct archive
*_a
)
551 struct archive_write
*a
= (struct archive_write
*)_a
;
552 int r
= ARCHIVE_OK
, r1
;
554 while (a
->filter_first
!= NULL
) {
555 struct archive_write_filter
*next
556 = a
->filter_first
->next_filter
;
557 if (a
->filter_first
->free
!= NULL
) {
558 r1
= (*a
->filter_first
->free
)(a
->filter_first
);
562 free(a
->filter_first
);
563 a
->filter_first
= next
;
565 a
->filter_last
= NULL
;
569 * Destroy the archive structure.
571 * Be careful: user might just call write_new and then write_free.
572 * Don't assume we actually wrote anything or performed any non-trivial
576 _archive_write_free(struct archive
*_a
)
578 struct archive_write
*a
= (struct archive_write
*)_a
;
579 int r
= ARCHIVE_OK
, r1
;
583 /* It is okay to call free() in state FATAL. */
584 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
585 ARCHIVE_STATE_ANY
| ARCHIVE_STATE_FATAL
, "archive_write_free");
586 if (a
->archive
.state
!= ARCHIVE_STATE_FATAL
)
587 r
= archive_write_close(&a
->archive
);
589 /* Release format resources. */
590 if (a
->format_free
!= NULL
) {
591 r1
= (a
->format_free
)(a
);
596 __archive_write_filters_free(_a
);
598 /* Release various dynamic buffers. */
599 free((void *)(uintptr_t)(const void *)a
->nulls
);
600 archive_string_free(&a
->archive
.error_string
);
601 if (a
->passphrase
!= NULL
) {
602 /* A passphrase should be cleaned. */
603 memset(a
->passphrase
, 0, strlen(a
->passphrase
));
606 a
->archive
.magic
= 0;
607 __archive_clean(&a
->archive
);
613 * Write the appropriate header.
616 _archive_write_header(struct archive
*_a
, struct archive_entry
*entry
)
618 struct archive_write
*a
= (struct archive_write
*)_a
;
621 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
622 ARCHIVE_STATE_DATA
| ARCHIVE_STATE_HEADER
, "archive_write_header");
623 archive_clear_error(&a
->archive
);
625 if (a
->format_write_header
== NULL
) {
626 archive_set_error(&(a
->archive
), -1,
627 "Format must be set before you can write to an archive.");
628 a
->archive
.state
= ARCHIVE_STATE_FATAL
;
629 return (ARCHIVE_FATAL
);
632 /* In particular, "retry" and "fatal" get returned immediately. */
633 ret
= archive_write_finish_entry(&a
->archive
);
634 if (ret
== ARCHIVE_FATAL
) {
635 a
->archive
.state
= ARCHIVE_STATE_FATAL
;
636 return (ARCHIVE_FATAL
);
638 if (ret
< ARCHIVE_OK
&& ret
!= ARCHIVE_WARN
)
641 if (a
->skip_file_set
&&
642 archive_entry_dev_is_set(entry
) &&
643 archive_entry_ino_is_set(entry
) &&
644 archive_entry_dev(entry
) == (dev_t
)a
->skip_file_dev
&&
645 archive_entry_ino64(entry
) == a
->skip_file_ino
) {
646 archive_set_error(&a
->archive
, 0,
647 "Can't add archive to itself");
648 return (ARCHIVE_FAILED
);
651 /* Format and write header. */
652 r2
= ((a
->format_write_header
)(a
, entry
));
653 if (r2
== ARCHIVE_FAILED
) {
654 return (ARCHIVE_FAILED
);
656 if (r2
== ARCHIVE_FATAL
) {
657 a
->archive
.state
= ARCHIVE_STATE_FATAL
;
658 return (ARCHIVE_FATAL
);
663 a
->archive
.state
= ARCHIVE_STATE_DATA
;
668 _archive_write_finish_entry(struct archive
*_a
)
670 struct archive_write
*a
= (struct archive_write
*)_a
;
671 int ret
= ARCHIVE_OK
;
673 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
674 ARCHIVE_STATE_HEADER
| ARCHIVE_STATE_DATA
,
675 "archive_write_finish_entry");
676 if (a
->archive
.state
& ARCHIVE_STATE_DATA
677 && a
->format_finish_entry
!= NULL
)
678 ret
= (a
->format_finish_entry
)(a
);
679 a
->archive
.state
= ARCHIVE_STATE_HEADER
;
684 * Note that the compressor is responsible for blocking.
687 _archive_write_data(struct archive
*_a
, const void *buff
, size_t s
)
689 struct archive_write
*a
= (struct archive_write
*)_a
;
690 const size_t max_write
= INT_MAX
;
692 archive_check_magic(&a
->archive
, ARCHIVE_WRITE_MAGIC
,
693 ARCHIVE_STATE_DATA
, "archive_write_data");
694 /* In particular, this catches attempts to pass negative values. */
697 archive_clear_error(&a
->archive
);
698 return ((a
->format_write_data
)(a
, buff
, s
));
701 static struct archive_write_filter
*
702 filter_lookup(struct archive
*_a
, int n
)
704 struct archive_write
*a
= (struct archive_write
*)_a
;
705 struct archive_write_filter
*f
= a
->filter_first
;
707 return a
->filter_last
;
710 while (n
> 0 && f
!= NULL
) {
718 _archive_filter_code(struct archive
*_a
, int n
)
720 struct archive_write_filter
*f
= filter_lookup(_a
, n
);
721 return f
== NULL
? -1 : f
->code
;
725 _archive_filter_name(struct archive
*_a
, int n
)
727 struct archive_write_filter
*f
= filter_lookup(_a
, n
);
728 return f
!= NULL
? f
->name
: NULL
;
732 _archive_filter_bytes(struct archive
*_a
, int n
)
734 struct archive_write_filter
*f
= filter_lookup(_a
, n
);
735 return f
== NULL
? -1 : f
->bytes_written
;