}
}
- if (archive_write_finish(a) != ARCHIVE_OK)
+ if (archive_write_free(a) != ARCHIVE_OK)
errx(EXIT_FAILURE, "%s", archive_error_string(a));
if (error != 0)
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
- archive_write_finish(cpio->archive);
+ archive_write_free(cpio->archive);
}
/*
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
- archive_read_finish(a);
- archive_write_finish(ext);
+ archive_read_free(a);
+ archive_write_free(ext);
exit(cpio->return_value);
}
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
- archive_read_finish(a);
+ archive_read_free(a);
exit(0);
}
blocks == 1 ? "block" : "blocks");
}
- archive_write_finish(cpio->archive);
+ archive_write_free(cpio->archive);
}
/*
argv++;
}
archive_write_close(a);
- archive_write_finish(a);
+ archive_write_free(a);
}
#endif
msg("\n");
}
archive_read_close(a);
- archive_read_finish(a);
+ archive_read_free(a);
exit(0);
}
if (r != ARCHIVE_EOF)
die("Error reading archive");
/* Close the archives. */
- if (archive_read_finish(ina) != ARCHIVE_OK)
+ if (archive_read_free(ina) != ARCHIVE_OK)
die("Error closing input archive");
- if (archive_write_finish(outa) != ARCHIVE_OK)
+ if (archive_write_free(outa) != ARCHIVE_OK)
die("Error closing output archive");
return (0);
}
msg("\n");
}
archive_read_close(a);
- archive_read_finish(a);
+ archive_read_free(a);
exit(0);
}
/* Close the file and release most resources. */
__LA_DECL int archive_read_close(struct archive *);
/* Release all resources and destroy the object. */
-/* Note that archive_read_finish will call archive_read_close for you. */
+/* Note that archive_read_free will call archive_read_close for you. */
+__LA_DECL int archive_read_free(struct archive *);
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Synonym for archive_read_free() for backwards compatibility. */
__LA_DECL int archive_read_finish(struct archive *);
+#endif
/*-
* To create an archive:
* - archive_write_header to write the header
* - archive_write_data to write the entry data
* 5) archive_write_close to close the output
- * 6) archive_write_finish to cleanup the writer and release resources
+ * 6) archive_write_free to cleanup the writer and release resources
*/
__LA_DECL struct archive *archive_write_new(void);
__LA_DECL int archive_write_set_bytes_per_block(struct archive *,
#endif
__LA_DECL int archive_write_finish_entry(struct archive *);
__LA_DECL int archive_write_close(struct archive *);
-/* Libarchive 2.x and later returns an error if this fails. */
-/* It can fail if the archive wasn't already closed, in which case
- * archive_write_finish() will implicitly call archive_write_close(). */
+/* This can fail if the archive wasn't already closed, in which case
+ * archive_write_free() will implicitly call archive_write_close(). */
+__LA_DECL int archive_write_free(struct archive *);
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Synonym for archive_write_free() for backwards compatibility. */
__LA_DECL int archive_write_finish(struct archive *);
+#endif
/*
* Set write options.
* - construct an appropriate struct archive_entry structure
* - archive_write_header to create the file/dir/etc on disk
* - archive_write_data to write the entry data
- * 4) archive_write_finish to cleanup the writer and release resources
+ * 4) archive_write_free to cleanup the writer and release resources
*
* In particular, you can use this in conjunction with archive_read()
* to pull entries out of an archive and create them on disk.
struct archive_vtable {
int (*archive_close)(struct archive *);
- int (*archive_finish)(struct archive *);
+ int (*archive_free)(struct archive *);
int (*archive_write_header)(struct archive *,
struct archive_entry *);
int (*archive_write_finish_entry)(struct archive *);
.Nm archive_read_extract2 ,
.Nm archive_read_extract_set_progress_callback ,
.Nm archive_read_close ,
-.Nm archive_read_finish
+.Nm archive_read_free
.Nd functions for reading streaming archives
.Sh SYNOPSIS
.In archive.h
.Ft int
.Fn archive_read_close "struct archive *"
.Ft int
-.Fn archive_read_finish "struct archive *"
+.Fn archive_read_free "struct archive *"
.Sh DESCRIPTION
These functions provide a complete API for reading streaming archives.
The general process is to first create the
can be retrieved for the progress display.
.It Fn archive_read_close
Complete the archive and invoke the close callback.
-.It Fn archive_read_finish
+.It Fn archive_read_free
Invokes
.Fn archive_read_close
if it was not invoked manually, then release all resources.
printf("%s\\n",archive_entry_pathname(entry));
archive_read_data_skip(a);
}
- archive_read_finish(a);
+ archive_read_free(a);
free(mydata);
}
static int cleanup_filters(struct archive_read *);
static struct archive_vtable *archive_read_vtable(void);
static int _archive_read_close(struct archive *);
-static int _archive_read_finish(struct archive *);
+static int _archive_read_free(struct archive *);
static struct archive_vtable *
archive_read_vtable(void)
static int inited = 0;
if (!inited) {
- av.archive_finish = _archive_read_finish;
+ av.archive_free = _archive_read_free;
av.archive_close = _archive_read_close;
}
return (&av);
* Release memory and other resources.
*/
static int
-_archive_read_finish(struct archive *_a)
+_archive_read_free(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int i;
int r = ARCHIVE_OK;
__archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
- "archive_read_finish");
+ "archive_read_free");
if (a->archive.state != ARCHIVE_STATE_CLOSED)
r = archive_read_close(&a->archive);
.Nm archive_read_disk_set_gname_lookup ,
.Nm archive_read_disk_set_standard_lookup ,
.Nm archive_read_close ,
-.Nm archive_read_finish
+.Nm archive_read_free
.Nd functions for reading objects from disk
.Sh SYNOPSIS
.In archive.h
.Ft int
.Fn archive_read_close "struct archive *"
.Ft int
-.Fn archive_read_finish "struct archive *"
+.Fn archive_read_free "struct archive *"
.Sh DESCRIPTION
These functions provide an API for reading information about
objects on disk.
object.
.It Fn archive_read_close
This currently does nothing.
-.It Fn archive_write_finish
+.It Fn archive_write_free
Invokes
.Fn archive_write_close
if it was not invoked manually, then releases all resources.
while ((bytes_read = read(fd, buff, sizeof(buff))) > 0)
archive_write_data(a, buff, bytes_read);
archive_write_finish_entry(a);
- archive_read_finish(ard);
+ archive_read_free(ard);
archive_entry_free(entry);
}
.Ed
#include "archive_private.h"
#include "archive_read_disk_private.h"
-static int _archive_read_finish(struct archive *);
+static int _archive_read_free(struct archive *);
static int _archive_read_close(struct archive *);
static const char *trivial_lookup_gname(void *, gid_t gid);
static const char *trivial_lookup_uname(void *, uid_t uid);
static int inited = 0;
if (!inited) {
- av.archive_finish = _archive_read_finish;
+ av.archive_free = _archive_read_free;
av.archive_close = _archive_read_close;
}
return (&av);
}
static int
-_archive_read_finish(struct archive *_a)
+_archive_read_free(struct archive *_a)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
{
int ret = ARCHIVE_OK;
- ret = archive_write_finish(a->extract->ad);
+ ret = archive_write_free(a->extract->ad);
free(a->extract);
a->extract = NULL;
return (ret);
return ((a->vtable->archive_close)(a));
}
+int
+archive_write_free(struct archive *a)
+{
+ return ((a->vtable->archive_free)(a));
+}
+
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* For backwards compatibility; will be removed with libarchive 4.0. */
int
archive_write_finish(struct archive *a)
{
- return ((a->vtable->archive_finish)(a));
+ return ((a->vtable->archive_free)(a));
+}
+#endif
+
+int
+archive_read_free(struct archive *a)
+{
+ return ((a->vtable->archive_free)(a));
}
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* For backwards compatibility; will be removed with libarchive 4.0. */
int
archive_read_finish(struct archive *a)
{
- return ((a->vtable->archive_finish)(a));
+ return ((a->vtable->archive_free)(a));
}
+#endif
int
archive_write_header(struct archive *a, struct archive_entry *entry)
.Nm archive_write_data ,
.Nm archive_write_finish_entry ,
.Nm archive_write_close ,
-.Nm archive_write_finish
+.Nm archive_write_free
.Nd functions for creating archives
.Sh SYNOPSIS
.In archive.h
.Ft int
.Fn archive_write_close "struct archive *"
.Ft int
-.Fn archive_write_finish "struct archive *"
+.Fn archive_write_free "struct archive *"
.Sh DESCRIPTION
These functions provide a complete API for creating streaming
archive files.
as needed.
.It Fn archive_write_close
Complete the archive and invoke the close callback.
-.It Fn archive_write_finish
+.It Fn archive_write_free
Invokes
.Fn archive_write_close
-if it was not invoked manually, then releases all resources.
-Note that this function was declared to return
-.Ft void
-in libarchive 1.x, which made it impossible to detect errors when
+if necessary, then releases all resources.
+If you need detailed information about
.Fn archive_write_close
-was invoked implicitly from this function.
-This is corrected beginning with libarchive 2.0.
+failures, you should be careful to call it separately, as
+you cannot obtain error information after
+.Fn archive_write_free
+returns.
.El
More information about the
.Va struct archive
archive_entry_free(entry);
filename++;
}
- archive_write_finish(a);
+ archive_write_free(a);
}
int main(int argc, const char **argv)
.Fn archive_write_data ,
.Fn archive_write_close ,
or
-.Fn archive_write_finish .
+.Fn archive_write_free .
The client callback can call
.Fn archive_set_error
to provide values that can then be retrieved by
static struct archive_vtable *archive_write_vtable(void);
static int _archive_write_close(struct archive *);
-static int _archive_write_finish(struct archive *);
+static int _archive_write_free(struct archive *);
static int _archive_write_header(struct archive *, struct archive_entry *);
static int _archive_write_finish_entry(struct archive *);
static ssize_t _archive_write_data(struct archive *, const void *, size_t);
if (!inited) {
av.archive_close = _archive_write_close;
- av.archive_finish = _archive_write_finish;
+ av.archive_free = _archive_write_free;
av.archive_write_header = _archive_write_header;
av.archive_write_finish_entry = _archive_write_finish_entry;
av.archive_write_data = _archive_write_data;
* Destroy the archive structure.
*/
static int
-_archive_write_finish(struct archive *_a)
+_archive_write_free(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r = ARCHIVE_OK;
__archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
- ARCHIVE_STATE_ANY, "archive_write_finish");
+ ARCHIVE_STATE_ANY, "archive_write_free");
if (a->archive.state != ARCHIVE_STATE_CLOSED)
r = archive_write_close(&a->archive);
.Nm archive_write_data ,
.Nm archive_write_finish_entry ,
.Nm archive_write_close ,
-.Nm archive_write_finish
+.Nm archive_write_free
.Nd functions for creating objects on disk
.Sh SYNOPSIS
.In archive.h
.Ft int
.Fn archive_write_close "struct archive *"
.Ft int
-.Fn archive_write_finish "struct archive *"
+.Fn archive_write_free "struct archive *"
.Sh DESCRIPTION
These functions provide a complete API for creating objects on
disk from
.Nm
library maintains a list of all such deferred attributes and
sets them when this function is invoked.
-.It Fn archive_write_finish
+.It Fn archive_write_free
Invokes
.Fn archive_write_close
if it was not invoked manually, then releases all resources.
There should be a corresponding
.Nm archive_read_disk
interface that walks a directory heirarchy and returns archive
-entry objects.
\ No newline at end of file
+entry objects.
static struct archive_vtable *archive_write_disk_vtable(void);
static int _archive_write_close(struct archive *);
-static int _archive_write_finish(struct archive *);
+static int _archive_write_free(struct archive *);
static int _archive_write_header(struct archive *, struct archive_entry *);
static int _archive_write_finish_entry(struct archive *);
static ssize_t _archive_write_data(struct archive *, const void *, size_t);
if (!inited) {
av.archive_close = _archive_write_close;
- av.archive_finish = _archive_write_finish;
+ av.archive_free = _archive_write_free;
av.archive_write_header = _archive_write_header;
av.archive_write_finish_entry = _archive_write_finish_entry;
av.archive_write_data = _archive_write_data;
}
static int
-_archive_write_finish(struct archive *_a)
+_archive_write_free(struct archive *_a)
{
struct archive_write_disk *a = (struct archive_write_disk *)_a;
int ret;
.\"
.\" $FreeBSD: src/lib/libarchive/libarchive.3,v 1.11 2007/01/09 08:05:56 kientzle Exp $
.\"
-.Dd August 19, 2006
+.Dd February 6, 2010
.Dt LIBARCHIVE 3
.Os
.Sh NAME
.It
most common cpio archive formats,
.It
-ISO9660 CD images (with or without RockRidge extensions),
+ISO9660 CD images (including RockRidge and Joliet extensions),
.It
Zip archives.
.El
The library automatically detects archives compressed with
.Xr gzip 1 ,
.Xr bzip2 1 ,
+.Xr xz 1 ,
or
.Xr compress 1
and decompresses them transparently.
.It
POSIX octet-oriented cpio archives,
.It
+Zip archive,
+.It
two different variants of shar archives.
.El
Pax interchange format is an extension of the tar archive format that
(which works much like the
.Xr read 2
system call)
-to read this data from the archive.
+to read this data from the archive, or
+.Fn archive_read_data_block
+which provides a slightly more efficient interface.
You may prefer to use the higher-level
.Fn archive_read_data_skip ,
which reads and discards the data for this entry,
-.Fn archive_read_data_to_buffer ,
-which reads the data into an in-memory buffer,
.Fn archive_read_data_to_file ,
which copies the data to the provided file descriptor, or
.Fn archive_read_extract ,
should call
.Fn archive_read_close
to close the archive, then call
-.Fn archive_read_finish
+.Fn archive_read_free
to release all resources, including all memory allocated by the library.
.Pp
The
to write the actual data.
.Pp
After all entries have been written, use the
-.Fn archive_write_finish
+.Fn archive_write_free
function to release all resources.
.Pp
The
.Xr archive_write 3
manual page provides more detailed calling information for this API.
+.Sh WRITING ENTRIES TO DISK
+The
+.Xr archive_write_disk 3
+API allows you to write
+.Xr archive_entry 3
+objects to disk using the same API used by
+.Xr archive_write 3 .
+The
+.Xr archive_write_disk 3
+API is used internally by
+.Fn archive_read_extract ;
+using it directly can provide greater control over how entries
+get written to disk.
+This API also makes it possible to share code between
+archive-to-archive copy and archive-to-disk extraction
+operations.
+.Sh READING ENTRIES FROM DISK
+The
+.Xr archive_read_disk 3
+provides some support for populating
+.Xr archive_entry 3
+objects from information in the filesystem.
.Sh DESCRIPTION
Detailed descriptions of each function are provided by the
corresponding manual pages.
in arbitrary character sets that exceed
.Va PATH_MAX .
.Sh RETURN VALUES
-Most functions return zero on success, non-zero on error.
+Most functions return
+.Cm ARCHIVE_OK
+(zero) on success, non-zero on error.
The return value indicates the general severity of the error, ranging
from
.Cm ARCHIVE_WARN ,
is supported by all formats.
For example, cpio formats do not support nanosecond timestamps;
old tar formats do not support large device numbers.
+.Pp
+The
+.Xr archive_read_disk 3
+API should support iterating over filesystems;
+that would make it possible to share code among
+disk-to-archive, archive-to-archive, archive-to-disk,
+and disk-to-disk operations.
+Currently, it only supports reading the
+information for a single file.
+(Which is still quite useful, as it hides a lot
+of system-specific details.)
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the data on disk. */
assertEqualInt(0, stat("test0", &st));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Write out the data we generated to a file for manual inspection. */
assert(NULL != (f = fopen("testout", "wb")));
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertA(0 == archive_read_support_compression_all(a));
assertA(ARCHIVE_FATAL == archive_read_open_fd(a, -1, 1024));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Read first entry. */
assertEqualIntA(a, ARCHIVE_OK, r = archive_read_next_header(a, &ae));
if (r != ARCHIVE_OK) {
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
assertEqualString(
/* Read second entry. */
assertEqualIntA(a, ARCHIVE_OK, r = archive_read_next_header(a, &ae));
if (r != ARCHIVE_OK) {
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
assertEqualString(
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_GNUTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualIntA(a, ARCHIVE_OK,
archive_read_next_header(a, &ae));
if (r != ARCHIVE_OK) {
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
assertEqualString(n[i], archive_entry_pathname(ae));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_compat_tar_hardlink)
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
finish:
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
}
/*
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
}
/*
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
}
assertEqualIntA(a, ARCHIVE_WARN, archive_write_close(a));
else
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the data on disk. */
assertEqualInt(0, stat("test0", &st));
assertEqualInt(xsize, 5);
assertEqualMem(xval, "12345", xsize);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
archive_entry_free(ae);
#endif
}
archive_read_support_format_raw(a));
r = archive_read_open_filename(a, filename, 16384);
if (r != ARCHIVE_OK) {
- archive_read_finish(a);
+ archive_read_free(a);
skipping("Cannot uncompress %s", filename);
continue;
}
assertEqualIntA(a, ARCHIVE_EOF,
archive_read_next_header(a, &ae));
assertEqualInt(ARCHIVE_OK,
- archive_read_finish(a));
+ archive_read_free(a));
assert(size > 0);
failure("Internal buffer is not big enough for "
"uncompressed test file: %s", filename);
}
archive_read_close(a);
}
- archive_read_finish(a);
+ archive_read_free(a);
}
free(image);
free(rawimage);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
close(fd);
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_fd(a, 100, 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
fclose(f);
/*
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
fclose(f);
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Verify some of the error handling.
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_filename(a, "nonexistent.tar", 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
" characters in it without generating a warning");
assertEqualInt(ARCHIVE_OK, archive_read_next_header(a, &entry));
assertEqualString(filename, archive_entry_pathname(entry));
- archive_read_finish(a);
+ archive_read_free(a);
}
/*
archive_entry_free(entry);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now read the entries back.
assertEqualString(longname, archive_entry_pathname(entry));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/*
archive_entry_free(entry);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now read the entries back.
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &entry));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_pax_filename_encoding)
assertEqualIntA(a, ARCHIVE_FATAL,
archive_read_open_memory(a, archive, sizeof(archive)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* If we have "gzip -d", try using that.
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_PROGRAM);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Check that archive_read_data can handle 10*10^6 at a pop. */
assert((a = archive_read_new()) != NULL);
failure("Read expected 10MB, but data read didn't match what was written");
assert(0 == memcmp(buff2, buff3, sizeof(buff3)));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Check archive_read_data_into_fd */
assert((a = archive_read_new()) != NULL);
assert(tmpfilefd != 0);
assertEqualIntA(a, 0, archive_read_data_into_fd(a, tmpfilefd));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
close(tmpfilefd);
f = fopen(tmpfilename, "rb");
&umagic, &uname_lookup, &uname_cleanup));
/* Destroy the archive. */
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Verify our cleanup functions got called. */
assertEqualInt(gmagic, 0x2468);
/* Destroy the archive. */
archive_entry_free(entry);
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Extract the entries to disk. */
assert((a = archive_read_new()) != NULL);
}
assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Test the entries on disk. */
/* This first entry was extracted with ARCHIVE_EXTRACT_PERM,
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(ARCHIVE_FATAL,
archive_read_open_filename(a, "notexistent.tar", 512));
- archive_read_finish(a);
+ archive_read_free(a);
}
/* Test EOF */
assertA(1 == archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertA(archive_compression(a) == ARCHIVE_COMPRESSION_NONE);
assertA(archive_format(a) == ARCHIVE_FORMAT_CPIO_AFIO_LARGE);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
-
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
+
free(p);
}
assertA(archive_compression(a) == ARCHIVE_COMPRESSION_NONE);
assertA(archive_format(a) == ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
archive_format_name(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_BE);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assert(archive_compression(a) == ARCHIVE_COMPRESSION_BZIP2);
assert(archive_format(a) == ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
failure("archive_read_support_compression_gzip");
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_LZMA);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_XZ);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_BIN_LE);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertA(archive_compression(a) == ARCHIVE_COMPRESSION_NONE);
assertA(archive_format(a) == ARCHIVE_FORMAT_CPIO_POSIX);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_bzip2(a);
if (r == ARCHIVE_WARN) {
skipping("bzip2 reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_format(a),
ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, r);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
failure("archive_format_name(a)=\"%s\"", archive_format_name(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_CRC);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertA(archive_compression(a) == ARCHIVE_COMPRESSION_NONE);
assertA(archive_format(a) == ARCHIVE_FORMAT_EMPTY);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_GNUTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_GNUTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
finish:
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
struct contents *cts = ac->contents;
if (!assertEqualIntA(a, 0, archive_read_next_header(a, &ae))) {
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
failure("Name mismatch in archive %s", name);
failure("%s: Unexpected trailing data",
name);
assert(actual.o <= expect.o);
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
actual.d++;
assertEqualIntA(a, ARCHIVE_EOF, err);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
ARCHIVE_COMPRESSION_COMPRESS);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
static void
assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE);
assertEqualIntA(a,ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Test EOF */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Second, try the same with a compressed file. */
/* Test EOF */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Single entry with a hardlink. */
f(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_bzip2(a);
if (r != ARCHIVE_OK) {
skipping("Bzip2 support");
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_gzip(a);
if (r == ARCHIVE_WARN) {
skipping("gzip reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualInt(ARCHIVE_OK, archive_read_support_format_all(a));
ARCHIVE_COMPRESSION_GZIP);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK,archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK,archive_read_free(a));
}
r = archive_read_support_compression_lzma(a);
if (r == ARCHIVE_WARN) {
skipping("lzma reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_LZMA);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_read_support_compression_xz(a);
if (r == ARCHIVE_WARN) {
skipping("xz reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_XZ);
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
failure("archive_format_name(a)=\"%s\"", archive_format_name(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
* This filter won't be used this test. */
if (ARCHIVE_OK != archive_read_support_compression_bzip2(a)) {
skipping("Unsupported bzip2");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
break;
r = archive_read_support_format_xar(a);
if (r == ARCHIVE_WARN) {
skipping("xar reading not fully supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assert((buff = malloc(100000)) != NULL);
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
assertA(archive_format(a) == ARCHIVE_FORMAT_ZIP);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
finish:
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
assertA(0 == archive_write_header(a, entry));
archive_entry_free(entry);
assertA((int)sizeof(testdata) == archive_write_data(a, testdata, sizeof(testdata)));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert(NULL != (a = archive_read_new()));
assertA(0 == archive_read_support_format_all(a));
assertA(0 == archive_read_open_memory(a, buff, sizeof(buff)));
assertA(0 == archive_read_next_header(a, &entry));
assertA(0 == archive_read_data_into_buffer(a, testdatacopy, sizeof(testdatacopy)));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
assert(0 == memcmp(testdata, testdatacopy, sizeof(testdata)));
assert(0 < tmpfilefd);
assertA(0 == archive_read_data_into_fd(a, tmpfilefd));
close(tmpfilefd);
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
f = fopen(tmpfilename, "rb");
assertEqualInt(sizeof(testdatacopy),
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Now, read back a truncated version of the archive and
* verify that we get an appropriate error. */
}
wrap_up:
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
}
wrap_up2:
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Now, damage the archive in various ways and test the responses. */
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the size field in the pax attributes. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the size field in the pax attributes. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the size field in the pax attributes. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the size field in the pax attributes. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the size field in the pax attributes. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_WARN, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/* Damage the ustar header. */
memcpy(buff2, buff, buff_size);
assertA(0 == archive_read_open_memory(a, buff2, used));
assertEqualIntA(a, ARCHIVE_FATAL, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* TODO: Damage the ustar header in various ways and fixup the
== (size_t)archive_write_data(a, nulls, sizeof(nulls)));
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Read the archive back. */
assert(NULL != (a = archive_read_new()));
assert(read_position == (intmax_t)archive_read_header_position(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assert(read_position == (intmax_t)archive_read_header_position(a));
- archive_read_finish(a);
+ archive_read_free(a);
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Now, read back a truncated version of the archive and
* verify that we get an appropriate error. */
}
wrap_up:
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
}
wrap_up2:
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
}
archive_format_name(a));
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
free(buff);
}
strcpy(p, "/file3");
verify_sparse_file(a, path, sparse_file3, 0);
- archive_read_finish(a);
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
/* Verify the end of the archive. */
assert(1 == archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_tar_filenames)
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Open the same archive for reading.
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(memdata.buff);
free(filedata);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
failure("This fails if entries were written that should not have been written. dlen=%d, flen=%d", dlen, flen);
assertEqualInt(1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_ustar_filenames)
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(data);
free(buff);
r = archive_write_set_compression_bzip2(a);
if (r == ARCHIVE_FATAL) {
skipping("bzip2 writing not supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat the cycle again, this time setting some compression
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat again, with much lower compression.
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
assertEqualInt((int)datasize, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Test various premature shutdown scenarios to make sure we
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_bzip2(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Clean up.
r = archive_write_set_compression_gzip(a);
if (r == ARCHIVE_FATAL) {
skipping("gzip writing not supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat the cycle again, this time setting some compression
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat again, with much lower compression.
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Test various premature shutdown scenarios to make sure we
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_gzip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Clean up.
r = archive_write_set_compression_lzma(a);
if (r == ARCHIVE_FATAL) {
skipping("lzma writing not supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat the cycle again, this time setting some compression
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat again, with much lower compression.
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Test various premature shutdown scenarios to make sure we
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_lzma(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Clean up.
if (r == ARCHIVE_FATAL) {
skipping("Write compression via external "
"program unsupported on this platform");
- archive_write_finish(a);
+ archive_write_free(a);
return;
}
assertA(0 == archive_write_set_bytes_per_block(a, blocksize));
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back through the built-in gzip support.
if (r != ARCHIVE_OK && !canGunzip()) {
skipping("No libz and no gunzip program, "
"unable to verify gzip compression");
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
if (!assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae))) {
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
r = archive_write_set_compression_xz(a);
if (r == ARCHIVE_FATAL) {
skipping("xz writing not supported on this platform");
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
return;
}
assertEqualIntA(a, ARCHIVE_OK,
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat the cycle again, this time setting some compression
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Curiously, this test fails; the test data above compresses
* better at default compression than at level 9. */
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Repeat again, with much lower compression.
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Level 0 really does result in larger data. */
failure("Compression-level=0 wrote %d bytes; default wrote %d bytes",
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
}
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Test various premature shutdown scenarios to make sure we
*/
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert((a = archive_write_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_xz(a));
assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, buffsize, &used2));
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Clean up.
failure("%s", msg);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entries on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entries on disk. */
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
archive_write_data_block(ad, data + i, 1000, i));
}
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entries on disk. */
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(5, archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entry on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
assertEqualInt(ARCHIVE_OK,
archive_write_data_block(ad, data, sizeof(data), 0));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entry on disk. */
assert(0 == stat(archive_entry_pathname(ae), &st));
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
assertEqualInt(sizeof(data), archive_write_data(ad, data, sizeof(data)));
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entries on disk. */
l = strlen(archive_entry_pathname(ae));
archive_entry_set_mtime(ae, 123456789, 0);
assertEqualIntA(a, ARCHIVE_FAILED, archive_write_header(a, ae));
assertEqualIntA(a, 0, archive_write_finish_entry(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
archive_entry_free(ae);
#endif
}
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
}
archive_entry_free(ae);
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
/* Test the entries on disk. */
assertEqualIntA(a,ARCHIVE_WARN,archive_write_finish_entry(a));
}
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
archive_entry_free(ae);
/* Test the entries on disk. */
assert(S_ISDIR(st.st_mode));
archive_entry_free(ae);
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Test the entries on disk. */
assert(0 == lstat("dir", &st));
archive_write_disk_set_options(ad, 0);
verify_write_data(ad, 0);
verify_write_data_block(ad, 0);
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
assert((ad = archive_write_disk_new()) != NULL);
archive_write_disk_set_options(ad, ARCHIVE_EXTRACT_SPARSE);
verify_write_data(ad, 1);
verify_write_data_block(ad, 1);
- assertEqualInt(0, archive_write_finish(ad));
+ assertEqualInt(0, archive_write_free(ad));
}
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
archive_entry_free(ae);
- assertEqualInt(ARCHIVE_OK, archive_write_finish(ad));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(ad));
/* Test the entries on disk. */
skipping("Platform-specific time restore tests");
#endif
- archive_write_finish(a);
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
}
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
assertEqualMem(buff2, "88877766", 8);
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Then, we try to create a BSD format archive.
assertEqualIntA(a, 6, archive_write_data(a, "555555", 7));
archive_entry_free(ae);
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Now, Read the data back */
assert((a = archive_read_new()) != NULL);
/* Test EOF */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Damage the second entry to test the search-ahead recovery.
assertA(0 == archive_read_open_memory(a, buff, used));
if (!assertEqualIntA(a, 0, archive_read_next_header(a, &ae))) {
- archive_read_finish(a);
+ archive_read_free(a);
return;
}
/* Verify the end of the archive. */
assertEqualIntA(a, 1, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
failure("Empty cpio archive should be exactly 87 bytes, was %d.", used);
assert(used == 87);
assertEqualIntA(a, 0, archive_write_header(a, entry));
archive_entry_free(entry);
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Verify the archive format.
/* Write of data to symlink should fail == zero bytes get written. */
assertEqualIntA(a, 0, archive_write_data(a, "1234567890", 10));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Verify the archive format.
archive_entry_free(ae);
}
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
if (use_set) {
const char *p;
assertEqualInt(8, archive_entry_size(ae));
}
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_write_format_mtree)
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualIntA(a, ARCHIVE_OK, archive_write_finish(a));
+ assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
/*
*
*/
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualIntA(a, ARCHIVE_OK, archive_read_finish(a));
+ assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
free(buff);
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
failure("Empty shar archive should be exactly 0 bytes, was %d.", used);
assert(used == 0);
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* This calculation gives "the smallest multiple of
* the block size that is at least 2048 bytes". */
/* Verify the end of the archive. */
assert(1 == archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
}
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert(used == 1024);
for (i = 0; i < used; i++) {
/* Close out the archive. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assertEqualInt((int)used, 1024);
for (i = 0; i < used; i++) {
archive_entry_set_nlink(entry, 1);
assertEqualIntA(a, 0, archive_write_header(a, entry));
archive_entry_free(entry);
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Verify the archive format.
/* Close out the archive. */
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/*
* Now, read the data back.
/* Verify the end of the archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
- assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_read_free(a));
free(buff);
}
/* Close out the archive without writing anything. */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Verify the correct format for an empy Zip archive. */
assertEqualInt(used, 22);
/* Close the archive . */
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
/* Remember the end of the archive in memory. */
buffend = buff + used;
assertA(ARCHIVE_FATAL == archive_write_close(a));
else
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
- assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
+ assertEqualInt(ARCHIVE_OK, archive_write_free(a));
assert(buff[i] == 0xAE);
assert(s <= i);
}
fprintf(stdout, "Archive Format: %s, Compression: %s\n",
archive_format_name(a), archive_compression_name(a));
- archive_read_finish(a);
+ archive_read_free(a);
}
archive_error_string(a));
while (0 == archive_read_next_header(a, &entry)) {
if (archive_compression(a) != ARCHIVE_COMPRESSION_NONE) {
- archive_read_finish(a);
+ archive_read_free(a);
close(bsdtar->fd);
lafe_errc(1, 0,
"Cannot append to compressed archive.");
}
end_offset = archive_read_header_position(a);
- archive_read_finish(a);
+ archive_read_free(a);
/* Re-open archive for writing */
a = archive_write_new();
/* Build a list of all entries and their recorded mod times. */
while (0 == archive_read_next_header(a, &entry)) {
if (archive_compression(a) != ARCHIVE_COMPRESSION_NONE) {
- archive_read_finish(a);
+ archive_read_free(a);
close(bsdtar->fd);
lafe_errc(1, 0,
"Cannot append to compressed archive.");
}
end_offset = archive_read_header_position(a);
- archive_read_finish(a);
+ archive_read_free(a);
/* Re-open archive for writing. */
a = archive_write_new();
free(bsdtar->buff);
archive_entry_linkresolver_free(bsdtar->resolver);
bsdtar->resolver = NULL;
- archive_read_finish(bsdtar->diskreader);
+ archive_read_free(bsdtar->diskreader);
bsdtar->diskreader = NULL;
if (bsdtar->option_totals) {
tar_i64toa(archive_position_compressed(a)));
}
- archive_write_finish(a);
+ archive_write_free(a);
}
/*
filename, archive_error_string(ina));
bsdtar->return_value = 1;
}
- archive_read_finish(ina);
+ archive_read_free(ina);
return (rc);
}
projects / thirdparty / libarchive.git / commitdiff
