A raft of test changes and improvements from the Googlecode repository.
In particular, this includes tests for the new features I've merged over the last few days.
This commit is contained in:
Tim Kientzle
parent
f124826e0d
commit
0a1d787383
@ -14,8 +14,10 @@ TESTS= \
|
||||
test_archive_api_feature.c \
|
||||
test_bad_fd.c \
|
||||
test_compat_bzip2.c \
|
||||
test_compat_cpio.c \
|
||||
test_compat_gtar.c \
|
||||
test_compat_gzip.c \
|
||||
test_compat_lzma.c \
|
||||
test_compat_solaris_tar_acl.c \
|
||||
test_compat_tar_hardlink.c \
|
||||
test_compat_xz.c \
|
||||
@ -42,6 +44,7 @@ TESTS= \
|
||||
test_read_format_cpio_bin_be.c \
|
||||
test_read_format_cpio_bin_bz2.c \
|
||||
test_read_format_cpio_bin_gz.c \
|
||||
test_read_format_cpio_bin_lzma.c \
|
||||
test_read_format_cpio_bin_xz.c \
|
||||
test_read_format_cpio_odc.c \
|
||||
test_read_format_cpio_svr4_gzip.c \
|
||||
@ -51,8 +54,15 @@ TESTS= \
|
||||
test_read_format_gtar_lzma.c \
|
||||
test_read_format_gtar_sparse.c \
|
||||
test_read_format_iso_gz.c \
|
||||
test_read_format_iso_multi_extent.c \
|
||||
test_read_format_isorr_rr_moved.c \
|
||||
test_read_format_isojoliet_bz2.c \
|
||||
test_read_format_isojoliet_long.c \
|
||||
test_read_format_isojoliet_rr.c \
|
||||
test_read_format_isorr_bz2.c \
|
||||
test_read_format_isorr_ce.c \
|
||||
test_read_format_isorr_new_bz2.c \
|
||||
test_read_format_isozisofs_bz2.c \
|
||||
test_read_format_mtree.c \
|
||||
test_read_format_pax_bz2.c \
|
||||
test_read_format_raw.c \
|
||||
@ -60,6 +70,7 @@ TESTS= \
|
||||
test_read_format_tar_empty_filename.c \
|
||||
test_read_format_tbz.c \
|
||||
test_read_format_tgz.c \
|
||||
test_read_format_tlz.c \
|
||||
test_read_format_txz.c \
|
||||
test_read_format_tz.c \
|
||||
test_read_format_zip.c \
|
||||
@ -82,6 +93,7 @@ TESTS= \
|
||||
test_write_disk_perms.c \
|
||||
test_write_disk_secure.c \
|
||||
test_write_disk_sparse.c \
|
||||
test_write_disk_symlink.c \
|
||||
test_write_disk_times.c \
|
||||
test_write_format_ar.c \
|
||||
test_write_format_cpio.c \
|
||||
@ -94,6 +106,9 @@ TESTS= \
|
||||
test_write_format_tar.c \
|
||||
test_write_format_tar_empty.c \
|
||||
test_write_format_tar_ustar.c \
|
||||
test_write_format_zip.c \
|
||||
test_write_format_zip_empty.c \
|
||||
test_write_format_zip_no_compression.c \
|
||||
test_write_open_memory.c
|
||||
|
||||
|
||||
@ -108,16 +123,12 @@ NO_MAN=yes
|
||||
|
||||
PROG=libarchive_test
|
||||
INTERNALPROG=yes # Don't install this; it's just for testing
|
||||
DPADD=${LIBBZ2} ${LIBZ}
|
||||
DPADD=${LIBBZ2} ${LIBZ} ${LIBMD} ${LIBCRYPTO} ${LIBBSDXML}
|
||||
CFLAGS+= -DPLATFORM_CONFIG_H=\"config_freebsd.h\"
|
||||
LDADD= -lz -lbz2 -lmd -lcrypto
|
||||
LDADD= -lz -lbz2 -lmd -lcrypto -lbsdxml
|
||||
CFLAGS+= -g
|
||||
CFLAGS+= -I${LA_SRCDIR} -I.
|
||||
|
||||
# Uncomment to build and test lzma support via liblzmadec
|
||||
#CFLAGS+= -I/usr/local/include -DHAVE_LIBLZMADEC=1 -DHAVE_LZMADEC_H=1
|
||||
#LDADD+= -L/usr/local/lib -llzmadec
|
||||
|
||||
# Uncomment to build and test lzma and xz support via liblzma
|
||||
#CFLAGS+= -I/usr/local/include -DHAVE_LIBLZMA=1 -DHAVE_LZMA_H=1
|
||||
#LDADD+= -L/usr/local/lib -llzma
|
||||
@ -125,11 +136,11 @@ CFLAGS+= -I${LA_SRCDIR} -I.
|
||||
# Uncomment to link against dmalloc
|
||||
#LDADD+= -L/usr/local/lib -ldmalloc
|
||||
#CFLAGS+= -I/usr/local/include -DUSE_DMALLOC
|
||||
WARNS=6
|
||||
#WARNS=6
|
||||
|
||||
# Build libarchive_test and run it.
|
||||
check test: libarchive_test
|
||||
./libarchive_test -v -r ${.CURDIR}
|
||||
./libarchive_test -r ${.CURDIR}
|
||||
|
||||
# list.h is just a list of all tests, as indicated by DEFINE_TEST macro lines
|
||||
list.h: ${TESTS} Makefile
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -45,43 +45,85 @@
|
||||
#error Oops: No config.h and no pre-built configuration in test.h.
|
||||
#endif
|
||||
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
#include <dirent.h>
|
||||
#else
|
||||
#include <direct.h>
|
||||
#endif
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h> /* Windows requires this before sys/stat.h */
|
||||
#include <sys/stat.h>
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <wchar.h>
|
||||
|
||||
#ifdef USE_DMALLOC
|
||||
#include <dmalloc.h>
|
||||
#endif
|
||||
#if HAVE_DIRENT_H
|
||||
#include <dirent.h>
|
||||
#endif
|
||||
#ifdef HAVE_DIRECT_H
|
||||
#include <direct.h>
|
||||
#define dirent direct
|
||||
#endif
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#ifdef HAVE_IO_H
|
||||
#include <io.h>
|
||||
#endif
|
||||
#ifdef HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#ifdef HAVE_UNISTD_H
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <wchar.h>
|
||||
#ifdef HAVE_WINDOWS_H
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
/* No non-FreeBSD platform will have __FBSDID, so just define it here. */
|
||||
#ifdef __FreeBSD__
|
||||
#include <sys/cdefs.h> /* For __FBSDID */
|
||||
#else
|
||||
/* Some non-FreeBSD platforms such as newlib-derived ones like
|
||||
* cygwin, have __FBSDID, so this definition must be guarded.
|
||||
/*
|
||||
* System-specific tweaks. We really want to minimize these
|
||||
* as much as possible, since they make it harder to understand
|
||||
* the mainline code.
|
||||
*/
|
||||
#ifndef __FBSDID
|
||||
#define __FBSDID(a) /* null */
|
||||
|
||||
/* Windows (including Visual Studio and MinGW but not Cygwin) */
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
#if !defined(__BORLANDC__)
|
||||
#define strdup _strdup
|
||||
#endif
|
||||
#define LOCALE_UTF8 NULL
|
||||
#else
|
||||
#define LOCALE_UTF8 "de_DE.UTF-8"
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
/* Visual Studio */
|
||||
#ifdef _MSC_VER
|
||||
#define snprintf sprintf_s
|
||||
#define LOCALE_DE "deu"
|
||||
#else
|
||||
#define LOCALE_DE "de_DE.UTF-8"
|
||||
#endif
|
||||
|
||||
#if defined(__BORLANDC__)
|
||||
#pragma warn -8068 /* Constant out of range in comparison. */
|
||||
#endif
|
||||
|
||||
/* Cygwin */
|
||||
#if defined(__CYGWIN__)
|
||||
/* Cygwin-1.7.x is lazy about populating nlinks, so don't
|
||||
* expect it to be accurate. */
|
||||
# define NLINKS_INACCURATE_FOR_DIRS
|
||||
#endif
|
||||
|
||||
/* Haiku OS */
|
||||
#if defined(__HAIKU__)
|
||||
/* Haiku has typedefs in stdint.h (needed for int64_t) */
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
/* Get a real definition for __FBSDID if we can */
|
||||
#if HAVE_SYS_CDEFS_H
|
||||
#include <sys/cdefs.h>
|
||||
#endif
|
||||
|
||||
/* If not, define it so as to avoid dangling semicolons. */
|
||||
#ifndef __FBSDID
|
||||
#define __FBSDID(a) struct _undefined_hack
|
||||
#endif
|
||||
|
||||
#ifndef O_BINARY
|
||||
@ -95,38 +137,81 @@
|
||||
#define DEFINE_TEST(name) void name(void); void name(void)
|
||||
|
||||
/* An implementation of the standard assert() macro */
|
||||
#define assert(e) test_assert(__FILE__, __LINE__, (e), #e, NULL)
|
||||
|
||||
#define assert(e) assertion_assert(__FILE__, __LINE__, (e), #e, NULL)
|
||||
/* chdir() and error if it fails */
|
||||
#define assertChdir(path) \
|
||||
assertion_chdir(__FILE__, __LINE__, path)
|
||||
/* Assert two integers are the same. Reports value of each one if not. */
|
||||
#define assertEqualInt(v1,v2) \
|
||||
test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
|
||||
#define assertEqualInt(v1,v2) \
|
||||
assertion_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
/* Assert two strings are the same. Reports value of each one if not. */
|
||||
#define assertEqualString(v1,v2) \
|
||||
test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
assertion_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
/* As above, but v1 and v2 are wchar_t * */
|
||||
#define assertEqualWString(v1,v2) \
|
||||
test_assert_equal_wstring(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
assertion_equal_wstring(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
|
||||
/* As above, but raw blocks of bytes. */
|
||||
#define assertEqualMem(v1, v2, l) \
|
||||
test_assert_equal_mem(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (l), #l, NULL)
|
||||
assertion_equal_mem(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (l), #l, NULL)
|
||||
/* Assert two files are the same; allow printf-style expansion of second name.
|
||||
* See below for comments about variable arguments here...
|
||||
*/
|
||||
#define assertEqualFile \
|
||||
test_setup(__FILE__, __LINE__);test_assert_equal_file
|
||||
assertion_setup(__FILE__, __LINE__);assertion_equal_file
|
||||
/* Assert that a file is empty; supports printf-style arguments. */
|
||||
#define assertEmptyFile \
|
||||
test_setup(__FILE__, __LINE__);test_assert_empty_file
|
||||
assertion_setup(__FILE__, __LINE__);assertion_empty_file
|
||||
/* Assert that a file is not empty; supports printf-style arguments. */
|
||||
#define assertNonEmptyFile \
|
||||
assertion_setup(__FILE__, __LINE__);assertion_non_empty_file
|
||||
#define assertFileAtime(pathname, sec, nsec) \
|
||||
assertion_file_atime(__FILE__, __LINE__, pathname, sec, nsec)
|
||||
#define assertFileAtimeRecent(pathname) \
|
||||
assertion_file_atime_recent(__FILE__, __LINE__, pathname)
|
||||
#define assertFileBirthtime(pathname, sec, nsec) \
|
||||
assertion_file_birthtime(__FILE__, __LINE__, pathname, sec, nsec)
|
||||
#define assertFileBirthtimeRecent(pathname) \
|
||||
assertion_file_birthtime_recent(__FILE__, __LINE__, pathname)
|
||||
/* Assert that a file exists; supports printf-style arguments. */
|
||||
#define assertFileExists \
|
||||
test_setup(__FILE__, __LINE__);test_assert_file_exists
|
||||
assertion_setup(__FILE__, __LINE__);assertion_file_exists
|
||||
/* Assert that a file exists; supports printf-style arguments. */
|
||||
#define assertFileNotExists \
|
||||
test_setup(__FILE__, __LINE__);test_assert_file_not_exists
|
||||
assertion_setup(__FILE__, __LINE__);assertion_file_not_exists
|
||||
/* Assert that file contents match a string; supports printf-style arguments. */
|
||||
#define assertFileContents \
|
||||
test_setup(__FILE__, __LINE__);test_assert_file_contents
|
||||
assertion_setup(__FILE__, __LINE__);assertion_file_contents
|
||||
#define assertFileMtime(pathname, sec, nsec) \
|
||||
assertion_file_mtime(__FILE__, __LINE__, pathname, sec, nsec)
|
||||
#define assertFileMtimeRecent(pathname) \
|
||||
assertion_file_mtime_recent(__FILE__, __LINE__, pathname)
|
||||
#define assertFileNLinks(pathname, nlinks) \
|
||||
assertion_file_nlinks(__FILE__, __LINE__, pathname, nlinks)
|
||||
#define assertFileSize(pathname, size) \
|
||||
assertion_file_size(__FILE__, __LINE__, pathname, size)
|
||||
#define assertTextFileContents \
|
||||
assertion_setup(__FILE__, __LINE__);assertion_text_file_contents
|
||||
#define assertIsDir(pathname, mode) \
|
||||
assertion_is_dir(__FILE__, __LINE__, pathname, mode)
|
||||
#define assertIsHardlink(path1, path2) \
|
||||
assertion_is_hardlink(__FILE__, __LINE__, path1, path2)
|
||||
#define assertIsNotHardlink(path1, path2) \
|
||||
assertion_is_not_hardlink(__FILE__, __LINE__, path1, path2)
|
||||
#define assertIsReg(pathname, mode) \
|
||||
assertion_is_reg(__FILE__, __LINE__, pathname, mode)
|
||||
#define assertIsSymlink(pathname, contents) \
|
||||
assertion_is_symlink(__FILE__, __LINE__, pathname, contents)
|
||||
/* Create a directory, report error if it fails. */
|
||||
#define assertMakeDir(dirname, mode) \
|
||||
assertion_make_dir(__FILE__, __LINE__, dirname, mode)
|
||||
#define assertMakeFile(path, mode, contents) \
|
||||
assertion_make_file(__FILE__, __LINE__, path, mode, contents)
|
||||
#define assertMakeHardlink(newfile, oldfile) \
|
||||
assertion_make_hardlink(__FILE__, __LINE__, newfile, oldfile)
|
||||
#define assertMakeSymlink(newfile, linkto) \
|
||||
assertion_make_symlink(__FILE__, __LINE__, newfile, linkto)
|
||||
#define assertUmask(mask) \
|
||||
assertion_umask(__FILE__, __LINE__, mask)
|
||||
|
||||
/*
|
||||
* This would be simple with C99 variadic macros, but I don't want to
|
||||
@ -135,26 +220,60 @@
|
||||
* but effective.
|
||||
*/
|
||||
#define skipping \
|
||||
test_setup(__FILE__, __LINE__);test_skipping
|
||||
assertion_setup(__FILE__, __LINE__);test_skipping
|
||||
|
||||
/* Function declarations. These are defined in test_utility.c. */
|
||||
void failure(const char *fmt, ...);
|
||||
void test_setup(const char *, int);
|
||||
int assertion_assert(const char *, int, int, const char *, void *);
|
||||
int assertion_chdir(const char *, int, const char *);
|
||||
int assertion_empty_file(const char *, ...);
|
||||
int assertion_equal_file(const char *, const char *, ...);
|
||||
int assertion_equal_int(const char *, int, long long, const char *, long long, const char *, void *);
|
||||
int assertion_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
|
||||
int assertion_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
|
||||
int assertion_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
|
||||
int assertion_file_atime(const char *, int, const char *, long, long);
|
||||
int assertion_file_atime_recent(const char *, int, const char *);
|
||||
int assertion_file_birthtime(const char *, int, const char *, long, long);
|
||||
int assertion_file_birthtime_recent(const char *, int, const char *);
|
||||
int assertion_file_contents(const void *, int, const char *, ...);
|
||||
int assertion_file_exists(const char *, ...);
|
||||
int assertion_file_mtime(const char *, int, const char *, long, long);
|
||||
int assertion_file_mtime_recent(const char *, int, const char *);
|
||||
int assertion_file_nlinks(const char *, int, const char *, int);
|
||||
int assertion_file_not_exists(const char *, ...);
|
||||
int assertion_file_size(const char *, int, const char *, long);
|
||||
int assertion_is_dir(const char *, int, const char *, int);
|
||||
int assertion_is_hardlink(const char *, int, const char *, const char *);
|
||||
int assertion_is_not_hardlink(const char *, int, const char *, const char *);
|
||||
int assertion_is_reg(const char *, int, const char *, int);
|
||||
int assertion_is_symlink(const char *, int, const char *, const char *);
|
||||
int assertion_make_dir(const char *, int, const char *, int);
|
||||
int assertion_make_file(const char *, int, const char *, int, const char *);
|
||||
int assertion_make_hardlink(const char *, int, const char *newpath, const char *);
|
||||
int assertion_make_symlink(const char *, int, const char *newpath, const char *);
|
||||
int assertion_non_empty_file(const char *, ...);
|
||||
int assertion_text_file_contents(const char *buff, const char *f);
|
||||
int assertion_umask(const char *, int, int);
|
||||
void assertion_setup(const char *, int);
|
||||
|
||||
void test_skipping(const char *fmt, ...);
|
||||
int test_assert(const char *, int, int, const char *, void *);
|
||||
int test_assert_empty_file(const char *, ...);
|
||||
int test_assert_equal_file(const char *, const char *, ...);
|
||||
int test_assert_equal_int(const char *, int, int, const char *, int, const char *, void *);
|
||||
int test_assert_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
|
||||
int test_assert_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
|
||||
int test_assert_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
|
||||
int test_assert_file_contents(const void *, int, const char *, ...);
|
||||
int test_assert_file_exists(const char *, ...);
|
||||
int test_assert_file_not_exists(const char *, ...);
|
||||
|
||||
/* Like sprintf, then system() */
|
||||
int systemf(const char * fmt, ...);
|
||||
|
||||
/* Delay until time() returns a value after this. */
|
||||
void sleepUntilAfter(time_t);
|
||||
|
||||
/* Return true if this platform can create symlinks. */
|
||||
int canSymlink(void);
|
||||
|
||||
/* Return true if this platform can run the "gzip" program. */
|
||||
int canGzip(void);
|
||||
|
||||
/* Return true if this platform can run the "gunzip" program. */
|
||||
int canGunzip(void);
|
||||
|
||||
/* Suck file into string allocated via malloc(). Call free() when done. */
|
||||
/* Supports printf-style args: slurpfile(NULL, "%s/myfile", refdir); */
|
||||
char *slurpfile(size_t *, const char *fmt, ...);
|
||||
@ -162,9 +281,6 @@ char *slurpfile(size_t *, const char *fmt, ...);
|
||||
/* Extracts named reference file to the current directory. */
|
||||
void extract_reference_file(const char *);
|
||||
|
||||
/* Get external gzip program name */
|
||||
const char *external_gzip_program(int un);
|
||||
|
||||
/*
|
||||
* Special interfaces for libarchive test harness.
|
||||
*/
|
||||
@ -177,20 +293,9 @@ int read_open_memory(struct archive *, void *, size_t, size_t);
|
||||
/* "2" version exercises a slightly different set of libarchive APIs. */
|
||||
int read_open_memory2(struct archive *, void *, size_t, size_t);
|
||||
|
||||
/*
|
||||
* ARCHIVE_VERSION_STAMP first appeared in 1.9 and libarchive 2.2.4.
|
||||
* We can approximate it for earlier versions, though.
|
||||
* This is used to disable tests of features not present in the current
|
||||
* version.
|
||||
*/
|
||||
#ifndef ARCHIVE_VERSION_STAMP
|
||||
#define ARCHIVE_VERSION_STAMP \
|
||||
(ARCHIVE_API_VERSION * 1000000 + ARCHIVE_API_FEATURE * 1000)
|
||||
#endif
|
||||
|
||||
/* Versions of above that accept an archive argument for additional info. */
|
||||
#define assertA(e) test_assert(__FILE__, __LINE__, (e), #e, (a))
|
||||
#define assertA(e) assertion_assert(__FILE__, __LINE__, (e), #e, (a))
|
||||
#define assertEqualIntA(a,v1,v2) \
|
||||
test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
|
||||
assertion_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
|
||||
#define assertEqualStringA(a,v1,v2) \
|
||||
test_assert_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
|
||||
assertion_equal_string(__FILE__, __LINE__, (v1), #v1, (v2), #v2, (a))
|
||||
|
||||
@ -406,7 +406,7 @@ DEFINE_TEST(test_acl_pax)
|
||||
struct archive *a;
|
||||
struct archive_entry *ae;
|
||||
size_t used;
|
||||
int fd;
|
||||
FILE *f;
|
||||
|
||||
/* Write an archive to memory. */
|
||||
assert(NULL != (a = archive_write_new()));
|
||||
@ -453,14 +453,14 @@ DEFINE_TEST(test_acl_pax)
|
||||
#endif
|
||||
|
||||
/* Write out the data we generated to a file for manual inspection. */
|
||||
assert(-1 < (fd = open("testout", O_WRONLY | O_CREAT | O_TRUNC, 0775)));
|
||||
assert(used == (size_t)write(fd, buff, (unsigned int)used));
|
||||
close(fd);
|
||||
assert(NULL != (f = fopen("testout", "wb")));
|
||||
assertEqualInt(used, (size_t)fwrite(buff, 1, (unsigned int)used, f));
|
||||
fclose(f);
|
||||
|
||||
/* Write out the reference data to a file for manual inspection. */
|
||||
assert(-1 < (fd = open("reference", O_WRONLY | O_CREAT | O_TRUNC, 0775)));
|
||||
assert(sizeof(reference) == write(fd, reference, sizeof(reference)));
|
||||
close(fd);
|
||||
assert(NULL != (f = fopen("reference", "wb")));
|
||||
assert(sizeof(reference) == fwrite(reference, 1, sizeof(reference), f));
|
||||
fclose(f);
|
||||
|
||||
/* Assert that the generated data matches the built-in reference data.*/
|
||||
failure("Generated pax archive does not match reference; check 'testout' and 'reference' files.");
|
||||
|
||||
@ -47,7 +47,10 @@ compat_bzip2(const char *name)
|
||||
int i;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
|
||||
if (ARCHIVE_OK != archive_read_support_compression_bzip2(a)) {
|
||||
skipping("Unsupported bzip2");
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
extract_reference_file(name);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));
|
||||
|
||||
106
lib/libarchive/test/test_compat_cpio.c
Normal file
106
lib/libarchive/test/test_compat_cpio.c
Normal file
@ -0,0 +1,106 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2009 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Verify our ability to read various sample files.
|
||||
* It should be easy to add any new sample files sent in by users
|
||||
* to this collection of tests.
|
||||
*/
|
||||
|
||||
/* Copy this function for each test file and adjust it accordingly. */
|
||||
|
||||
/*
|
||||
* test_compat_cpio_1.cpio checks heuristics for avoiding false
|
||||
* hardlinks. foo1 and foo2 are files that have nlinks=1 and so
|
||||
* should not be marked as hardlinks even though they have identical
|
||||
* ino values. bar1 and bar2 have nlinks=2 so should be marked
|
||||
* as hardlinks.
|
||||
*/
|
||||
static void
|
||||
test_compat_cpio_1(void)
|
||||
{
|
||||
char name[] = "test_compat_cpio_1.cpio";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
extract_reference_file(name);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 17));
|
||||
|
||||
/* Read first entry. */
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString("foo1", archive_entry_pathname(ae));
|
||||
assertEqualString(NULL, archive_entry_hardlink(ae));
|
||||
assertEqualInt(1260250228, archive_entry_mtime(ae));
|
||||
assertEqualInt(1000, archive_entry_uid(ae));
|
||||
assertEqualInt(1000, archive_entry_gid(ae));
|
||||
assertEqualInt(0100644, archive_entry_mode(ae));
|
||||
|
||||
/* Read second entry. */
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString("foo2", archive_entry_pathname(ae));
|
||||
assertEqualString(NULL, archive_entry_hardlink(ae));
|
||||
assertEqualInt(1260250228, archive_entry_mtime(ae));
|
||||
assertEqualInt(1000, archive_entry_uid(ae));
|
||||
assertEqualInt(1000, archive_entry_gid(ae));
|
||||
assertEqualInt(0100644, archive_entry_mode(ae));
|
||||
|
||||
/* Read third entry. */
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString("bar1", archive_entry_pathname(ae));
|
||||
assertEqualString(NULL, archive_entry_hardlink(ae));
|
||||
assertEqualInt(1260250228, archive_entry_mtime(ae));
|
||||
assertEqualInt(1000, archive_entry_uid(ae));
|
||||
assertEqualInt(1000, archive_entry_gid(ae));
|
||||
assertEqualInt(0100644, archive_entry_mode(ae));
|
||||
|
||||
/* Read fourth entry. */
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString("bar2", archive_entry_pathname(ae));
|
||||
assertEqualString("bar1", archive_entry_hardlink(ae));
|
||||
assertEqualInt(1260250228, archive_entry_mtime(ae));
|
||||
assertEqualInt(1000, archive_entry_uid(ae));
|
||||
assertEqualInt(1000, archive_entry_gid(ae));
|
||||
assertEqualInt(0100644, archive_entry_mode(ae));
|
||||
|
||||
/* Verify that the format detection worked. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_NONE);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC);
|
||||
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
DEFINE_TEST(test_compat_cpio)
|
||||
{
|
||||
test_compat_cpio_1();
|
||||
}
|
||||
|
||||
|
||||
19
lib/libarchive/test/test_compat_cpio_1.cpio.uu
Normal file
19
lib/libarchive/test/test_compat_cpio_1.cpio.uu
Normal file
@ -0,0 +1,19 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_compat_cpio_1.cpio
|
||||
M,#<P-S`Q,#`U-CEE8F4P,#`P.#%A-#`P,#`P,V4X,#`P,#`S93@P,#`P,#`P
|
||||
M,31B,61E-#<T,#`P,#`P,#0P,#`P,#`P,#`P,#`P,#4T,#`P,#`P,#`P,#`P
|
||||
M,#`P,#`P,#`P,#`U,#`P,#`P,#!F;V\Q``!F;V\*,#<P-S`Q,#`U-CEE8F4P
|
||||
M,#`P.#%A-#`P,#`P,V4X,#`P,#`S93@P,#`P,#`P,31B,61E-#<T,#`P,#`P
|
||||
M,#0P,#`P,#`P,#`P,#`P,#4T,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`U,#`P
|
||||
M,#`P,#!F;V\R``!B87(*,#<P-S`Q,#`U-CEE8F4P,#`P.#%A-#`P,#`P,V4X
|
||||
M,#`P,#`S93@P,#`P,#`P,C1B,61E-#<T,#`P,#`P,#0P,#`P,#`P,#`P,#`P
|
||||
M,#4T,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`U,#`P,#`P,#!B87(Q``!B87H*
|
||||
M,#<P-S`Q,#`U-CEE8F4P,#`P.#%A-#`P,#`P,V4X,#`P,#`S93@P,#`P,#`P
|
||||
M,C1B,61E-#<T,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#4T,#`P,#`P,#`P,#`P
|
||||
M,#`P,#`P,#`P,#`U,#`P,#`P,#!B87(R```P-S`W,#$P,#`P,#`P,#`P,#`P
|
||||
M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`Q,#`P,#`P,#`P,#`P,#`P,#`P
|
||||
M,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,#`P,&(P,#`P,#`P
|
||||
/,%1204E,15(A(2$`````
|
||||
`
|
||||
end
|
||||
155
lib/libarchive/test/test_compat_lzma.c
Normal file
155
lib/libarchive/test/test_compat_lzma.c
Normal file
@ -0,0 +1,155 @@
|
||||
/*-
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* Copyright (c) 2003-2008 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following to rebuild the data for this program:
|
||||
tail -n +33 test_compat_lzma.c | /bin/sh
|
||||
|
||||
# Use lzma command of XZ Utils.
|
||||
name=test_compat_lzma_1
|
||||
zcmd=lzma
|
||||
zsuffix=lzma
|
||||
ztar_suffix=tlz
|
||||
dir="$name`date +%Y%m%d%H%M%S`.$USER"
|
||||
mktarfile()
|
||||
{
|
||||
mkdir $dir
|
||||
echo "f1" > $dir/f1
|
||||
echo "f2" > $dir/f2
|
||||
echo "f3" > $dir/f3
|
||||
mkdir $dir/d1
|
||||
echo "f1" > $dir/d1/f1
|
||||
echo "f2" > $dir/d1/f2
|
||||
echo "f3" > $dir/d1/f3
|
||||
(cd $dir; tar cf ../$name.tar f1 f2 f3 d1/f1 d1/f2 d1/f3)
|
||||
rm -r $dir
|
||||
}
|
||||
mktarfile
|
||||
$zcmd $name.tar
|
||||
mv $name.tar.$zsuffix $name.$ztar_suffix
|
||||
echo "This is unrelated junk data at the end of the file" >> $name.$ztar_suffix
|
||||
uuencode $name.$ztar_suffix $name.$ztar_suffix > $name.$ztar_suffix.uu
|
||||
rm -f $name.$ztar_suffix
|
||||
#
|
||||
# Use option -e
|
||||
#
|
||||
name=test_compat_lzma_2
|
||||
dir="$name`date +%Y%m%d%H%M%S`.$USER"
|
||||
mktarfile
|
||||
$zcmd -e $name.tar
|
||||
mv $name.tar.$zsuffix $name.$ztar_suffix
|
||||
uuencode $name.$ztar_suffix $name.$ztar_suffix > $name.$ztar_suffix.uu
|
||||
rm -f $name.$ztar_suffix
|
||||
#
|
||||
# Use lzma command of LZMA SDK with option -d12.
|
||||
#
|
||||
name=test_compat_lzma_3
|
||||
zcmd=lzmasdk # Change this path to use lzma of LZMA SDK.
|
||||
dir="$name`date +%Y%m%d%H%M%S`.$USER"
|
||||
mktarfile
|
||||
$zcmd e -d12 $name.tar $name.$ztar_suffix
|
||||
rm -f $name.tar
|
||||
uuencode $name.$ztar_suffix $name.$ztar_suffix > $name.$ztar_suffix.uu
|
||||
rm -f $name.$ztar_suffix
|
||||
|
||||
exit 0
|
||||
*/
|
||||
|
||||
/*
|
||||
* Verify our ability to read sample files compatibly with unlzma.
|
||||
*
|
||||
* In particular:
|
||||
* * unlzma will read multiple lzma streams, concatenating the output
|
||||
* * unlzma will read lzma streams which is made by lzma with option -e,
|
||||
* concatenating the output
|
||||
*
|
||||
* Verify our ability to read sample files compatibly with lzma of
|
||||
* LZMA SDK.
|
||||
* * lzma will read lzma streams which is made by lzma with option -d12,
|
||||
* concatenating the output
|
||||
*/
|
||||
|
||||
/*
|
||||
* All of the sample files have the same contents; they're just
|
||||
* compressed in different ways.
|
||||
*/
|
||||
static void
|
||||
compat_lzma(const char *name)
|
||||
{
|
||||
const char *n[7] = { "f1", "f2", "f3", "d1/f1", "d1/f2", "d1/f3", NULL };
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int i, r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(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));
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
extract_reference_file(name);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2));
|
||||
|
||||
/* Read entries, match up names with list above. */
|
||||
for (i = 0; i < 6; ++i) {
|
||||
failure("Could not read file %d (%s) from %s", i, n[i], name);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_next_header(a, &ae));
|
||||
assertEqualString(n[i], archive_entry_pathname(ae));
|
||||
}
|
||||
|
||||
/* Verify the end-of-archive. */
|
||||
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify that the format detection worked. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_LZMA);
|
||||
assertEqualString(archive_compression_name(a), "lzma");
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_TAR_USTAR);
|
||||
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
DEFINE_TEST(test_compat_lzma)
|
||||
{
|
||||
/* This sample has been added junk datas to its tail. */
|
||||
compat_lzma("test_compat_lzma_1.tlz");
|
||||
/* This sample has been made by lzma with option -e,
|
||||
* the first byte of which is 0x5e.
|
||||
* Not supported in libarchive 2.7.* and earlier */
|
||||
compat_lzma("test_compat_lzma_2.tlz");
|
||||
/* This sample has been made by lzma of LZMA SDK with
|
||||
* option -d12, second byte and third byte of which is
|
||||
* not zero.
|
||||
* Not supported in libarchive 2.7.* and earlier */
|
||||
compat_lzma("test_compat_lzma_3.tlz");
|
||||
}
|
||||
10
lib/libarchive/test/test_compat_lzma_1.tlz.uu
Normal file
10
lib/libarchive/test/test_compat_lzma_1.tlz.uu
Normal file
@ -0,0 +1,10 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_compat_lzma_1.tlz
|
||||
M70``@`#__________P`S##P;IXPT!HUK`DO\DC[V2OB%Z^'=ZT59ANYMTD(/
|
||||
M^W;\8!%O7<+P&=#(9W<_!$Z.7/Y<&\(8+E0^,_-\Z"D^P'N0J^4-UH"WMJ<&
|
||||
MV-P6=Y[-FY$IFNZ="RF24TO.B7EP[F]BGMJSP[]OZ_P9/#J'T=;7E&&A@J<[
|
||||
MA^C'Q*/Y&I)2^T930'MJTK-98U0D9R*-X2^5__6H:+A4:&ES(&ES('5N<F5L
|
||||
F871E9"!J=6YK(&1A=&$@870@=&AE(&5N9"!O9B!T:&4@9FEL90H`
|
||||
`
|
||||
end
|
||||
9
lib/libarchive/test/test_compat_lzma_2.tlz.uu
Normal file
9
lib/libarchive/test/test_compat_lzma_2.tlz.uu
Normal file
@ -0,0 +1,9 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_compat_lzma_2.tlz
|
||||
M7@``@`#__________P`S##P;IXPT!HUK`DO\DC[V2OB%Z^'<FN`(!=!,)@8W
|
||||
M9R(6\QIOTA6SGM20X;2'6#3B&HC%2XOX2?D['5WD"`>`W2"/3R1F1:P:&Q9A
|
||||
MGH2JJI9$C?8.=WTE:O<1WA@X>DK-Y#SW;I2!P;NYG^2"-(D9/E(D_0XK_H,\
|
||||
95*/V"T#E9ZO][@'R,6E&^A([.##_\M#YU@``
|
||||
`
|
||||
end
|
||||
9
lib/libarchive/test/test_compat_lzma_3.tlz.uu
Normal file
9
lib/libarchive/test/test_compat_lzma_3.tlz.uu
Normal file
@ -0,0 +1,9 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_compat_lzma_3.tlz
|
||||
M70`0````'``````````S##P;IXPT!HUK`DO\DC[V2OB%Z^'=ZT59ANYMTD(1
|
||||
M$Y^=;\4%U_CXKQ*F$OFZKEQUG)1U8="](V<2K"U1\Z6%H(UNQ[Y3.=D'>_G-
|
||||
MCO71X+M*7WH7$D1&E9Y$XHW,(`[X";GGTO+,'&1?F%<@`.$-OV;8P1?*M$A"
|
||||
:MA+1XONREMK,1('455L=X1>WC#1YW"('I@``
|
||||
`
|
||||
end
|
||||
@ -50,9 +50,9 @@ DEFINE_TEST(test_compat_solaris_tar_acl)
|
||||
|
||||
/* Archive has 1 entry with some ACLs set on it. */
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
failure("Basic ACLs should set mode to 0640, not %04o",
|
||||
failure("Basic ACLs should set mode to 0644, not %04o",
|
||||
archive_entry_mode(ae)&0777);
|
||||
assertEqualInt((archive_entry_mode(ae) & 0777), 0640);
|
||||
assertEqualInt((archive_entry_mode(ae) & 0777), 0644);
|
||||
assertEqualInt(7, archive_entry_acl_reset(ae,
|
||||
ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
|
||||
assertEqualInt(ARCHIVE_OK, archive_entry_acl_next(ae,
|
||||
@ -77,7 +77,7 @@ DEFINE_TEST(test_compat_solaris_tar_acl)
|
||||
ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
|
||||
&type, &permset, &tag, &qual, &name));
|
||||
assertEqualInt(ARCHIVE_ENTRY_ACL_TYPE_ACCESS, type);
|
||||
assertEqualInt(000, permset);
|
||||
assertEqualInt(004, permset);
|
||||
assertEqualInt(ARCHIVE_ENTRY_ACL_OTHER, tag);
|
||||
assertEqualInt(-1, qual);
|
||||
assert(name == NULL);
|
||||
|
||||
@ -51,12 +51,39 @@ DEFINE_TEST(test_entry)
|
||||
const char *xname; /* For xattr tests. */
|
||||
const void *xval; /* For xattr tests. */
|
||||
size_t xsize; /* For xattr tests. */
|
||||
int c;
|
||||
wchar_t wc;
|
||||
long l;
|
||||
|
||||
assert((e = archive_entry_new()) != NULL);
|
||||
|
||||
/*
|
||||
* Verify that the AE_IF* defines match S_IF* defines
|
||||
* on this platform. See comments in archive_entry.h.
|
||||
*/
|
||||
#ifdef S_IFREG
|
||||
assertEqualInt(S_IFREG, AE_IFREG);
|
||||
#endif
|
||||
#ifdef S_IFLNK
|
||||
assertEqualInt(S_IFLNK, AE_IFLNK);
|
||||
#endif
|
||||
#ifdef S_IFSOCK
|
||||
assertEqualInt(S_IFSOCK, AE_IFSOCK);
|
||||
#endif
|
||||
#ifdef S_IFCHR
|
||||
assertEqualInt(S_IFCHR, AE_IFCHR);
|
||||
#endif
|
||||
/* Work around MinGW, which defines S_IFBLK wrong. */
|
||||
/* sourceforge.net/tracker/?func=detail&atid=102435&aid=1942809&group_id=2435 */
|
||||
#if defined(S_IFBLK) && !defined(_WIN32)
|
||||
assertEqualInt(S_IFBLK, AE_IFBLK);
|
||||
#endif
|
||||
#ifdef S_IFDIR
|
||||
assertEqualInt(S_IFDIR, AE_IFDIR);
|
||||
#endif
|
||||
#ifdef S_IFIFO
|
||||
assertEqualInt(S_IFIFO, AE_IFIFO);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Basic set/read tests for all fields.
|
||||
* We should be able to set any field and read
|
||||
@ -414,7 +441,7 @@ DEFINE_TEST(test_entry)
|
||||
skipping("ACL preserved by archive_entry_clone()");
|
||||
#else
|
||||
/* Verify ACL was copied. */
|
||||
assertEqualInt(4, c = archive_entry_acl_reset(e2,
|
||||
assertEqualInt(4, archive_entry_acl_reset(e2,
|
||||
ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
|
||||
/* First three are standard permission bits. */
|
||||
assertEqualInt(0, archive_entry_acl_next(e2,
|
||||
@ -455,7 +482,7 @@ DEFINE_TEST(test_entry)
|
||||
skipping("xattr data preserved by archive_entry_clone");
|
||||
#else
|
||||
/* Verify xattr was copied. */
|
||||
assertEqualInt(1, c = archive_entry_xattr_reset(e2));
|
||||
assertEqualInt(1, archive_entry_xattr_reset(e2));
|
||||
assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize));
|
||||
assertEqualString(xname, "xattr1");
|
||||
assertEqualString(xval, "xattrvalue");
|
||||
@ -539,7 +566,7 @@ DEFINE_TEST(test_entry)
|
||||
skipping("ACL held by clone of archive_entry");
|
||||
#else
|
||||
/* Verify ACL was unchanged. */
|
||||
assertEqualInt(4, c = archive_entry_acl_reset(e2,
|
||||
assertEqualInt(4, archive_entry_acl_reset(e2,
|
||||
ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
|
||||
/* First three are standard permission bits. */
|
||||
assertEqualInt(0, archive_entry_acl_next(e2,
|
||||
@ -807,7 +834,7 @@ DEFINE_TEST(test_entry)
|
||||
/*
|
||||
* Exercise the character-conversion logic, if we can.
|
||||
*/
|
||||
if (NULL == setlocale(LC_ALL, LOCALE_DE)) {
|
||||
if (NULL == LOCALE_UTF8 || NULL == setlocale(LC_ALL, LOCALE_UTF8)) {
|
||||
skipping("Can't exercise charset-conversion logic without"
|
||||
" a suitable locale.");
|
||||
} else {
|
||||
|
||||
@ -31,11 +31,11 @@ DEFINE_TEST(test_entry_strmode)
|
||||
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
|
||||
archive_entry_set_mode(entry, S_IFREG | 0642);
|
||||
archive_entry_set_mode(entry, AE_IFREG | 0642);
|
||||
assertEqualString(archive_entry_strmode(entry), "-rw-r---w- ");
|
||||
|
||||
/* Regular file + hardlink still shows as regular file. */
|
||||
archive_entry_set_mode(entry, S_IFREG | 0644);
|
||||
archive_entry_set_mode(entry, AE_IFREG | 0644);
|
||||
archive_entry_set_hardlink(entry, "link");
|
||||
assertEqualString(archive_entry_strmode(entry), "-rw-r--r-- ");
|
||||
|
||||
@ -44,22 +44,22 @@ DEFINE_TEST(test_entry_strmode)
|
||||
assertEqualString(archive_entry_strmode(entry), "hrw-r----- ");
|
||||
archive_entry_set_hardlink(entry, NULL);
|
||||
|
||||
archive_entry_set_mode(entry, S_IFDIR | 0777);
|
||||
archive_entry_set_mode(entry, AE_IFDIR | 0777);
|
||||
assertEqualString(archive_entry_strmode(entry), "drwxrwxrwx ");
|
||||
|
||||
archive_entry_set_mode(entry, S_IFBLK | 03642);
|
||||
archive_entry_set_mode(entry, AE_IFBLK | 03642);
|
||||
assertEqualString(archive_entry_strmode(entry), "brw-r-S-wT ");
|
||||
|
||||
archive_entry_set_mode(entry, S_IFCHR | 05777);
|
||||
archive_entry_set_mode(entry, AE_IFCHR | 05777);
|
||||
assertEqualString(archive_entry_strmode(entry), "crwsrwxrwt ");
|
||||
|
||||
archive_entry_set_mode(entry, S_IFSOCK | 0222);
|
||||
archive_entry_set_mode(entry, AE_IFSOCK | 0222);
|
||||
assertEqualString(archive_entry_strmode(entry), "s-w--w--w- ");
|
||||
|
||||
archive_entry_set_mode(entry, S_IFIFO | 0444);
|
||||
archive_entry_set_mode(entry, AE_IFIFO | 0444);
|
||||
assertEqualString(archive_entry_strmode(entry), "pr--r--r-- ");
|
||||
|
||||
archive_entry_set_mode(entry, S_IFLNK | 04000);
|
||||
archive_entry_set_mode(entry, AE_IFLNK | 04000);
|
||||
assertEqualString(archive_entry_strmode(entry), "l--S------ ");
|
||||
|
||||
archive_entry_acl_add_entry(entry, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
|
||||
|
||||
@ -85,7 +85,7 @@ DEFINE_TEST(test_extattr_freebsd)
|
||||
|
||||
n = extattr_set_fd(fd, EXTATTR_NAMESPACE_USER, "testattr", "1234", 4);
|
||||
if (n != 4) {
|
||||
skipping("Restoring xattr to an unwritable file (broken in some versions of FreeBSD");
|
||||
skipping("Restoring xattr to an unwritable file seems to be broken on this platform");
|
||||
extattr_privilege_bug = 1;
|
||||
}
|
||||
close(fd);
|
||||
@ -114,17 +114,15 @@ DEFINE_TEST(test_extattr_freebsd)
|
||||
archive_entry_set_size(ae, 0);
|
||||
archive_entry_set_mode(ae, 0);
|
||||
archive_entry_xattr_add_entry(ae, "user.bar", "123456", 6);
|
||||
if (extattr_privilege_bug)
|
||||
/* If the bug is here, write_header will return warning. */
|
||||
assertEqualIntA(a, ARCHIVE_WARN,
|
||||
archive_write_header(a, ae));
|
||||
else
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_write_header(a, ae));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
|
||||
if (extattr_privilege_bug)
|
||||
/* If the bug is here, write_close will return warning. */
|
||||
assertEqualIntA(a, ARCHIVE_WARN, archive_write_close(a));
|
||||
else
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
|
||||
|
||||
/* Verify the data on disk. */
|
||||
|
||||
@ -44,86 +44,87 @@ __FBSDID("$FreeBSD$");
|
||||
* post-failure diagnostics.
|
||||
*/
|
||||
|
||||
/* Because this works for any archive, I can just re-use the archives
|
||||
* developed for other tests. I've not included all of the compressed
|
||||
* archives here, though; I don't want to spend all of my test time
|
||||
* testing zlib and bzlib. */
|
||||
static const char *
|
||||
files[] = {
|
||||
"test_fuzz_1.iso",
|
||||
"test_compat_bzip2_1.tbz",
|
||||
"test_compat_gtar_1.tar",
|
||||
"test_compat_tar_hardlink_1.tar",
|
||||
"test_compat_zip_1.zip",
|
||||
"test_read_format_gtar_sparse_1_17_posix10_modified.tar",
|
||||
"test_read_format_tar_empty_filename.tar",
|
||||
"test_read_format_zip.zip",
|
||||
NULL
|
||||
/* Because this works for any archive, we can just re-use the archives
|
||||
* developed for other tests. */
|
||||
static struct {
|
||||
int uncompress; /* If 1, decompress the file before fuzzing. */
|
||||
const char *name;
|
||||
} files[] = {
|
||||
{0, "test_fuzz_1.iso.Z"}, /* Exercise compress decompressor. */
|
||||
{1, "test_fuzz_1.iso.Z"},
|
||||
{0, "test_compat_bzip2_1.tbz"}, /* Exercise bzip2 decompressor. */
|
||||
{1, "test_compat_bzip2_1.tbz"},
|
||||
{0, "test_compat_gtar_1.tar"},
|
||||
{0, "test_compat_gzip_1.tgz"}, /* Exercise gzip decompressor. */
|
||||
{0, "test_compat_gzip_2.tgz"}, /* Exercise gzip decompressor. */
|
||||
{0, "test_compat_tar_hardlink_1.tar"},
|
||||
{0, "test_compat_xz_1.txz"}, /* Exercise xz decompressor. */
|
||||
{0, "test_compat_zip_1.zip"},
|
||||
{0, "test_read_format_ar.ar"},
|
||||
{0, "test_read_format_cpio_bin_be.cpio"},
|
||||
{0, "test_read_format_gtar_sparse_1_17_posix10_modified.tar"},
|
||||
{0, "test_read_format_mtree.mtree"},
|
||||
{0, "test_read_format_tar_empty_filename.tar"},
|
||||
{0, "test_read_format_zip.zip"},
|
||||
{1, NULL}
|
||||
};
|
||||
|
||||
#define UnsupportedCompress(r, a) \
|
||||
(r != ARCHIVE_OK && \
|
||||
(strcmp(archive_error_string(a), \
|
||||
"Unrecognized archive format") == 0 && \
|
||||
archive_compression(a) == ARCHIVE_COMPRESSION_NONE))
|
||||
|
||||
DEFINE_TEST(test_fuzz)
|
||||
{
|
||||
const char **filep;
|
||||
const void *blk;
|
||||
size_t blk_size;
|
||||
off_t blk_offset;
|
||||
int n;
|
||||
|
||||
for (filep = files; *filep != NULL; ++filep) {
|
||||
for (n = 0; files[n].name != NULL; ++n) {
|
||||
const size_t buffsize = 30000000;
|
||||
const char *filename = files[n].name;
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
char *rawimage, *image;
|
||||
size_t size;
|
||||
int i, r;
|
||||
int i;
|
||||
|
||||
extract_reference_file(*filep);
|
||||
rawimage = slurpfile(&size, *filep);
|
||||
assert(rawimage != NULL);
|
||||
image = malloc(size);
|
||||
assert(image != NULL);
|
||||
srand(time(NULL));
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assert(0 == archive_read_support_compression_all(a));
|
||||
assert(0 == archive_read_support_format_all(a));
|
||||
assert(0 == archive_read_open_memory(a, rawimage, size));
|
||||
r = archive_read_next_header(a, &ae);
|
||||
if (UnsupportedCompress(r, a)) {
|
||||
skipping("Skipping GZIP/BZIP2 compression check: "
|
||||
"This version of libarchive was compiled "
|
||||
"without gzip/bzip2 support");
|
||||
assert(0 == archive_read_close(a));
|
||||
assert(0 == archive_read_finish(a));
|
||||
continue;
|
||||
}
|
||||
assert(0 == r);
|
||||
if (r == ARCHIVE_OK) {
|
||||
char buff[20];
|
||||
|
||||
r = archive_read_data(a, buff, 19);
|
||||
if (r < ARCHIVE_OK && strcmp(archive_error_string(a),
|
||||
"libarchive compiled without deflate support (no libz)") == 0) {
|
||||
skipping("Skipping ZIP compression check: %s",
|
||||
archive_error_string(a));
|
||||
assert(0 == archive_read_close(a));
|
||||
assert(0 == archive_read_finish(a));
|
||||
extract_reference_file(filename);
|
||||
if (files[n].uncompress) {
|
||||
int r;
|
||||
/* Use format_raw to decompress the data. */
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_raw(a));
|
||||
r = archive_read_open_filename(a, filename, 16384);
|
||||
if (r != ARCHIVE_OK) {
|
||||
archive_read_finish(a);
|
||||
skipping("Cannot uncompress %s", filename);
|
||||
continue;
|
||||
}
|
||||
while (0 == archive_read_data_block(a, &blk,
|
||||
&blk_size, &blk_offset))
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_next_header(a, &ae));
|
||||
rawimage = malloc(buffsize);
|
||||
size = archive_read_data(a, rawimage, buffsize);
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_next_header(a, &ae));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_finish(a));
|
||||
assert(size > 0);
|
||||
failure("Internal buffer is not big enough for "
|
||||
"uncompressed test file: %s", filename);
|
||||
if (!assert(size < buffsize))
|
||||
continue;
|
||||
} else {
|
||||
rawimage = slurpfile(&size, filename);
|
||||
if (!assert(rawimage != NULL))
|
||||
continue;
|
||||
|
||||
}
|
||||
assert(0 == archive_read_close(a));
|
||||
assert(0 == archive_read_finish(a));
|
||||
image = malloc(size);
|
||||
assert(image != NULL);
|
||||
srand((unsigned)time(NULL));
|
||||
|
||||
for (i = 0; i < 100; ++i) {
|
||||
int j, fd, numbytes;
|
||||
FILE *f;
|
||||
int j, numbytes;
|
||||
|
||||
/* Fuzz < 1% of the bytes in the archive. */
|
||||
memcpy(image, rawimage, size);
|
||||
@ -133,11 +134,10 @@ DEFINE_TEST(test_fuzz)
|
||||
|
||||
/* Save the messed-up image to a file.
|
||||
* If we crash, that file will be useful. */
|
||||
fd = open("after.test.failure.send.this.file."
|
||||
"to.libarchive.maintainers.with.system.details",
|
||||
O_WRONLY | O_CREAT | O_TRUNC, 0744);
|
||||
write(fd, image, (off_t)size);
|
||||
close(fd);
|
||||
f = fopen("after.test.failure.send.this.file."
|
||||
"to.libarchive.maintainers.with.system.details", "wb");
|
||||
fwrite(image, 1, (size_t)size, f);
|
||||
fclose(f);
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
|
||||
495
lib/libarchive/test/test_fuzz_1.iso.Z.uu
Normal file
495
lib/libarchive/test/test_fuzz_1.iso.Z.uu
Normal file
@ -0,0 +1,495 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_fuzz_1.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GA0%`(,)$`4'QT(0``F'H@``@"(PJ)`"(A"04(6#"0"
|
||||
M`!P4E..+`;'(Q@(6),!``^"$>&)`*`+0X9),-NGDDU!&*>645%9IY9589JGE
|
||||
MEEQ>V<0224SQA!%3@!#F$R#D8(,-,+R`!)D@&)$$$T5,D<445!2AH1!5S$E$
|
||||
M$5*`8`((%Q8QQ!-2/"A@"U*\0(05BDI11!!4(`H""D.D`$(,.>0P`PA%N)#%
|
||||
M$U4X<0010=!Y:::;=GH#"$JX`,6D4HCIQ`NQ3C$$$G,RD82I708K;+`R$(A#
|
||||
M##'(4&P.R<8P`X'@%`O#L<DNV^RS,(!#X+;<=DL@`-)2JRP,S,K@++0'#JON
|
||||
MNNRVZ^Z[\,8K[[STUBOE?_@N)H"`!!H8D!$`R`%`&0,#(`0`4P!`A)(,@]#P
|
||||
MPPX[/(3"`$@!P!,`-`'QQA%O;!"((D91P@M%<)1BB@"L&'`"`R4@!P8):6`C
|
||||
M`.X45#./*0/P8Y!#%HDDDB9V+#3'1`]M=-%('ZUTTDPO[7334#\M==143VUU
|
||||
MU5A?K7767&]]M<9+`)`$PA<C2+;#8R>,L<,Y`&"#VP#``,`7`"!A=L(.`SPV
|
||||
M$P"4G'`69%/1=\8,'UR%V`#PO7#)%CML`L,3+VQQR1-C;/'"$E/<0L5S4VP%
|
||||
MQ9E/#D`074-=^M2G,QTNLN.6>VZVJU=+[K70>FO[MN`:R[JUYF(+3KKV!B_\
|
||||
M\,07;_SQR"</9;[,'_8/OP6:V/STU%=O_?78%_=E$B!,$08=(#CQAAT@*`L"
|
||||
MN3HDF_ZGX2K0QAIIS/&&&7.4[T*!(+101?Z!MJ!$_F\`P1C(X(+X!7"`7R!#
|
||||
M&@26O08Z\($0C*`$LW*@'/WL9^(0R(%(]P$`I$.#HPN""$=(PA*:\(0BS)D'
|
||||
M0"@'.7RA#>,K`QD.-`Z!A(B#`%B'0`800A3Z\(<I/%`(!$*`T0&@B.$@XNBV
|
||||
M5<1M*#$(_2IB-9Y((!D4\1E4A,$,BIB,+-*@B,/(8@V*V(LLVJ"(M\CB#8H8
|
||||
MBRSBH(BKR&(.BEB*+`:AB)_(HA"*F(DL#J&(D\@B$8K8B"P6H8B'R*(1BAB(
|
||||
M+!ZAB'O((A**6(<L)J&(;\BB$HJ8ABPNH8ACR"(3BMB%+#:AB%?(HA.*2**`
|
||||
M%!&*,'A"$</FRB7"``I%+%DM81F%(OX@BU(H8MMV2:`I%'$&6:1"$3='3!A4
|
||||
MH8@GR*(5#D0.@13`B!ULAT`,T$,@>K.$1[I10`Y@Q`-Q0R`L(]V!K"$0!903
|
||||
M`-`0R`+>J0R!,."=Q!!(`][I"X$XX)VX$,@#WBD+@4#@G:P02`3>:0J!2."=
|
||||
MH!#(!-ZI"8',2)T`H(1`*O!.1PBD1AA%A$`N\$Y!"`1F&.6#0#+P3CL(1&88
|
||||
MA8-`-O!.-0@D1Q@E@T`Z\$XO"&2%&,6"0#J(48L%Q&$8Y5M`AHA1@`7D1A@%
|
||||
M@D!&\$X="(0$[Z2!0$KP3A<(Y'$818%`HHG1<@A$K!BE:D!4\,YN"&0%[[R&
|
||||
M0%CPSF@(9',8789`O(K18@CD!>_\A4#DAM%<""0&[YR%0&3PSE8(!)D8/85`
|
||||
MM(K14`BD!N_<A$#>AM%*".0&[WR$0'#PSD0(I&T8'81`K(K1/@AD!^^\@T!X
|
||||
M\,XX"*0'[UR#0'SP3H(%Y)<8I5M`I(I1P`6$=!A-6$`.AE&-!61B&#V"0!:&
|
||||
M4=(%I&08A>V_WHG9@$@7HX`-B-TPF@*!C`VCYA"($MZ)U8"$#:/>$`C?,(H-
|
||||
M@6@,H](0B!/>R0R!8`RCQA`(%-X)#(&0"*.Z$(C%,$H+@20,HZX0B.`PB@J!
|
||||
M'`ZCHA#(YS#*"8&D$J.6$(A0,0H)@0`.HXH0B!;>20B!;.&=?A`(%]Z)!X&4
|
||||
M$J,,!(!/,<H&@=`-HV80"!C>.>2`A.&=*PZ(&-XIN("$$J/[#8A.,6JW@!`,
|
||||
MHP<+2)`Q2MN`G.&=;PL(&MXIMX!T$J-L#8A-,7H.@>@6HUP-2(\Q^@V!M.&=
|
||||
MV1"(&]XY#8%D$J/-$(A,,7H,@=@6H\$0B,`PN@N!S.&=M1`('=[Y"H%4$J.I
|
||||
M$(A+,3H*@<@6HYT02(TQ>@F!Y.&=D1"('MZY"(%$$J.%$(A*,?H'@;@6HZ<.
|
||||
M2(PQ^NB`U!JC=PX((-[YY8`T$J-'#HA),?KB@*@6HX<+2(LQBK&`Q!JC8PN(
|
||||
M(=XYL8`D$J.X#8A(,0K:@)@6HX@-2(HQ"M>`M!JCZ!`((][YN(`4$J/@$(A'
|
||||
M,:H-@8@6H]002(DQZ@R!I!JCR!"()-XI#($$$J.\$(A&,6H+@7@6H[`02(@Q
|
||||
MJ@J!E!JCI!`()M[I"8'T$:,C#TA%,;KP@&@6H_,.2(<QNNV`A!JCPPY(R3&Z
|
||||
MZH#D$:.3#DA$,;KG@%@6HV,.2(8QNN2`=!JC,PY(R#'ZN8#4$:,##DA#,;K>
|
||||
M@$@6HPL+2(4QRMN`9!JCI`U(QS'*V(#$$:-T#4A"K3O!NMO][GC/>WBDAZ,C
|
||||
M^3T@&0P`#@7R0<%_\_`CS-E/3]3"%\9PA@.IH0`&'Q`=#@#QF/\[`(9(`-(5
|
||||
M42!)[#P3!^)$T1?H\P&9HNFM.!`LFGZ+`^FBZ;\XD#":?HP#*:/ISSB0-)I^
|
||||
MC0-IH^G?.)`XFGZ.`ZFCZ>\XD#R:?H\#Z:/I_SB00)I^D`,II.D/.9!$FGZ1
|
||||
M`VFDZ1\YD$B:?I(#J:3I+SF03)I^DP/II.D_.9!0FGZ4`RFEZ4\YD%2:?I4#
|
||||
M02*F)TL#$3:FATL#43*FUTL#\4NF%TP#T3:F9TP#@4RFITP#L3FF]TP#$4VF
|
||||
M-TT#44T%0'D`H$T&@'F(IWDW<@`8)1#GE``M&!#LI``Q"$\`L``U6$\,4(/Y
|
||||
MU``UV$\.4(,!]0`U6%`04(,)%0$UV%`24(,1-0$U6%$44(,:50$UZ%$64(,B
|
||||
M=0$U:%(84(,JE0$UZ%(:4(,RM0$U:%,<4(,ZU0$UZ%,>4(-"]0$UV#@UR#<A
|
||||
M4(,`(P(U*%4C4(-610(UJ%4E4(->90(U*%8G4(-FA0(U2%4J4(-NM0(U*%<L
|
||||
M4(-VU0(UJ%<N4(-^]0(U*%@P4(.&%0,UJ%@R4(..-0,U*%DT4(.650,UJ%DV
|
||||
M4(.>=0,U*%HX4(.FE0,UJ%HZ4(.NM0,U*%L\4(.VU0,UJ%L^4(,$\P,U2#=`
|
||||
M4(,G5H,)(P0UJ#%#4(/2A2J:1SJ3HGFP900UB%E'4(.`A00U6%Y)4(/II00U
|
||||
MB%5+4(/QQ00U6%]-4(/YY00UV%]/4(,!!@4U6&!14(,))@4UV&!34(,11@4U
|
||||
M6&%54(,99@4UV&%74(,AA@4U6&)94(,II@4UV&);4(,QQ@4U6&-=4(,"XP4U
|
||||
MV&-?4(-!!@8U.&1A4(,K)@8U*#AC4(/[108U:#=E4(,'8P8U2%MG4(-O@P8U
|
||||
M*#=I4(-LI08UV&9K4(-<Q08U6&=M4(-YY@8UV&=O4(.!!@<U6&AQ4(.))@<U
|
||||
MV&AS4(.11@<U6&EU4(.99@<UV&EW4(.AA@<U6&IY4(.II@<UV&I[4(.QQ@<U
|
||||
M6&M]4(.GY@<U^&A_4(-W!@@U^&6!4(-')@@U^&*#4(.'0P@UB#&%4(-C8P@U
|
||||
M.#&'4(.XA0@U"%J)4(.(I0@U"%>+4(/QQ@@U^#B-4(/YY@@UV&^/4(,!!PDU
|
||||
M6'"14(,))PDUV'"34(,11PDU6'&54(,99PDUV'&74(,AAPDU6'*94(,CIPDU
|
||||
MN'";4(/SQ@DUN&V=4(/#Y@DUN&J?4(.3!@HUN&>A4(-C)@HUN&2C4(,S1@HU
|
||||
M^#FE4(,#9@HUN%ZG4(,+@PHUR%NI4(.DI0HUR%BK4(-TQ0ITIW<8FJ$:NJ$<
|
||||
MRAL'4C,7!``A`@LH,SK#=@LEBEQ&I*(LNJ(NVJ(P^J(R&J,T.J,V6J,X>J,Z
|
||||
M&@0A$@LF8B1!,&RX8"(\M*-&FJ-(>J1*FJ1,NJ0K&B*R8"*?%Z0`D`LF<DU.
|
||||
MVJ1:FJ5<NJ5>^J0`,`LFPDVC$R*T8"(OPJ,`4`LFPC)E"@"V8"+N]*;O($_'
|
||||
M%2+P8$]W"@#QH$][*@_^M*?S(%![2@\&M:?UH%![:@\.M:?W(%%[B@\6M:?Y
|
||||
ML%%[J@\?M:?[,%)[R@\GM:?]L%)[Z@\OM:?_,%-[ZG<6I*9)`@`\]:8"8"(K
|
||||
M]*8#8"(=]*8$$#1[6@`F,D1O:@`F(DYJ>@`FHE9JB@`FTEYJF@`F$F=JJ@`F
|
||||
M4F]JN@`F$DUOR@`F(E9OV@`F4EYOZ@`FDF9J^@`FTFYJ"@$F$G=J&@$FPDQJ
|
||||
M*@$FXE5O.@$F$EYJ2@$F4F9J6@$FDFYJ:@$FTG9J>@$F@DQOB@$FHE5OF@$F
|
||||
MTEUJJ@$F$F9JN@$F4FYJR@$FDG9JV@$F,DQJZ@$F8E5O^@$FHEUJ"@(FTF5J
|
||||
M&@(F$FYJ*@(F4G9J.@(F\DMO2@(F(E5O6@(F8EUJ:@(FDF5J>@(FTFUJB@(F
|
||||
M$G9JF@(FHDMJJ@(FXE1JN@(F(EUOR@(F4F5JV@(FDFUJZ@(FTG5J^@(F0DMJ
|
||||
M"@,FHE1JZB^$\Z8R8")1IJ8S8"+5IJ8T8")9IZ8U8"*MI*8V8")&I:8W8"+*
|
||||
MI:8X8")-IJ8Y8"+1IJ8Z8")5IZ8[8"*I]*8\8")"]:8]8"+&I:8^8"))IJ8_
|
||||
M8"+-IJ9`8")1IZ9!8"*E]*9"8"(^]:9#8"+"I:9$8")%IJ9%8"+)IJ9&8")-
|
||||
MIZ9'8"*A]*9(8"(Z]:9)8"*^I:9*8")!]J9+8"+%IJ9,8"))IZ9-8"*=]*9.
|
||||
M8"(V]:9/8"*Z]:908"(]]J918"+!IJ928")%IZ938"*9]*948"(R]:958"*V
|
||||
M]:8@&#![>@4FTFMJB@4F$G1JF@4F4DEOJ@4FXE)ON@4F(EMOR@4F4F-OV@4F
|
||||
MDFMJZ@4FTG-J^@4F$DEO"@8FHE)O&@8FXEIO*@8F$F-O.@8F4FMO"GD`D'-J
|
||||
M6@8FTDAO:@8F8E)O>@8FHEIOB@8FTF)OF@8F$FMOJ@8F4G-JN@8FDDAOR@8F
|
||||
M(E)OV@8F8EIOZ@8FDF)O^@8FTFIO"@<F$G-J&@<F4DAO*@<FXE%O.@<F(EIO
|
||||
M2@<F4F)O6@<FDFIO:@<FTG)J>@<F$DAOB@<FHE%OF@<FXEEOJ@<F$F)ON@<F
|
||||
M4FIOR@<FDG)JV@<FTD=OZ@<F4E%O^@<FHEEO"@@FTF%O&@@F$FIO*@@F4G)O
|
||||
M.@@FDD=O2@@F$E%O6@@F8EEO:@@FDF%O>@@FTFEOB@@F$G)OF@@F4D=OJ@@F
|
||||
MTE!ON@@F(EEOR@@F4F%OV@@FDFEOZ@@FTG%O^@@F$D=O"@DFDE!O&@DFXEAO
|
||||
M*@DF$F%O.@DF4FEO2@DFDG%O6@DFTD9O:@DF4E!O>@DFHEAOB@DFTF!OF@DF
|
||||
M$FEOJ@DF4G%ON@DFDD9OR@DF$E!OV@DF8EAOZ@DFDF!O^@DFTFAO"@HF$G%O
|
||||
M&@HF4D9O*@HFTD]O.@HF(EAO2@HF4F!O6@HFDFAO:@HFTG!O>@HF$D9OB@HF
|
||||
MDD]OF@HFXE=OJ@HF$F!ON@HF4FAOR@HFDG!OV@HFTD5OZ@HF4D]O^@HFHE=&
|
||||
MU*%F?=9HG=;LP7<U\Z,:E'$;E',GDD8;U*5V_:5X?==W;20GTD8W)-<!$%`\
|
||||
ME->$K=>%?=@WRM<!4%"O!-B&=4V('=F&/=F'K=B*Q4UJBB0-QB*9?2*1EDZ*
|
||||
M77'NU-D`4*?S1-IY>D^DW:?[1-J`^D^D/:@#1=J&>E"DG:@+1=J,^E"D_:@3
|
||||
M1=J2>E%\#0"5RE&DC:D@-=R;2E*D[:DH-=RARE*D3:HP-=RG2E.=;2(XI=@'
|
||||
MPE/9'2)`I=@\1%2*741(I=C7Q%2*S4U0I=CD1%79S2)8E=TLPU79[4Y@I=CS
|
||||
M1%:*?4]HI=C[5%[9_4]LE=T#!5?9?5!TE=T+A5>*_5!\I=@3!5C9/2.$I=@<
|
||||
MA5C972.,E=TD!5F*#3.4I=@LA5G9+3.<I=@T!5K9G2.DE=T\A5J*O4*LI=@=
|
||||
M!%O9[3"TE=U#A%O9?2.\E=U4!5R*C57$I=CV_:9(\CC,I=C1!%V*+5;4I=CE
|
||||
MA5V*S58`D]UP]5V*35?CI=B;<UZ*[57KE=V`]5Z*+3?SI=B(=5^*S5C[E=W(
|
||||
M]%^*K54#EMV8=6"*_38+IMB@]6"*35H3IMAM<V&*;54;IMBP]6&*35LCIMBX
|
||||
M=6**S5LKEMV_]&+9+54SEMVD<V.*?3`[IM@3\V.*O3!#EMTE<V39#3!+EMW2
|
||||
M]62*;3=3IMAC<V6*O5Y;IMAA\V79S3=CEMT:<V:*O5]KIM@8\V:*/6!SIM@D
|
||||
M<F?9;3%[EMT)\V>*+3B#IMB'<VB*_3F+IMBI]&C9+523EMV`<VF*O6*;IM@O
|
||||
M]FF*/6.CIMBE=&K9[5.KEMUT\VJ*/62SIMA'=FN*O62[IMBA]&N*K5/#EMT$
|
||||
M<VR*'63+IMA?]FR*/6;3IMB==&V*;5/;EMVZ]6V*W6/CIMAW=FZ*O6?KIMB9
|
||||
M]&Z*+5/SEMVV=6^*+3#[IMB/]F^*/6D#I]B5='"*[5(+E]VR]7"*76,3I]BG
|
||||
M=G&*O6H;I]B1]'&*K5(CE]VN=7**'6,KI]BU]G**/6PSI]B-='.*;5([I]BJ
|
||||
M]7.*W6)#I]BQ=G2*O6U+I]B)]'2*+5)3I]BF=76*G6);I]BM]G6*/6]CI]B%
|
||||
M=':*[5%KI]BB]7:*76)SI]BIYEC9O7`1EMV!5&G9K5$9E]V>U4;9'6(%E=VE
|
||||
MIEC9/7(-EMU]%&G975$5E]V:E4;9W6$!E=VA9EC977()EMUYU&C9'5$1E]V6
|
||||
M54;9G6']E-V=)EC9'7(%EMUUE&C9W5`-E]V2%4;976'YE-V9YE?9W7$!EMUQ
|
||||
M5&C9G5`)E]V.U479'6'UE-V5IE<7JM;JO_[LW_[0(5(6-!`[,A`^`B1"0B1&
|
||||
M<C((`P7$Z@MU*@52@%<%`BB`!7!6.[A00:`=8*F!4`#009$*"`,@WA@$*F`$
|
||||
M()8#V!GW#QQ@P)ZQ`8G$$"@"&$L7\)T``-(*@C8A".T@R,2_FZ)X>H3.L'\]
|
||||
M(_\!C0````4@`32`"%`!%H0&^``!0`0\"!30`G9`#0@#B<00U!D`((,0A`R"
|
||||
M,^H?S\!_%P1%!($:&``2@1-H`L!J=-S``'``!T("[($0T`$.A!\X`2M@`+B`
|
||||
M19`(/D$UF`$!@*3Z(`3A@S3!%[@&9>")H$,HZ)M002O8!`2:X<F#@#`0"L)!
|
||||
M2`@%X0?$6*]J("1"@H#/!@(L6#6S:B"L$)CQJ8:@'0P`"*#QP!`[($,J1@"L
|
||||
M@E>06P4,%[()9<@6S$I>L`VHE8$P`L3@#D$'KC`,!L$S.`1K81IT?[@P%^K"
|
||||
MQG`%W5@W*83`,!@*PQ&R!;N@0/B"!2$"]D`R6!!F(1I<@[9P#>[":4@-JZ$U
|
||||
MO(8X(<A$PL5#"0,"S+"$4?!`4,$!6``#`"H\AJJP(+3"90@+V:$SC(89\`BJ
|
||||
M0!W1`G,&./0[*((&?D)RB`.]H`XD"#QP#$K`9F@&GV$\3(-'4*;XJH$P1.;@
|
||||
M/3P94_`3)H,KF`6#0#',@6#0!\9"C0@$"R(\Y(!I4%+D*@`P:9((04@B#C$-
|
||||
M7D+3(S>HX$3$@AOD(OK#X180!,!&9(8$X1TBQ)VX!D7B@9@T3H0@.)&46`>C
|
||||
MH.E!+"Z1(L;$<F@,CTL[R(C*4"!V1"'($P]B3SPD/Q$`3!&",$6(8@9<B;"$
|
||||
ML21%F*@%F2)&3(8W<2#F1(]8%4'B51R)DP:+$`0LXA5CH%&$)<AD+%9$F7@,
|
||||
MGR):9(=3D1:V12,8$K$B200`7"WVU$,G^!7O(H'0*GIQ*?;#O@@5TV)@-(AN
|
||||
MT2IF0)]X&(E:[5F,=+`QXL/;XPEYU4O<BV;1'U9&P%@&J2(T'(S@@#-.&I:6
|
||||
M>T#C0T02NZ<T!H#3*!FYX%DD"%'Q%5[&CT@8WV)6I&B]QS:J1,<(`T!+9"R+
|
||||
MD]$IKD:IV!H%XVN\CIO1,$X:?A9\E&-1'(VPA+0\1XN8&BGC7Z2.!-$U:L;,
|
||||
MV#-D(P`@9\7'.XK&%'%\="-OA(Z^436>1^%8'3%C<5R/1,(],K/D(Q_M(G@D
|
||||
M$*1C//)%Z;@?P^!PA(U#T#W2LN93(*'@@80!!T-!ED<&"1PM8W\DCFRP/6I'
|
||||
M`,#)HD^%]!D7<F)HR.@X.OQBAV2-Z=$Z`L@0&2!')"&K/B<2+!((R2$1E2)^
|
||||
M;(HM<CKRQQCI'VFDD>2,:V'2L+'LDR.9(^/HD621/+)(9/@BT>-:5(_L\3^*
|
||||
M2+@(`*A8]VF2%Q)@K,C\:!ZKY)"\DC(R2Q[)$<G#P@^8I(^P1+J,22!))04B
|
||||
MC$2311)$ND<25G[>)&Z$)79C3OY&.VDE!X).Q(YJTCTRL/3C)T_$^K&//E)*
|
||||
MDDD.22C/I*%DBXA22]9(+EF_VD^C#`#O!U)&R049)!LD1_R0$+(P<LGN%7\^
|
||||
MY?P1E:AQ2KK(2ND@466F7)-<LGC5'U<)2_B&H-2/9K)6$DD0&2%'9.O*/[R2
|
||||
M0&B,7UDF:>6I'):ITC@>QLK5?Y(E#-@OS))2OL([>2FQI*;$E5FQE00@:VDY
|
||||
MH&2LG)2E,E@^2SQ)+%5E5J0E!<A:#IALF2Z=)4[LEFGR6Q9++JE+$I"U)!'T
|
||||
MLDYNRT(I83#EC-R76=%F-2!K:3$"YJP<F):R8'I+(XDP#^,PB4#6,F$X3"$I
|
||||
M+-EEM,R.7-)@52!K*3@VIJF\EQ(S7U),=WD8F4D&LI:'PV2J2Y09$`[EP629
|
||||
M2V'26*L.9"T_A\RTEVH17^9)V(@DL:'1/)I(,VDJS:<09!:B0&B(]"\T&DC]
|
||||
M-PY)I<`,@]PR90[-6PG`MF%`F(0#X1LN1WR((JA@*+":[6`53A4/"2UOY1"$
|
||||
M`DP`6P5-`!!O>HPXF1EUT4)"Q#T8*=$FQUR70K-=2L.E23@+I^$\G)DAR-Q-
|
||||
M@7`C\B:*I)K[T&^>S+E9,PVFFI2'FZ<@0$T8(37UY@RLFANR7D+,CADX/V;/
|
||||
M0()J,R!0%<=Y"04/WQR5H?-J:L2L63DG)HA$G+@S=^K.W=D8@DSJ!`"K,VK>
|
||||
MQA,A#B-G['R86)-@UDZ5>3L59T%HG,)S;)X,?6@#C^??I)D`P&9>SEO88]K+
|
||||
M0,`JK#,<1D1>Q0?/)9U$GK-3>69/RZDO;R'O?)_P,W[*S[D09+SG5?F4Q;-Z
|
||||
MRLKK23G7I^V$C0#`=ZI#_$D]`P`_1)>R,SB23JTI.-M@CXDS`X&KA$^R.3Y!
|
||||
M(>S<GY/S0;I-]SD_.Z@'_:`@-"L$&0BZ5?"G;CR@YY-_:M";*0WK9T$`G]'S
|
||||
M.TY/T(E!9V;_U)[M4QKVF'HS$!['!-V;G[!\]L84FD%M)0MM@R$TB2K1)<I$
|
||||
M@T*0X:%?Q8324`2*/A4HX&2@II-(!%``0$(#@@2-H?/Q<QK/&@HT5^CVE(8U
|
||||
M9A>,0))6$(Z@^*2"F:!O6L\BVC:/:,\8`G$S`.S,L=)$^Z@?_:.`M",$F3T:
|
||||
M$*+)#P4:)U1RVE`SFD/;H,#PF@``;%9"Z2E&>=79/)Z_<QVJ3QRZ,M<@W,16
|
||||
M4#0@/(X>HZT&@E@YI,2S@@K1'SDH1^<579Y;<T8&TEE*2VNI+24(0::4GA4I
|
||||
M.D:IJ`HUHF>T#0[2@F!(P>C4K*0&5)&646#:2$]GC_%6`Z&\H%(I^#K-9RM-
|
||||
MGA$3EC;0TWE+NZDW_::!-,A`4X$@38VIYR2>B72.+E)FVDF%*0#0I0'AE)K3
|
||||
MQXE,4>@U39_9U'\R3P#:8]+,0&`KT]1U!E$Y2D9=*?;DI+<3G"K4A<I0Y6>0
|
||||
M\:<"`:#.T]:93@LJ-EV@VC2+YAMQ6A#**><<GOEPBA+1=5I'@ZDS!0#M9B#`
|
||||
ME8"J2@FJ+Z6C'G.##LZ&2E-KJDU%FD$FI;X57JH_7RI)C:EV5(L^U((@43\J
|
||||
M)26>!=2>`LME6E*;J1;M,7%G(-`5EEI-A^@]M:('E7VV4VYZ4[NJ5_VJZR_(
|
||||
M1-6YPE.3J3IEJD#5I`I5E%H05NI$#8=)59D:U!NJ56]G&EVC!\&-4E`XZE)'
|
||||
M*EHMG3(U`^)1;.4R[PI8/:R(-;%FCR!36`/"Y@BH%=6G_E4L&EA/YR,M")+4
|
||||
M&W9.>HI4S2;:S*1L,ZTZ57#P20/`6`T(=*7'R*N!X%6HZD"]H))UKC+2K:I%
|
||||
M%:MMO:VX-3\$F=6Z5\JJ4FV6LI6=-D\`T%B)*P$5J5<UM`+6H)IO>DQX&0B`
|
||||
MQ;62S[Z:7&FG/HVE:C*W:M?MREWM0Y!YKG_%M\K5B_I*K^LV7:N\-2"TUK=*
|
||||
M-N/J60VN396V-M>X41#DAG2UH-9TJ<)7T2I?NZM__:\`UCP$F3(S$.PK>X6<
|
||||
M/=6O[M?EJE8W*@``KP$ANA[8>CI>\2E&-:\:%0FFFX&`6.[K*I64"I:\9M7_
|
||||
MR34#K(D]L2BV.@29#7M8Q.M[%;%TE<3*T@%;7X]K+PVQ%K:\(E1^"BX*`F/Q
|
||||
ML-15O\+8V9I04ZR1/;)(EC@$F;8S$'[LA$6GR%7(YM@1NT^YYHHM"!WVR8;4
|
||||
M&UM=-VE=!:!W=2`$`#9*$/0J$.55<12VXEBL&F.K[(P<K`%`9#Z6)$MGZZR=
|
||||
M50U!1LX&!&0"6:,L<!VRPA6`7E:"D%D!@-B4H<CTDLI*T&I==^RM+*U,=K$@
|
||||
M084U$+0*D%6S73:?.EI9>F<[K:?]M(D3`%#:R>)B+>J4;;/8]5MN43T+`/BL
|
||||
MEBV;7%;*LEDBRV.[RT#`+)<VO_[94TMK2RRH_;7`-MA2AB!C:R]+J8VM@#:^
|
||||
M#M=1&Q`L[:MUKZ9VU@9:KMECPLQ`>!NYUJK*6N5*69FKL/VVX#;<&H8@8VTW
|
||||
MR[%=L]PVHU;6M5IL`P*N?;9^5ELF6_YZ.WM,N1D(H"7;LM)MVVB_K*\5MP`W
|
||||
MX`I<^@D`[NUG.;>9]L)NVNQ*;@L"MH6WL7;72EMERV/3SD`@+?H6Q"9<'>MO
|
||||
M.>W`_;@@-^22A2!C<4<+PN6W7E;&,MR"6Q#R+<1-L!N7RJ9:(PD`PJP&(;,#
|
||||
MP<P"C0J:9G6MO.6UT_;-YM&+>5I$KM$]NDA7*009HAL0VD:?C;@_=^+26T$;
|
||||
M23&KH0V;F[5U%E!%2T49;<IULVJRM);<@$!:>HS(&@A6)>-66*G+8$=KTGV[
|
||||
M<#?NZH0@<W97R\F5N.D6PZY;!\MT`8#3?;EF-=KFW86K:GN,=AD(L$7MOEB@
|
||||
M2W'_K=Q]O)`W\LJ$('-X7\O=C;J#M^.NW+H;$-(NX/VMF+??JMS""P"ZS$"@
|
||||
M+8I7\(I>L*MJ):_K?;VPMR0$&=,[6RZOZ)RW;;>_4MZ"D'@_[]K-O*.7YO:8
|
||||
M<#,0<$OJ1;:,=^HZWMC+?)NO\XT(08;XWA;;FT"!+^NEN;.W(*!>W[MXV6ZW
|
||||
M;;!(L.P,!-YR?-'MZIVY>O7YJM_URWX'0I`1O[N%^E91ZXM^;V'T+0C&E_NJ
|
||||
MWJ];?]$H`%"C8A;G"@2=FTKY*J9%N9I6\WY+.*LP!4(#;K\0.`(?W2#S@`'`
|
||||
M+WFZ,!<!*UP%3','K22\NI,4T7;63\AUSZ?73<#!]VWF4?@;$'A+C]%9`T&J
|
||||
ME-^8BVK/:[Z1P#@X!P_<(`.#!8(,?K61U?SR7QN\12OP!=:_R-?[JEMO.V<*
|
||||
M`NF8P1J8XZ9@#JJ#J[`5_KA;Q@G+WU_:>&<L`.C!P\7&9F"\>WZ)<(_),@/A
|
||||
M8$!A,CR$,^P5?L-P&-P&&30L$-0P$(ZWMS?YYM[AFOZ,2$"%MDF8_IIA`-!M
|
||||
M!L+$6,.AMPWOW3C,B!NQIPTRA5@@'.([#'7SL!+6N]YV#A<$.VQ41?"6'<.)
|
||||
M&`5?WR/88\+.0%@8B-@2"V(W[(A;L2M&L4'&%$^7+0Q3]S``A<0%81)WXC`Z
|
||||
M@D&Q*B[#&=;F(@D!+&<XZ)D-`#U7V[)A4=Q_!6L>[9<"`1J_XFE,C6]JD)'&
|
||||
M@P,#!]Y`#(P7L0?FAE@7I,):2_I9U>$JWKNE518'A(718YS*0``8J;CZ=F-O
|
||||
M6XWKL3U>J$'&'0L$>$R)?;$\5L29>'`0A)+QA_'P/V;&@]AJ#03I$H_G[SP&
|
||||
MO_<X(DMDFAID%+)`8,C]>!L+882<8?-Q0>#'N_B8]F*-3(-[K2SM,55F(-B-
|
||||
MALR%E:_'G<@P.2;7TB"3D@7"2L[(H/<7`V3P6Y$+`D8.R>?T$Y/D*"QS!W&V
|
||||
M&0AC@R77XN_K=F6R4W[*?33('&7S0HM_JBVVLG6C(-QDH,Q9A7)./L@;>`KK
|
||||
M4`#0=0;">E'*5IDI]U>HS);;L@<-,F59O53ER;J$>3+B(`A)&0EOY+`\BF^A
|
||||
M,#X1Q'BS@I`"_`F3\;Y=QGRY&=_1/`HO!4)C=LN0.3)?PR#SF`%`V-#&7]DA
|
||||
M[V2W^XV_)@C6K.)XZY9C@J!).3(ZSJ-Q.2"LEQZC5`8"WT#+=!D30V3)3)MK
|
||||
M<RX,,JU9OLSE!:N6AVMEOLQZN20'W>S:8YS+0-`8L)DWU^6F;)N;LW.>AD'&
|
||||
M.-N7W8Q[>_,M3AP%X34'9Z)<@S-LCXDR`V&_).?JO)S7\G,^S^A9_049\*Q?
|
||||
MJ+,>MLY863H'!.2\G1&S%.[+8[G:#`2,,9[?<WDNLNDY0`OH#!5D]+-_<<^7
|
||||
MF/!B7P#`G@.">*[/H3@Q#^*L,Q`&3'].T!PX_0[H#<VA(TB0H=`"!D&?XX!L
|
||||
MH`,"?X;0.MDT>]N_/&;SJC'>N0;8YZ9H":U1X:RX-#`=.D?K:/\09&YT0"`1
|
||||
MF/GW/F3.7'4)[6>^NJ'9LV)2<SRDY6MI!=$!0=EQ#H)@,2[TB)[-.SI+:VGY
|
||||
M$&2,RD"HTCA92&]FW0L`?'29%L-#V3X79>],-@A"PK#231I`;^DY3:?I0Y!1
|
||||
M+@/A38?I[GNEW6Z7+@A@FBMK78.LF54T^.TQ3<90XL^6>H#5='=>Q'4Z4DMJ
|
||||
M]Q!D$K6$$=%Q^CKC:0>#IC-S2[[*)QD`1)N!<#C@])B6TY,Z5:OJ\!!D1K6%
|
||||
MP=2G^CI;ZIK9J<6TH7:[/:;J#(3/8:IOM7E>U<`Z6&N'(*.K-0RL]M7#U54'
|
||||
MA%*-HL'R?5;,6I1%!V8"3$T+<Y!UU"993<)9:NEAA+6W_M;((<APZX"02H(T
|
||||
MG\[47+,S5]UNB*2/JE`NP3GP!-/HTXRMBG5`^!P])G,-!*'2J^<U/0;7`#M@
|
||||
M]X8@HZ]%S+'VUW9Y7`.`<MVL"S7"QM4`P+@,!,#1KY\U$1;8&#MC!X<@([%-
|
||||
MS,&VV!T9`!3L@,"O&_:GAL^A.LD,A!53L=<TI-;8,#MFWX8@H[)5S,=VV0&Y
|
||||
M8P<$BFVRE_)_YK'-9B"\F);]J/^US#[:2+LU!)F@[6)N=M&VRS4[(+#LGIV6
|
||||
M?S:U!0!19R#,&**=K5MOTO[:8+LT!)FL+6.<=M=>T$P[(`QMJAV;%?01E-8N
|
||||
M>J8>8\.L<;GSV1Z"</98VIBPS;?[MF0(,GH[()02<[U_D375A:2%]M#RXG<]
|
||||
MFEEAGW;2>91L!X09TV-BUT#P*5Q[.'MMO\VY._>XU3$%`7/OZ<+]L,ETX`8`
|
||||
M@YMM*V?9#+&%RT"@&YF["V=7STV[:_=B"#*NV\>8;<V]H"VW0!#=@AJN$NJ3
|
||||
M;;5#=9$9"$,F=KODV6V[F[?S#@PQJ2`D[]'-C6,U5L[=`0%VJV[RS+K[:X])
|
||||
M-@/AR"AO4,V\G[?Y/M]W(<B`;X$@OJGW7@;9BSAZ$X3I';S;Z_#VV=V[W@*`
|
||||
MIC,0ELSX1MGE&WT+\`'>%H(,_Q8(_MM]"V?9K6K5=T%HW_5[AE9B9XVSP2_<
|
||||
M-@C46J"BV6L=H>$W<X6SNE(@A'`"3L)+.%8(,B,<`(02PEV]#7>Z+M(?F%TK
|
||||
M;I',N)<T:7[<(+*T'G`E@P23UT#0*?^[>`=P$T[$B[A3"#(^7"``<05NMWDW
|
||||
MYDSA*WQ[^^?\S6-]RT`@&$&<BB]?(\[%NSA4"#)67"!@<2:.K9VX_04`25S*
|
||||
MU.IS;;U#=?1ROXNZJA[F#E[!F;,7O^-X7.EN45RZNQGX@@[C5F:-DVX/?J@!
|
||||
M0+$9"%\FB[MM*IS'&[DC!PI!YI`+A$1.QNGXT_;3>QR.%^0)[K`).<1..@-A
|
||||
MS"CR#,W('[DI/^4V(<B`<H$@RBOYC/;D9%J2>QE!WL)+MUW]OW@5@[]HPKS!
|
||||
M&[4EO]MI$,ZR2H$PS%&Y,3_F(B'(%',`T$E8^/NNX_U572?NK"N\27#C7IOH
|
||||
M>D:6UE4N9I!@^!H(-F64BV4DBLS+N3G?"$'FFPN$<.[**?@E)]/+O)E+<0P]
|
||||
MSD]J^1H(ND6<XV=R?L[[N3\7I`#@GKN9/KZ\&S@`4.=JAI8_\W>NO]-7SHWC
|
||||
MKU5&NW-@/E/_N46_Z!0AR#CT`4S0R;=!%^@!(9_/<QS.8X/-0+@S^AQ:WV",
|
||||
MSM);.D,(,B;=SG1T`&[0-[J<4>@+O*`+7P!0=`;"GDGI%]NE"_6A#L=[NIZ9
|
||||
MZ4+<H,?T@(#21WHVSZX7O(WN\FK=RR5Z)X?F(!+.=DH_0]2[NCD/,EL](&02
|
||||
M9Y[3/7H'AN'@.`0O[G$<`."U/Y37L#R'YU&C'A#V3(_)7P-!I@!U5NS5^[HI
|
||||
M#S)X7=`@=2WNA<,Z`!CK3KV-$V<`T+\&@FW9ZR_;KTOV<QYD&KNA&>R+O(4"
|
||||
M@,`>$/1Z8G?AH3K'*!J(/EU]^2O'Z@!TLJOV<AYD1'M`$!ADO8G[<<QIV0/"
|
||||
M8__LMIS']IJ!\&@@N]%>[<#]D0>9W>YH,#LIU^RN'8!M<G]\U1DZCPTZ`V'2
|
||||
M^'8L'=RK.QX/,M!=TACW>KY6B7M`Z.VX/:Z#65P>@.,V.9_;'/RT._=;"6<7
|
||||
MI:6Q[O!]@`<9]QX0*DEL+^.S_19*\R,]PX,R6W?K?1&NH_9'FT>S>T"8-#T&
|
||||
M@@T$ES+=[7A\?_"V.\@H>$VSW??YZ9SO!<&^A_<!'ZHIV$"0+0W^5T/X$2_?
|
||||
M`8"']S057J5OT0D?$!C\AE_OH1J##80:$^)1-8F_\<X[R,AX49/BB7"0.?$!
|
||||
M`<2_>(KN0`%`KAD(IZ;&IW8<S^1SO)$O"$F^G3=W(G_A:VY!H/%#WHR/Y9XS
|
||||
M$%:-DM_B33[,]^T@P^5538\/V4?>U.!TV:[3WS9YO[GFG:NB=],^T;6\,\96
|
||||
M?-+5B/D]'[.#3)X/")'DOO]R.V]9T;IGEN'4W'Y;<QONN)_ZMRRM93X@K)H>
|
||||
M@\(&@DKY\B^9SVMZ<!UD*KVL.?/Q&P#\>5&_YO%[F^>>`("%#037@NF'^*9_
|
||||
M]1H[R*AZ6P/J`[*G#PB7/LOG][$,PP9"C&GUFQO6"WN,'61ZO4#X]5*>>!/V
|
||||
ME3OK`P*KU_6G?BS3L(%0:X`]S1WVV%Y@!YEI+Q"J?;+'WYG=G1I[75/J!_VN
|
||||
M+_)R32`,&VNOH;.]NP?602;="YM:;Y>YO:\I]^J=RD?K-S^,XWQMW:O6FLY/
|
||||
M>4+O`?-HFQ0(!__=*_P<'602/@!H)((^WQ/\?+/?$7V27O2+EDDK]D>?1^7]
|
||||
M#4."0&P@F!1V7\H7OLD/T`RO((S\;U^UE[U!=_@0']J;=5(,`(C80%`M)+^B
|
||||
MG_R=KZ6#C,T7"#B?Y;?MX^Y.0[Y`6/D1G,*R<="^V)'80&@Q.9^?\_RIS_`!
|
||||
M@-,7"%!?Z*_N<%_E?[ZSP?=U_MR?5"8V$&)-U.>J5#_M;^@@0_8%@MG7^MR;
|
||||
MZZ_5JR]MP/[`%_M/%0#4G(&P;<[^OU?[@#\]!YF]+Q#Z/MR?XG+?P;9]:V/W
|
||||
ME7WBM_(`&,[K<KD-HP.^57?\1'\Q8RLO*1`X?^#__$XYR'C^+DGOB33BYN^)
|
||||
M7H*38T:/S3>^D2RMA%_;($$L-A!$BM]?Z:`_]\/D($/[!8+M/_STW,*OU=&?
|
||||
M2)9[FC;WT;[(<[&!8%INO^Y__I(YR"Q_@=#\@3])Q\J]7]PT?G"?^?,^&!L(
|
||||
M*<;Y0__QSY:#S/<7".'?^COZ!3W]S<WV;_F/O\>0L8'0:L0_^;__,3G(S'^!
|
||||
M4/_5O^O'G.>?NO'^#7W<W7P5<PP$\X;]A_\M@/=8D'$`RANE'YFV_[D;`^#6
|
||||
MU_WE&U%=F375:7#(6'H7]B5_FE\`L"0)!",@`V@"5F%!1@D(`!02$=\'.//I
|
||||
M=X;>NA:.N6O_W36G.EU_VEP>]0`&!/-&CP''#`0>A0)X`@Z!$EB0\0/J&Q'@
|
||||
M<*4"LH`R'TVWT]$Q`X%H(002@53@&Q9D0('^1A)XG1V!`4$0V`0F=3L='C,0
|
||||
ME!A38!5H!N9@0888*'!H@5@9%A@02(%?H,NWT_$Q`T&J40:>@7A@^Q5DT($&
|
||||
M!QOHA:F!`0$9&`?&?P!`RS$0+!QW8!ZH"#I?088AJ'#X@2L7'Q@0V(&#X`4(
|
||||
M^>5R4AWEQ\MU@`(?YE<`PEDWDL.Q"(Z"D5>0$0H&!(%$"WCW@8!:5,4W`WIB
|
||||
M-2#K=P.N?RH8MN((!@0+1X^!R`P$&D4B2`K^@B!7D+$+2AR0H$%W"@(`J6`E
|
||||
M6``B08S,0.!9^(+`8#3X=@49S:#%40PN:,-@0-`+*H/"WWP%R0P$(08T*`V.
|
||||
M@R)7D/$-:AS7(.94#08$SR`WJ.+U&)3,0%!JB(/D8#TH<`49\:#'D0Z><>=@
|
||||
M0!`.NH.#6,HQ$(P<]*`]:!#*80"`0"AR[(.:73X8$,R#`&$PQN\!9O[>2C?G
|
||||
M77[<WR>81Y5()L=!Z!$&6T$&1Q@0]!&JH"?8#79-5I?%1P.*9K(@\(0#AEUY
|
||||
ME$(8$(P</08H,Q!4%`7A1Z@3FEA!ADTH$."$_A_39]")A"12!1CW68(]!BDS
|
||||
M$&@6.>%.Z!0F64&&4B@0,(5!86Z'E?F$*H=1B/@AA0``*C,0=!A-X5,H%L)B
|
||||
M76%!`!96A>(=5B85NAQ:8?#W#@(`K,Q`$&J$A6-A7?A?!1EQH4`P%Z*%'-[*
|
||||
MY14*!&=ATC>2>6H9X4G88\`R`T')01?:A8RA=A5D((8"@6+(%\)X*U=>:'.T
|
||||
MA2^AJI4!YEP;(,_E`:Z"+^`:!&=-2`(!:=@8GH:X59!A&@(`>41)6!BJ>*Z@
|
||||
M6D?#Q8(9WPU'"Z9!I15DJ',@0;C,0!!1+(:H87`(3@49O:%`\!M.AOJ>@[4:
|
||||
MMH81X2+68_`R`X%E`1P*A]2A315D0(<"@72('$Y\6U1Q*'1@AK?A6`;,#`09
|
||||
MQG18'9Z'^%B+4!"4A]LAWN=@88=&!WCX_Z%ZQ,Q`T&F8A^AA?MA-!1GUH4!P
|
||||
M'[:'K*"#-1X*!.RA8.B5V6I68:B&S`P$(0=^J!\^B+-4D+$@"@0-(H`8&KI3
|
||||
M_:'3(1\*A3379CB`=88QFC*&_%V((>"`)!"8B!!BBFA+!1DH(@!01[B&\)\E
|
||||
M&!N"9BNADE8;-GKSH2>51TV(4@<2!,T,!`V%@Z@B#HF\4Y#Q(PH$0:*%Z`1B
|
||||
M3BWBB]@<,F$``#4S$$@60B*1:"6^95%B04`E*HE@(.9T)&H=&V*"N-AA,P-!
|
||||
MA5$E7HEH(OP49)")`H&9R"7*@9B3E"@0;(D&(EM'&,:(RV"/P<T,!)G&F9@F
|
||||
M_HFY4Y"Q)PH$?>*;^/BMB06!FU@G`F(+77*(!($S`T''X2<"BI1BX11D0(H"
|
||||
M@:1H*%J"@F)!4"@NBO<;GG@2>HC%F"9(U7&"&*&HJ-+!6?"10-`J5HJP8I'X
|
||||
M'A4$<02,2`">A#-BNP8+LH0W8NO'(=:"`0"FJ'8@0>C,0)!03(JQ8K(85@$`
|
||||
MQ:)`<"QNBLM@D/$JSHK&WYUX*[Z%[,Q`X%@@B\IBM[@+!1G9HD"P+4*+)V&0
|
||||
MT2S*'6%B6ABJP3,#083!+7J+\&+[$V2PBP*!NT@NJGC@8D$P+H**G)Q)^!;2
|
||||
M,P-!I?$NQHL$8UH39`",`H'`>"_Z>```O1@0V(O\(G/G+PYBC9!`D'$,C`5C
|
||||
MQLBA!!D58T!P,2Z,(1O"&!`HC!'C\2?QN8>78'DW^9UWE5]5)R*>C`$BG,4=
|
||||
M"00SH\9H,]YF`$#-F#,RA(Y4##C-77RK7Z\X"^:(&5!IU3$"`!E'CP'0#`0%
|
||||
M!<9X,SZ-UD.0L30*!$TCR!CJZ8QM1+6((*J+BQU!,Q`H%DXCU"@V0A!!AM<H
|
||||
M$("-5F-`-C4&!%5CR6@M6H!Y(@"`T`P$F\VKQ:BEBM=B4#<V[HVZ4)`Q-PH$
|
||||
M=6.=&(25=4OB&6<V!@1HH]NX-?:%I!=#,Q!$&F$CWR@Y4@]!AN,H$$".::-=
|
||||
M]C<&!(&C"P0TFHPN8.$XED$T`T'%$3E.CJ@COA!DD(X"@>F8.6)REF-`@#DJ
|
||||
MCDN?F*@93H0MVLHHY[6,J.++&#IVB<%<'H4<"03#8^IH/$X004;Q"`"D$;8B
|
||||
MW(@K^HRHW^<(X#E%`AYER/%A*ZQC0%!Q]!@8S4`04)R.QV/XN!X$&=VC0/`]
|
||||
MOHYDFO+(/#Z)A1Q',Q`8%N"C^"@_<FE52D$`/Z*/PU7Y&!"<C[3C(,<X[G0E
|
||||
MD$"08,2/\V,!V1X$&0%D0#!`XH_7F?LH$-R/_6,MQS627@)8HT%`&I`8)'H0
|
||||
M9%20/&.5ET`"``MD!-DH<H<]!DHS$$0<%V0&J4*.!T&&"2D0H)`,)%;&06J-
|
||||
MM>,$V2'BCM,:B&CY^8Z@H>AXYP4`M)%`$$2ND$2D;@4`#)%'9`?9"D*/*N&N
|
||||
M:"-V71K?KX@;YE$N9$`0<?08,,U`T$^DD$5D%^D<!!E9I$"P1<:07A@264;0
|
||||
MD/ZC];C3T30#@6#!17J1<*2*!0"PD0*!&TE&KEQA9$`P1HJ0A"/P.);A-`-!
|
||||
M@?%&QI&$)'009`"2`H$@>4<:='1D0&!'\I%L'HF8]_$T`T&B,4@6DICD<A!D
|
||||
M4)("@26Y2"YHB&1`H$A"DJ:>)#E?`34#0<-Q26:2K*1Q$&2@D@*!*OE)8DZ<
|
||||
M9$#@29*2(Z(/>3J1BH+9&[5#SG$PHRD)9WE&`@$QV4H>DZP:`&!,*I-*),7'
|
||||
M1+Z":QVO"$7:AD1CSU!:P9(!0</18R`U`T$^L4HBD^!D;!!D<),"@3<Y2YYQ
|
||||
MRV08@49*D/\CS<?4#`1^Q3<93LZ3N$&0\4X*!/'D.:G9D9,!@3F)2P:3NF3>
|
||||
M!]4,!`&&/$E/'I2S09`Q4`H$!:4^Z4[=DP%!/OE/_HYP(JI'U0P$A89!B5!N
|
||||
ME*Y!D'%1"@09I4-9Y2V4`4%#.5'VD'YDD8?5#`0)AT;)4;Z4J4&0L5(*!"VE
|
||||
M2+E6?90!04AY4DZ,$F'DU^_ICO_>1<A#\I1[%YR5&`D$1R5,J50F!T%&4HD8
|
||||
M-9,HH9'61$:33Z0)%D7:CJ]?'C53!@0)1X\!U@P$]81+N52.E<,6`/!5"@1A
|
||||
MI4WI8#F57<0Z.4*BC#T&63,0Z!5B)5EI5VX&089<*1#0E6KE%G56!@1IY4[Y
|
||||
M&@YB_05!T%_4E7=E8FD9!!F%Y4!P6/:5>65!P%<*EJKB(!9H$`2!!F*I6&Z6
|
||||
MD4&0<5D.!)DE9`D`-)8"P6-)6>:-;%K!01`4')HE9^E:,@9!AFHY$+"6HN5G
|
||||
M*1"$EJ>E\ZCB\9(9G&?8"0Z6-5H>)1>U'J]E<5D;!!G#I4!`%_65N6)_UY71
|
||||
MAM,DCBA%ZHC8BFPI$!0</48\01#$$ZVE<>E=IF\VR'8)52*7!<%RF5L>A7&C
|
||||
M74$0V!7=Y7?I7OH%089Z.1"PEZ*E=CD0<)?L(\267Q`$^45[^5[^EWE!D+%?
|
||||
M#@3]I6@I7PH$].5YN17&C7T&0=!G^)<`9H1)%P09#>9`\&"*E@.F0%!@*IAN
|
||||
MX2`6<!`$`0>$*6&.F&]!D/%A#@0AIFA980H$%R:'F1G>D#XE10A46H2\(]VV
|
||||
M.*J1>%L>M14-!#LFB>EC:@9!1H^9>D"5S67JEVC9@"YA>%@TYE$GID`0</08
|
||||
M[`1!P$Z(F#]FE:D5!!E1YD`P98J60J96E"ZVDZB>7$$0R!54II5I9H8%08:8
|
||||
M.1"0F:)EEBD0;)DNII)Y4M47!$%]46:>F7@F5Q!DT)D#@9TI6JJ9`@&;&6=6
|
||||
MDWE?GD$0Y!EW9IZI:%X%08:A.1`@FJ(EGRD0^)F#YG19Y/4;!$&_D6@NFIRF
|
||||
M5!!D8)H#@:8I6CJ:`@&D66EBE6Y>C)D[9H(LXR9H8]:08*9HF$<%1:1'IVEK
|
||||
M%@9!!JTI$`Q%S.4S*1OZ=]*D54E-6IK69!X%:@H$_4:/<4X0!.?$IGEK/IL]
|
||||
M09"Q;`X$S:9HJ6L&!+SFJ6E#TGQN!4'@5CB;T&:X210$&=WF0/!MBI;3I@OR
|
||||
M9>*8J%Y\01#$%^"FN"EO_@1!AKLY$,";HF6Y*1"<F]IFK%GDU1D$09T1;\Z;
|
||||
M!.?<!0``G`.!P"E:VIL"`;[9;[*;8QGN%Q#D&P-GP6EQU@1!AL0)`%"<HB7"
|
||||
M*1`HG`^GH\A;ZI`N(S"9`-%$(LJ+F6-B*R;10-!R7IPPIUH09+R<`0%*).6A
|
||||
MG#:1G+E$GGY3Y6P8;,9K5^6V.45B*QJGQAES'IW/09"A!`T$3)!HN0(%!///
|
||||
M2;D`61,J)ZI70Q`$-43%B71NG2A!D'%U1A[C91)4$#2=(2<)"0!4$P1!-:%U
|
||||
M<IULYT@09*"=(4C8^74*!%EG?NF]`0!F!4%@5JR=;6??Z1$$&7GG0+!WBI9P
|
||||
MIT"@=MJ=^EMZ01"D%WRGW^EX9@1!AN(Y$#">HF7@*1`,GF4G7`D`M!D$09O1
|
||||
M>#Z>H&=&MWD6!)ZG:"EY"@249^89(")!<U.\\7F&GK#G0Q!DM)YA)^<Y$)2>
|
||||
MJJ<IF3)*?JSF[NAJ?H9$Y0>71SE-2T7L:7PV!4$&'#00R$%.)SWD5N9`4V=`
|
||||
M$!`1FUJ4I*)#$`0ZQ#2%!PU#C)H?Q'U^G^!G^%D('4(!@#I0$)B?!L'1>#0>
|
||||
MGW=E+[1!B)_P9_QI0MR8CB+[:7]F!T'&]3D09)^BI?))>*R;CJ*D<@(-!-J$
|
||||
M]@E^OD[>I_RI@"Z@\"?YR0X4!`]H^ED0K)_WYU+I?OY"#&@&"@RA33AGU:GS
|
||||
M5:`@:-)9@IA`\E<'JG,Z6/JG0,!_YIX!I=$9@KZ@KL&-`*(,!#<#$":#V@P$
|
||||
M%%9!HHA9'Z.!>$.HARB*F+4^&H@'#V5CA$HV2*B3`H,NH7+!C5"G$`1U"F1U
|
||||
M(\0I8I;KN"AB%7D*09"G3%,_*!/JA4H0-T(6.A!LH39H:5,01*'/%E;1IQ`$
|
||||
M?0H76M9\H7!H`W$CK*$#01M:AHJA`@$9>H4"`(`*00"HN*%]6!PJB#8/-T(?
|
||||
M.A#\H64H'2H0V*%[Z*!"$`PJ@.@@*HE2#S>"(SH00*)EJ"$J$""B>ZBA0A`8
|
||||
M*I'H)"J*X@LW@B<Z$("B9:@E*A!@HGMHHD(0)"JAZ"@JB^X'-X(K.A#`HF6H
|
||||
M*2H0H*)[**-"$#`JL>@L*HS:!S>"+SH0`*-EJ"TJ$."B>^BC0A`\*L'H,"J-
|
||||
MQ@<W@C,Z$$"C9:@Q*A`@HWNHI$(02"K1Z#0JCK('-X(W.A"`HV6H-2H08*-[
|
||||
M:*5"$%0JX>@X*H^>!S>".SH0P*-EJ#DJ$*"C>RBF0A!@*O'H/"J0B@<W@C\Z
|
||||
M$`"D9:@]*A#@HWOHID(0;"H!Z4`JD78'-X)#.A!`I&6H02H0(*1[J*="$'@J
|
||||
M$>E$*I)B!S>"1SH0@*1EJ$4J$&"D>VBH0A"$*B'I2"J33@<W@DLZ$,"D9:A)
|
||||
M*A"@I'LHJ4(0D"HQZ4PJE#H'-X)/.A``I66H32H0X*1[Z*E"$)PJ0>E0*I4F
|
||||
M!S>"4SH00*5EJ%$J$""E>ZCF@:9H65WH5"J6/@?BQ`CD`@F.56E!@)7NH:T*
|
||||
M(A65CJ5P*7!P([2EZ)04&J+X'7\85A&KB%DAPEL:E_ZEN\&-L)=J$'UI&4J7
|
||||
M)@EYJ0\T`O$0?BE@ZIC:!C="K2)F,:9EZ&"*)!2F>^A(I$$4$8WI8^J9Q@8W
|
||||
M@F:*&YE0D>EBFH,"`+R*F'5-=*:?:6O*&MP(J:D&L9J6H:*IHW2:9D$:!#?!
|
||||
MFKJFO.EI<"/@IDB";EJ&QJ9(PFRZAQ(K8A8YL9OVILRI:+""C$#*:1D*G)X(
|
||||
MPND>BJR(62S"<MJ<;J>=0>,T`F6G92ARJD%$IWLHLR)FL0S:*7>JGF(&-X)Y
|
||||
MJD&@IV7H=:I!@*=[*+0B9KD3Z>EZJI].!C>"?:I!X*=EJ'N*),"G>RBU(F;-
|
||||
M$_GI?JJ@.@8W@H&J02"H9:A_BB0`J'LHMB)FW1,)ZH*JH28&-X*%JD%@J&6H
|
||||
M@XHD0*A[J"BD0>P3&>J&JJ(2!C>"B8HDH*AEJ(>*)("H>RBX(F;]$RGJBJJC
|
||||
M_@4W@HVJ0>"H9:B+>B+`J'LHN2)F#10YZHZJI.H%-X*1JD$@J66HCXHD`*E[
|
||||
M*+HB9AT42>J2JJ76!3>"E:I!8*EEJ).*)$"I>RB[(F8M%%GJEJJFP@4W@IFJ
|
||||
M0:"I9:B7BB2`J7LHO")F/11IZIJJIZX%-X*=JD'@J66HFXHDP*E[*+TB9DT4
|
||||
M>>J>JJB:!3>"H:I!(*IEJ)^*)`"J>RB^(F;-"(GJHJJIA@4W@J6J06"J9:BC
|
||||
MBB1`JGLHOR)F<129ZJ:JJG(%-X*IJD&@JF6HIXHD@*I[*,`B9M4(J>JJJJM>
|
||||
M!3>"K:I!X*IEJ*N*),"J>RC!(F:1%+GJKJJL2@4W@K&J02"K9:BOBB0`JWLH
|
||||
MPB)FP0S)ZK*JK38%-X*UJD%@JV6HLXHD0*M[*,,B9K$4V>JVJJXB!3>"N:I!
|
||||
MH*MEJ+>*)("K>RC$(F;)#.GJNJJO#@4W@KVJ0>"K9:B[BB3`JWLHQ2)FT13Y
|
||||
MZKZJL/H$-X+!JD$@K&6HOXHD`*Q[*,8B9D6=GJ.[%I8NK!RK5W`C6*P:!,9J
|
||||
M#]&``$##.@)!K'LHQR)F\10):\?JLM8$-X+*JD&PK&4HR(HDB*R,D<^)58`L
|
||||
M8M8*T;*^K$`K3'`C\*P:A,]:ALJL2`+-NH>2+&)6!_&S!JU0ZTIP(S"M&H33
|
||||
M6H82K4B"T;J'HBQBEL/PM$:M8*M)<"-PK1J$UUJ&4JU(@M6ZA[(L8M;FE+%Z
|
||||
M8AMKV"JW)@4W`MNJ0;BM(RLL6+(J"2.0V;J'PBQB%O3D@[ZA<VOA:A3<"("K
|
||||
M!B&XOJUKW=YJMR()>&O."FQB%32+F!4\#:Z!J.&JN3*LP-,(=+DRKK/AWIJX
|
||||
M(@F+:]X:36(5.(N8!4-AKIMKZQH4W`BIJP:QNH*N_MW>6KEJ$)^KZ:JS<E$C
|
||||
MT!?%NKJNP"M/<"/P+&*6[TJ[/I=[:^R*),RNNNOD"@``+6*6#P66$J[!:_4*
|
||||
MLSZO(Y#TBI;RKL7K:4JTB%G%U.]JO8ZO,\&-\+UJ$.'K\4I1W0C0JP:AO:JO
|
||||
M<!56@;2(6?*4^$J^WJ\NP8TPOVH0]2O\2C;MK><KDI"^-J_/90"`53`M8I9'
|
||||
MY;^F"'$K_NK`H@0W`@*K02BP!.SZ^DZ-0/UK!1N_`@!0BYA55"VPERGU^L".
|
||||
ML"3!C=#!:A`?K`;[OT:P(Q`%*[D6L%@%U2)FN57V*PEKPX8$-X(,JT'0L"`L
|
||||
M.F7"CD`I[`NK=6$56(N8-55-KYGK#:O$9@0W0A&K01RQVZL.BR3PL"KL](15
|
||||
M<"UBUF.%Q"ZQ7&Q'<"-@L1J$%KN].K%(`A3;P^9#6`78(F:M5S5L%^O&4@0W
|
||||
M@AJK0;"Q9^R!\,6.0&)L'6O`/E@CD(35QKZQ@.Q#<".0+6*6'UO'[JUR+))`
|
||||
MQU:Q,Q!6@;:(60;6'QO(3K(*P8WPR&H0D>PA.\CVL:<IVX(D9%F2+"4KRCY/
|
||||
M`(`G>R*`LIILW#`"9;*,+%*%5;PM8I:3%<J.LK3LW@K+:A"R;"IKR@8`J&PK
|
||||
MB\:V6B.0JS7+UK*B[(TPMXA9PFPJ>\LB";FL+XLB8!5WBYCE;`VSQ.PD>R-$
|
||||
MLQK$-)O*'K,:1#+KS.ZQ>XN8]6Y1L]4L('LCA+,:Q#B;RF*S2((V^\UB%7^+
|
||||
MF/5PD;/EK!M[(\2S&L0\F\JBLTB".OO.%EPCD,M%S]:S7.R-,+B(60)M*HO/
|
||||
M(@GZ[#][N(A9&-<62]`2LS?"0ZM!1+3;ZT&K022T_^SB(F;]70/M1'O#W@@>
|
||||
MK08!TJ:R%BV2@-'JL5C%XR)F>5XAK4A+PMX(+JT&`=.FLB4MDG#2_K.3BYC5
|
||||
M>\6T,NT#>R/TM!K$3YO*UK1(PDW[SUXN8M;V!=0&M?CKC<#4:A!.;2I+U"()
|
||||
M1NT_N[F(6?G74PO5DJ\WPE:K072UJ>Q4BR14M?_LYR)FD5\2[5<;R`(Y(Q!;
|
||||
MN[V*M4@"6?O/CBYBUA'FU;JUU>N-@-=J$'IM*JO6:A!R+4O[A8U`/]A>R]<"
|
||||
MKS?"Z2)F);:I[%^+)`2V_^SJ(F8]86WM8MO%0A4C$&:[O3JV&@1D^\^^+F(6
|
||||
M)W;&-K":[4AK,(Q`IJTSN[=:MAJ$9VO8SBYBEBYVVHJPJ:T->R/0MAJ$;>O:
|
||||
MW@BDK0;1V@JQ&^SM(F:A8IEM;JO:&K<:!'*[O?*V2()O2]RV5UC%[B)F$63)
|
||||
MK7([T_8-(Q!VN[TRMTB"<VO8_BYB%DAVVR:QVNW]>B.0MQJ$>?O;<K?7[6DZ
|
||||
MO(A9/]EYF]XJL3?"?*M!U+?O+7N+)+BWTZT56S>,0%N9?7O?ZK8#KIA5X+ZW
|
||||
M^BV2P-\&N(VLV#`"Y66*[8$+MMX(RXN81>&FLL>+@GN:/B]BUEF6W5JX8"U9
|
||||
M-@*)N-MKAJM!;+C_[/0B9@%G%2Z)&[3>""ZN!@'CIK(@K@:!XAJVUXN8I9W%
|
||||
MN#+NRWHC]+@:Q(^;RM:X2,*-^\]N+V(6?0;D!KD=ZXW`Y&H03FXJ2^0B"4;N
|
||||
M/_N]B%D/VI,+Y2ZL-\*6JT%TN:GLE(LD5+G_[/@B9IUH7NZ7NZ_>"&JN!L'F
|
||||
MIK)B+I)`YOZSYXN89:&-N&YNZWHCY+D:Q)Z[O<:Y2,*<^\^N+V(6D,;G]KF:
|
||||
MZXV`Z&H0BN[V"N@B"8*N8?N^B%F!FH'+Z`:O-\*EJT%DNN_MHXLD1+J&[?PB
|
||||
M9NEI;>ZFJZW>"*:N!H'JIK*>+I(`ZD*XKFSV-`()#E^KJKNDW@CWBYB%ZY:A
|
||||
MK2Z2\.K^L_N+F,6LI;JZ[JYZ(Q2[&L2QF\KVNAK$K[N'_B](`J^VZ":[%RX`
|
||||
M0.V>"-;N]LKL(@G.[C\KP(A9#!NRB^VJJC?"N*M!E+NI[+8;`'2[AJT!(V:5
|
||||
M;.;NN:NIW@CRK@9![Z:RZBZ2P.[^LPJ,F,6SU;OVKJ)Z(P2\&L3`F\KFNTC"
|
||||
MOOO/.C!BUM1&\!:\>NJ-`/%J$!)O*HOP(@D*[S\KP8A9:]O$2_&JJ3?"QZM!
|
||||
MA+RI[,6+)&2\_ZP%(V9M;=?NR!OE8FTC$,R[O9J\2`+*^\]J,&)6ZB;RRKR[
|
||||
M+NHV`OF\J:S+JT'8O(:M!R-F`6^:+M`+M=X(2J\&P?2^MSRO!D'T_K,BC)BE
|
||||
MO?V\3J^.>B-DO1K$UIO*1KU(PM1+Z_ZR)HR81;\UO5VOD`L`I+T:Q-K[WH*]
|
||||
M2(+8^\^J,&(6!,?VMKTS+]ZK0>B][RW<BR3(O6?O,[N_C4`)'-?+]VJH-X(+
|
||||
M(V8EOJFLWXLD`+Z%[QXKPXA949SBN_@JJ#?"Y:M!9+ZIK..K04"^_ZP-@R0L
|
||||
M<9KOYJN?W@BF[XF`^J:RGB^2`/K^LSJ,F#7&I;ZJKWIZ(]2^&L3MF\JVO@'`
|
||||
MZ_O/^C!B5I"1Z^:^O.F-0/QJ$,9O&<K[(@F^[S\KQ(A9E!SNB_PVIS?"]*M!
|
||||
M5+^I[/*+)#2_>Z@1(V:U<M;O]=N;W@CBKP9!_J:RVB^2P/W^LTJ,F"7/E;_F
|
||||
MKVMZ(\2_&L3\F\JFOTC"^OO/.C%B%CM'_]:_G^F-``!K$`)P*HO_(@GZ[S\K
|
||||
MQ8A9(MT`3``_IC?"`ZQ!1,"I[`&,)"3`_ZP5(V;U&,?O!`R8W@@>L`8!`I>A
|
||||
M%C"2@`'_LUJ,F-742<`B\%]Z([3`&L0+G,J6P$C"";R'>C%BUD\7\\;`!B]/
|
||||
M-P+YP-LK#8PDV,#_K!@C9B%V,#`0/);>"$JP!L$$I[(\L`9!!!NV9HR8Y=DU
|
||||
MP4[P5'HC9,$:Q!:<RD;!2,(4_,^J,6+6;<<%=\%#Z8V`!FL0:G`J"P8C"6+P
|
||||
M/^L+:1"PW0_,!F^I-\(=C"3DP=OK&XPDQ,'_K!PC9H%W:_`>+)/>"(:P!H$(
|
||||
MI[)^,.-QFMHQ8I9TIP<KPDKJC4`):Q"6\/;:"",)C_`_J\>(61I>(HP)3Z0W
|
||||
MPBBL093"J>PFC"1TPH:M'R-FN7BF\"D\D-X(LK`&00NGLJHPDL`*_[."C)@E
|
||||
MY-7"MO`\>B,$PQK$,)S*YL)(PB[\SQHR8A:61PP7P^/HC0`-:Q#2<"J+#",)
|
||||
MRO`_J\B(65'>-$P-3Z,WPC>L083#J>PUC"1DP_^L(R-F>7F7\#B\H-X([K`&
|
||||
M`0]OK^8PDH`._[.2C)@5Z,7#\O!^>B/TPQK$/[R]UL-(PCULV%HR8E:N)PX'
|
||||
MQ+/HC<`0:Q`.<2I+$",)!K%AJ\F(6<_>0PP1CZ(WPD:L073$J>Q$C"14Q/^L
|
||||
M)R-F(7L>\4<\B=X(*K$&P1*GLB(QDD`2_[.BC)CE[;7$+O$@>B/DQ!K$3IS*
|
||||
MQL1(PDS\SYHR8M:Z!Q#WQ-CO#3,"*<7;*U",)`C%_ZPJ(V;%?#PQ4PR'W@A6
|
||||
ML0:!%:>R2+$&`14;MJZ,F(7T[;U:\3P,`)3%&L19_-YVQ4C"5_S/RC)B5M"7
|
||||
M%:?%3.B-0!=K$'9Q*LL6(PEN<>6+5=@R8E;6=Q?CQ3#HC4`8:Q"&<2J[%R,)
|
||||
M??$_J\N(66_?88P8AZ`WPF2L053&J>QBC"0TQO^L+R-F&7Z6\65<@=X(HK$&
|
||||
M01JGLIHQDL`9_[/"C)A5_"W%IC$%W"6-0+/Q]IH:(PFK\3]KS(A9OU]I7!NS
|
||||
MGS?";ZQ!!,>I;&RL0>3&AJTR(V95?\+Q<&Q\W@C.L08!':>RQC&2@!S_L\Z,
|
||||
MF)7^1<?2,>QY(W3'&L1WG,I6QTC"=?S/2C-B5O\''H?'H.>-P!YK$.YQ*DL>
|
||||
M(PGF\3]KS8A9"2!M#!\_P0#`?JQ!],?;ZWR,)-3'_ZPV(V8Q@>_Q?^QWW@@*
|
||||
ML@;!(*>R`C*20"`;MMZ,F.4%-L@.<MMY(V3(&L2&G,I&R$C"A/S/BC-B%AS(
|
||||
M(7?(7.>-@")K$"IR*@LB(PDB\C]KSHA9@N"*S"(CG3?"C:Q!Y,BI[(N,),3(
|
||||
M_ZPZ(V91@CKRCAQSW@A&L@:!)*>R/C*2`"3_L^Z,F(4(^L=*\B)<"(Y`5_+V
|
||||
MVB0C"4_R/RO/B%G)8)*<)5N<-\*8K$&4R:ELE:Q!=,F&K3TC9FV#9O*93'#>
|
||||
M"'*R!D$GI[)J,I+`)O^S^HR8U0[6R7:RO'DC!,H:Q*"<RN;)2,*>_,_Z,V+6
|
||||
M/T@H%\KAYHT`*6L0DG(JBR@C"8KR/RO0B%D0X:1,*3^;-\*GK$&$RJGLI8PD
|
||||
M9,K_K$$C9A&$6/*H;`PGA",0K+R]FLI(`JK\SRHT8A9)&"O+RM4PB30"^<K;
|
||||
MJZNL0=C*AJU#(V8!A:(RL,QIW@C*L@;!+*>RO+(&02P;MA*-F$45-LO.LJ)Y
|
||||
M(V3+&L2VG,I&RTC"M/S/6C1B5F"(%G?+0NF-@"YK$.KR>PLN(PGB\C^KT8A9
|
||||
M>R&WS"Z?F3?"O:Q!Y,NI[+N,),3+@C$`X-&(69*AOKPO6YDWPL&L023,J:R_
|
||||
MC"0`S/^L2"-F,8<*\\+\8]X(%K,&@3&GL@XSD@`Q_[,FC9AU'&;,&C.)>2.4
|
||||
MS!K$R9S*=LQ(PL?\SZHT8I9VB#*GS!+FC4`S:Q`V<RK+,B,)+O,_Z]*(607B
|
||||
MNHPSW\(MP@A4-+^W.S.2T#/_LS*-F/4?WLQ'\W]Y(T3-&L34G,H.S1K$TEPP
|
||||
MVS1B5H5(-5?-[N6-`#9K$&)S*HLU(PE:\S^KTXA93N+83#9[ES?"VZQ!Q,VI
|
||||
M[-F,)*3-_ZQ/(V8EB7+SW%Q<W@A^LP8!.*>R=C.2@#?_LT*-F$4G&LV",SD<
|
||||
M)8Y`C_-[6S@C"8?S/VO4B%F*(N0<.0^C-\+FK$%TSN]MXZQ!5,X%LU(C9GV*
|
||||
MGO/G'!$#`*JS!L$ZO[>B,Y)`.A?,3HV8I2D&SJZS8GDCY,X:Q.Z<RL;.2,+L
|
||||
M7#!+-6)6K?@K]\Y+Z(V`/&L0RO/V"CPC"<+S/VO5B%G/(N_,/-N5-\+UK$%D
|
||||
MSZGL\XPD1,^&K58C9NV+K?/V+(G>".:S!H$^O[?>,Y(`/O^S7HV8!3&FS^JS
|
||||
M('HCU,\:Q/W\WK;/2,+[7#"+-6(6R8@_Y\];,0!`0&L0!O1[RS\C"?YSY8M`
|
||||
MZ[Y(XPC4@Z:R,ZA`4(/NH3Z*F)4U+L\3M/UY(W30&L0'O;WNH&_-:1JEB%EM
|
||||
MXP$=0C?/`,`*K4&TT.\M"8TDF-"&K9@B9B6.+O0+_8+>"#JT!L%#O[<R-))`
|
||||
M0Q?,9XJ8U3GZLJBM#ZT_RXTCT!)=^.ZM0322,$07S&R*F#4[]M!.]&F\IHQ`
|
||||
M6_1[FT1K$%*TD5GK4J$:A!7*17?1(C2<,@*IT>]M%JU!A-$%\Q,Z$*"AVC,;
|
||||
M/4_>"$&H!C&$8M`XZ!^680PI8A;_>,86H4EH(GV$+M(QBAXM-MX(A+0&84B_
|
||||
MMWTTDO!'?[,9AI4B9D&0AS0C[4DKTJ`T;NM(%XPW@B:M07#2[VTDC21,TA+T
|
||||
M*/V8`@KM0`"@`%`!P@P`E`1``5\`I\`L4`I(0!$``F`(0\`2\$LG`43`$>!+
|
||||
M_PIY@A2P*P0!IH(O#05@")7"H<`$@`#/]!-@!1#3=4+W4`5``5``HD`%Q`F6
|
||||
M0C<]!20!6$"<,"?XTG8"GJ`G=`]Z`C--!20!0\`4`#=-"E.`+WTH.`$.R1#P
|
||||
M31,!8<(00$U7`4*`KS`%]-*!@A%@*<C3AD(2("=L(^_T$^`$=`^D@C(=*D`(
|
||||
M];0S#5`+U`2UF?`GX-,*=1(`*)@)#_4SG03D(U)`%@`"6`%/`!-0!30!OO2?
|
||||
MH"M(`;=TI5!06PKW=#[]3?\*!K44D(\TU$Y`>N5*_]1`=5`M5`_51'51;50?
|
||||
MU4AU4JU4+]5,=5/M5#_54'54+55/U51U56U57]58=5:M56_57'57[55_U6!U
|
||||
M6"U6C]5D=5EM5I_5:'5:K5:OU6QU6^U6O]5P=5PM5\_5='5=;5??U7AU7JU7
|
||||
M[]5\=5_M5__5@'5@+5@/UH1U86U8']:(=6*M6"_6C'5C[5@_UI!U9"U93]:4
|
||||
M=65M65_6F'5FK5EOUIQU9^U9?]:@=6@M6H_6I'5I;5J?UJAU:JU:K]:L=6OM
|
||||
M6K_6L'5L+5O/UK1U;6U;W]:X=6ZM6^_6O'5O[5O_UL!U<"U<#]?$=7%M7!_7
|
||||
MR'5RK5POU\QU<^U</]?0=70M74_7U'5U;5U?U]AU=JU=;]?<=7?M77_7X'5X
|
||||
M+5Z/U^1U>6U>G]?H=7JM7J_7['5[[5Z_U_!U?"U?S]?T=7UM7]_7^'5^K5_O
|
||||
MU_QU?^U?_]<`=H`M8`_8!':!;6`?V`AV@JU@+]@,=H/M8#_8$':$+6%/V!1V
|
||||
MA6UA7]@8=H:M86_8'':'[6%_V"!VB"UBC]@D=HEM8I_8*':*K6*OV"QVB^UB
|
||||
4O]@P=HPM8\_8-':-;6/?V#BVW0$`
|
||||
`
|
||||
end
|
||||
@ -25,6 +25,13 @@
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
#define open _open
|
||||
#if !defined(__BORLANDC__)
|
||||
#define lseek _lseek
|
||||
#endif
|
||||
#define close _close
|
||||
#endif
|
||||
|
||||
DEFINE_TEST(test_open_fd)
|
||||
{
|
||||
@ -33,7 +40,11 @@ DEFINE_TEST(test_open_fd)
|
||||
struct archive *a;
|
||||
int fd;
|
||||
|
||||
fd = open("test.tar", O_RDWR | O_CREAT, 0777);
|
||||
#if defined(__BORLANDC__)
|
||||
fd = open("test.tar", O_RDWR | O_CREAT | O_BINARY);
|
||||
#else
|
||||
fd = open("test.tar", O_RDWR | O_CREAT | O_BINARY, 0777);
|
||||
#endif
|
||||
assert(fd >= 0);
|
||||
if (fd < 0)
|
||||
return;
|
||||
|
||||
@ -32,7 +32,7 @@ DEFINE_TEST(test_open_file)
|
||||
struct archive *a;
|
||||
FILE *f;
|
||||
|
||||
f = fopen("test.tar", "w");
|
||||
f = fopen("test.tar", "wb");
|
||||
assert(f != NULL);
|
||||
if (f == NULL)
|
||||
return;
|
||||
@ -73,7 +73,7 @@ DEFINE_TEST(test_open_file)
|
||||
/*
|
||||
* Now, read the data back.
|
||||
*/
|
||||
f = fopen("test.tar", "r");
|
||||
f = fopen("test.tar", "rb");
|
||||
assert(f != NULL);
|
||||
if (f == NULL)
|
||||
return;
|
||||
|
||||
@ -107,9 +107,10 @@ test_pax_filename_encoding_2(void)
|
||||
* de_DE.UTF-8 seems to be commonly supported.
|
||||
*/
|
||||
/* If it doesn't exist, just warn and return. */
|
||||
if (NULL == setlocale(LC_ALL, LOCALE_DE)) {
|
||||
if (LOCALE_UTF8 == NULL
|
||||
|| NULL == setlocale(LC_ALL, LOCALE_UTF8)) {
|
||||
skipping("invalid encoding tests require a suitable locale;"
|
||||
" %s not available on this system", LOCALE_DE);
|
||||
" %s not available on this system", LOCALE_UTF8);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -151,11 +152,7 @@ test_pax_filename_encoding_2(void)
|
||||
archive_entry_free(entry);
|
||||
|
||||
assertEqualInt(0, archive_write_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(a);
|
||||
#else
|
||||
assertEqualInt(0, archive_write_finish(a));
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Now read the entries back.
|
||||
@ -181,11 +178,7 @@ test_pax_filename_encoding_2(void)
|
||||
assertEqualString(longname, archive_entry_pathname(entry));
|
||||
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
@ -227,6 +220,15 @@ test_pax_filename_encoding_3(void)
|
||||
return;
|
||||
}
|
||||
|
||||
/* Skip test if archive_entry_update_pathname_utf8() is broken. */
|
||||
/* In particular, this is currently broken on Win32 because
|
||||
* setlocale() does not set the default encoding for CP_ACP. */
|
||||
entry = archive_entry_new();
|
||||
if (archive_entry_update_pathname_utf8(entry, badname_utf8)) {
|
||||
skipping("Cannot test conversion failures.");
|
||||
return;
|
||||
}
|
||||
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertEqualIntA(a, 0, archive_write_set_format_pax(a));
|
||||
assertEqualIntA(a, 0, archive_write_set_compression_none(a));
|
||||
@ -274,11 +276,7 @@ test_pax_filename_encoding_3(void)
|
||||
archive_entry_free(entry);
|
||||
|
||||
assertEqualInt(0, archive_write_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(a);
|
||||
#else
|
||||
assertEqualInt(0, archive_write_finish(a));
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Now read the entries back.
|
||||
@ -322,11 +320,7 @@ test_pax_filename_encoding_3(void)
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &entry));
|
||||
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
#endif
|
||||
}
|
||||
|
||||
DEFINE_TEST(test_pax_filename_encoding)
|
||||
|
||||
@ -37,7 +37,6 @@ DEFINE_TEST(test_read_compress_program)
|
||||
int r;
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const char *extprog;
|
||||
|
||||
/*
|
||||
* First, test handling when a non-existent compression
|
||||
@ -53,26 +52,23 @@ DEFINE_TEST(test_read_compress_program)
|
||||
assertEqualIntA(a, ARCHIVE_OK, r);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_FATAL,
|
||||
archive_read_next_header(a, &ae));
|
||||
assertEqualIntA(a, ARCHIVE_WARN, archive_read_close(a));
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
|
||||
|
||||
/*
|
||||
* If we have "gzip -d", try using that.
|
||||
*/
|
||||
if ((extprog = external_gzip_program(1)) == NULL) {
|
||||
skipping("There is no gzip uncompression "
|
||||
"program in this platform");
|
||||
if (!canGunzip()) {
|
||||
skipping("Can't run gunzip program on this platform");
|
||||
return;
|
||||
}
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_none(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_program(a, extprog));
|
||||
archive_read_support_compression_program(a, "gunzip"));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
|
||||
@ -33,6 +33,11 @@ __FBSDID("$FreeBSD$");
|
||||
* had a bug relating to this, fixed in Nov 2006).
|
||||
*/
|
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
#define open _open
|
||||
#define close _close
|
||||
#endif
|
||||
|
||||
char buff1[11000000];
|
||||
char buff2[10000000];
|
||||
char buff3[10000000];
|
||||
@ -43,6 +48,7 @@ DEFINE_TEST(test_read_data_large)
|
||||
struct archive *a;
|
||||
char tmpfilename[] = "largefile";
|
||||
int tmpfilefd;
|
||||
FILE *f;
|
||||
unsigned int i;
|
||||
size_t used;
|
||||
|
||||
@ -96,7 +102,11 @@ DEFINE_TEST(test_read_data_large)
|
||||
assertA(0 == archive_read_support_compression_all(a));
|
||||
assertA(0 == archive_read_open_memory(a, buff1, sizeof(buff1)));
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT, 0777);
|
||||
#if defined(__BORLANDC__)
|
||||
tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT | O_BINARY);
|
||||
#else
|
||||
tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT | O_BINARY, 0777);
|
||||
#endif
|
||||
assert(tmpfilefd != 0);
|
||||
assertEqualIntA(a, 0, archive_read_data_into_fd(a, tmpfilefd));
|
||||
assert(0 == archive_read_close(a));
|
||||
@ -107,11 +117,9 @@ DEFINE_TEST(test_read_data_large)
|
||||
#endif
|
||||
close(tmpfilefd);
|
||||
|
||||
tmpfilefd = open(tmpfilename, O_RDONLY);
|
||||
assert(tmpfilefd != 0);
|
||||
assertEqualIntA(NULL, sizeof(buff3), read(tmpfilefd, buff3, sizeof(buff3)));
|
||||
close(tmpfilefd);
|
||||
f = fopen(tmpfilename, "rb");
|
||||
assert(f != NULL);
|
||||
assertEqualInt(sizeof(buff3), fread(buff3, 1, sizeof(buff3), f));
|
||||
fclose(f);
|
||||
assert(0 == memcmp(buff2, buff3, sizeof(buff3)));
|
||||
|
||||
unlink(tmpfilename);
|
||||
}
|
||||
|
||||
@ -111,8 +111,10 @@ DEFINE_TEST(test_read_disk)
|
||||
if (archive_read_disk_set_standard_lookup(a) != ARCHIVE_OK) {
|
||||
skipping("standard uname/gname lookup");
|
||||
} else {
|
||||
#if defined(__CYGWIN__)
|
||||
skipping("standard uname/gname lookup; typically no user with uid=0 on cygwin platform");
|
||||
#if defined(__CYGWIN__) || defined(__HAIKU__)
|
||||
/* Some platforms don't have predictable names for
|
||||
* uid=0, so we skip this part of the test. */
|
||||
skipping("standard uname/gname lookup");
|
||||
i = 0;
|
||||
p = zero_groups[0]; /* avoid unused warnings */
|
||||
#else
|
||||
|
||||
@ -45,7 +45,7 @@ DEFINE_TEST(test_read_disk_entry_from_file)
|
||||
{
|
||||
struct archive *a;
|
||||
struct archive_entry *entry;
|
||||
int fd;
|
||||
FILE *f;
|
||||
|
||||
assert((a = archive_read_disk_new()) != NULL);
|
||||
|
||||
@ -57,10 +57,10 @@ DEFINE_TEST(test_read_disk_entry_from_file)
|
||||
assertEqualString(archive_read_disk_gname(a, 0), "FOOGROUP");
|
||||
|
||||
/* Create a file on disk. */
|
||||
fd = open("foo", O_WRONLY | O_CREAT, 0777);
|
||||
assert(fd >= 0);
|
||||
assertEqualInt(4, write(fd, "1234", 4));
|
||||
close(fd);
|
||||
f = fopen("foo", "wb");
|
||||
assert(f != NULL);
|
||||
assertEqualInt(4, fwrite("1234", 1, 4, f));
|
||||
fclose(f);
|
||||
|
||||
/* Use archive_read_disk_entry_from_file to get information about it. */
|
||||
entry = archive_entry_new();
|
||||
|
||||
@ -32,22 +32,15 @@ DEFINE_TEST(test_read_extract)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
struct stat st;
|
||||
#endif
|
||||
size_t used;
|
||||
int i;
|
||||
int i, numEntries = 0;
|
||||
char *buff, *file_buff;
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
int fd;
|
||||
ssize_t bytes_read;
|
||||
#endif
|
||||
|
||||
buff = malloc(BUFF_SIZE);
|
||||
file_buff = malloc(FILE_BUFF_SIZE);
|
||||
|
||||
/* Force the umask to something predictable. */
|
||||
umask(022);
|
||||
assertUmask(022);
|
||||
|
||||
/* Create a new archive in memory containing various types of entries. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
@ -55,12 +48,14 @@ DEFINE_TEST(test_read_extract)
|
||||
assertA(0 == archive_write_set_compression_none(a));
|
||||
assertA(0 == archive_write_open_memory(a, buff, BUFF_SIZE, &used));
|
||||
/* A directory to be restored with EXTRACT_PERM. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir_0775");
|
||||
archive_entry_set_mode(ae, S_IFDIR | 0775);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* A regular file. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "file");
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
@ -71,49 +66,53 @@ DEFINE_TEST(test_read_extract)
|
||||
assertA(FILE_BUFF_SIZE == archive_write_data(a, file_buff, FILE_BUFF_SIZE));
|
||||
archive_entry_free(ae);
|
||||
/* A directory that should obey umask when restored. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir");
|
||||
archive_entry_set_mode(ae, S_IFDIR | 0777);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* A file in the directory. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir/file");
|
||||
archive_entry_set_mode(ae, S_IFREG | 0700);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* A file in a dir that is not already in the archive. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir2/file");
|
||||
archive_entry_set_mode(ae, S_IFREG | 0000);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* A dir with a trailing /. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir3/.");
|
||||
archive_entry_set_mode(ae, S_IFDIR | 0710);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* Multiple dirs with a single entry. */
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "dir4/a/../b/../c/");
|
||||
archive_entry_set_mode(ae, S_IFDIR | 0711);
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
/* A symlink. */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "symlink");
|
||||
archive_entry_set_mode(ae, S_IFLNK | 0755);
|
||||
archive_entry_set_symlink(ae, "file");
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
if (canSymlink()) {
|
||||
++numEntries;
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "symlink");
|
||||
archive_entry_set_mode(ae, AE_IFLNK | 0755);
|
||||
archive_entry_set_symlink(ae, "file");
|
||||
assertA(0 == archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
}
|
||||
/* Close out the archive. */
|
||||
assertA(0 == archive_write_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(a);
|
||||
#else
|
||||
assertA(0 == archive_write_finish(a));
|
||||
#endif
|
||||
|
||||
/* Extract the entries to disk. */
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
@ -125,75 +124,44 @@ DEFINE_TEST(test_read_extract)
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
assertA(0 == archive_read_extract(a, ae, ARCHIVE_EXTRACT_PERM));
|
||||
/* Rest of entries get restored with no flags. */
|
||||
for (i = 0; i < 7; i++) {
|
||||
failure("Error reading entry %d", i+1);
|
||||
for (i = 1; i < numEntries; i++) {
|
||||
failure("Error reading entry %d", i);
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
failure("Failed to extract entry %d: %s", i,
|
||||
archive_entry_pathname(ae));
|
||||
assertA(0 == archive_read_extract(a, ae, 0));
|
||||
}
|
||||
assertA(ARCHIVE_EOF == archive_read_next_header(a, &ae));
|
||||
assert(0 == archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assert(0 == archive_read_finish(a));
|
||||
#endif
|
||||
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
/* Test the entries on disk. */
|
||||
/* This first entry was extracted with ARCHIVE_EXTRACT_PERM,
|
||||
* so the permissions should have been restored exactly,
|
||||
* including resetting the gid bit on those platforms
|
||||
* where gid is inherited by subdirs. */
|
||||
assert(0 == stat("dir_0775", &st));
|
||||
failure("This was 0775 in archive, and should be 0775 on disk");
|
||||
assertEqualInt(st.st_mode, S_IFDIR | 0775);
|
||||
assertIsDir("dir_0775", 0775);
|
||||
/* Everything else was extracted without ARCHIVE_EXTRACT_PERM,
|
||||
* so there may be some sloppiness about gid bits on directories. */
|
||||
assert(0 == stat("file", &st));
|
||||
failure("st.st_mode=%o should be %o", st.st_mode, S_IFREG | 0755);
|
||||
assertEqualInt(st.st_mode, S_IFREG | 0755);
|
||||
failure("The file extracted to disk is the wrong size.");
|
||||
assert(st.st_size == FILE_BUFF_SIZE);
|
||||
fd = open("file", O_RDONLY);
|
||||
failure("The file on disk could not be opened.");
|
||||
assert(fd != 0);
|
||||
bytes_read = read(fd, buff, FILE_BUFF_SIZE);
|
||||
close(fd);
|
||||
failure("The file contents read from disk are the wrong size");
|
||||
assert(bytes_read == FILE_BUFF_SIZE);
|
||||
failure("The file contents on disk do not match the file contents that were put into the archive.");
|
||||
assert(memcmp(buff, file_buff, FILE_BUFF_SIZE) == 0);
|
||||
assert(0 == stat("dir", &st));
|
||||
failure("This was 0777 in archive, but umask should make it 0755");
|
||||
assertIsReg("file", 0755);
|
||||
assertFileSize("file", FILE_BUFF_SIZE);
|
||||
assertFileContents(file_buff, FILE_BUFF_SIZE, "file");
|
||||
/* If EXTRACT_PERM wasn't used, be careful to ignore sgid bit
|
||||
* when checking dir modes, as some systems inherit sgid bit
|
||||
* from the parent dir. */
|
||||
assertEqualInt(0755, st.st_mode & 0777);
|
||||
assert(0 == stat("dir/file", &st));
|
||||
assert(st.st_mode == (S_IFREG | 0700));
|
||||
assert(0 == stat("dir2", &st));
|
||||
assertEqualInt(0755, st.st_mode & 0777);
|
||||
assert(0 == stat("dir2/file", &st));
|
||||
assert(st.st_mode == (S_IFREG | 0000));
|
||||
assert(0 == stat("dir3", &st));
|
||||
assertEqualInt(0710, st.st_mode & 0777);
|
||||
assert(0 == stat("dir4", &st));
|
||||
assertEqualInt(0755, st.st_mode & 0777);
|
||||
assert(0 == stat("dir4/a", &st));
|
||||
assertEqualInt(0755, st.st_mode & 0777);
|
||||
assert(0 == stat("dir4/b", &st));
|
||||
assertEqualInt(0755, st.st_mode & 0777);
|
||||
assert(0 == stat("dir4/c", &st));
|
||||
assertEqualInt(0711, st.st_mode & 0777);
|
||||
assert(0 == lstat("symlink", &st));
|
||||
assert(S_ISLNK(st.st_mode));
|
||||
#if HAVE_LCHMOD
|
||||
/* Systems that lack lchmod() can't set symlink perms, so skip this. */
|
||||
assert((st.st_mode & 07777) == 0755);
|
||||
#endif
|
||||
assert(0 == stat("symlink", &st));
|
||||
assert(st.st_mode == (S_IFREG | 0755));
|
||||
#endif
|
||||
failure("This was 0777 in archive, but umask should make it 0755");
|
||||
assertIsDir("dir", 0755);
|
||||
assertIsReg("dir/file", 0700);
|
||||
assertIsDir("dir2", 0755);
|
||||
assertIsReg("dir2/file", 0000);
|
||||
assertIsDir("dir3", 0710);
|
||||
assertIsDir("dir4", 0755);
|
||||
assertIsDir("dir4/a", 0755);
|
||||
assertIsDir("dir4/b", 0755);
|
||||
assertIsDir("dir4/c", 0711);
|
||||
if (canSymlink())
|
||||
assertIsSymlink("symlink", "file");
|
||||
|
||||
free(buff);
|
||||
free(file_buff);
|
||||
|
||||
12
lib/libarchive/test/test_read_format_ar.ar.uu
Normal file
12
lib/libarchive/test/test_read_format_ar.ar.uu
Normal file
@ -0,0 +1,12 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 755 test_read_format_ar.ar
|
||||
M(3QA<F-H/@HO+R`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@
|
||||
M("`@("`@("`@("`T,"`@("`@("`@8`IY>7ET='1S<W-A86%F9F8N;R\*:&AH
|
||||
M:&IJ:FIK:VMK;&QL;"YO+PH*+S`@("`@("`@("`@("`@(#$Q-S4T-C4V-3(@
|
||||
M(#$P,#$@(#`@("`@(#$P,#8T-"`@."`@("`@("`@(&`*-34V-C<W.#AG9VAH
|
||||
M+F\O("`@("`@("`@,3$W-30V-38V."`@,3`P,2`@,"`@("`@,3`P-C0T("`T
|
||||
M("`@("`@("`@8`HS,S,S+S$Y("`@("`@("`@("`@(#$Q-S4T-C4W,3,@(#$P
|
||||
H,#$@(#`@("`@(#$P,#8T-"`@.2`@("`@("`@(&`*.3@W-C4T,S(Q"@``
|
||||
`
|
||||
end
|
||||
@ -28,46 +28,19 @@
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#if ARCHIVE_VERSION_NUMBER >= 1009000
|
||||
/*
|
||||
* This "archive" is created by "GNU ar". Here we try to verify
|
||||
* our GNU format handling functionality.
|
||||
*/
|
||||
static unsigned char archive[] = {
|
||||
'!','<','a','r','c','h','>',10,'/','/',' ',' ',' ',' ',' ',' ',' ',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
|
||||
' ',' ',' ',' ',' ','4','0',' ',' ',' ',' ',' ',' ',' ',' ','`',10,
|
||||
'y','y','y','t','t','t','s','s','s','a','a','a','f','f','f','.','o',
|
||||
'/',10,'h','h','h','h','j','j','j','j','k','k','k','k','l','l','l',
|
||||
'l','.','o','/',10,10,'/','0',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
|
||||
' ',' ',' ',' ','1','1','7','5','4','6','5','6','5','2',' ',' ','1',
|
||||
'0','0','1',' ',' ','0',' ',' ',' ',' ',' ','1','0','0','6','4','4',
|
||||
' ',' ','8',' ',' ',' ',' ',' ',' ',' ',' ',' ','`',10,'5','5','6',
|
||||
'6','7','7','8','8','g','g','h','h','.','o','/',' ',' ',' ',' ',' ',
|
||||
' ',' ',' ',' ','1','1','7','5','4','6','5','6','6','8',' ',' ','1',
|
||||
'0','0','1',' ',' ','0',' ',' ',' ',' ',' ','1','0','0','6','4','4',
|
||||
' ',' ','4',' ',' ',' ',' ',' ',' ',' ',' ',' ','`',10,'3','3','3',
|
||||
'3','/','1','9',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
|
||||
'1','1','7','5','4','6','5','7','1','3',' ',' ','1','0','0','1',' ',
|
||||
' ','0',' ',' ',' ',' ',' ','1','0','0','6','4','4',' ',' ','9',' ',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ','`',10,'9','8','7','6','5','4','3',
|
||||
'2','1',10};
|
||||
|
||||
char buff[64];
|
||||
#endif
|
||||
|
||||
DEFINE_TEST(test_read_format_ar)
|
||||
{
|
||||
#if ARCHIVE_VERSION_NUMBER < 1009000
|
||||
skipping("test_read_support_format_ar()");
|
||||
#else
|
||||
char buff[64];
|
||||
const char reffile[] = "test_read_format_ar.ar";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
|
||||
extract_reference_file(reffile);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertA(0 == archive_read_support_compression_all(a));
|
||||
assertA(0 == archive_read_support_format_all(a));
|
||||
assertA(0 == archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertA(0 == archive_read_open_file(a, reffile, 7));
|
||||
|
||||
/* Filename table. */
|
||||
assertA(0 == archive_read_next_header(a, &ae));
|
||||
@ -110,10 +83,5 @@ DEFINE_TEST(test_read_format_ar)
|
||||
/* Test EOF */
|
||||
assertA(1 == archive_read_next_header(a, &ae));
|
||||
assert(0 == archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assert(0 == archive_read_finish(a));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -36,10 +36,15 @@ DEFINE_TEST(test_read_format_cpio_bin_bz2)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(a));
|
||||
r = archive_read_support_compression_bzip2(a);
|
||||
if (r != ARCHIVE_OK) {
|
||||
skipping("bzip2 support unavailable");
|
||||
archive_read_close(a);
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
|
||||
60
lib/libarchive/test/test_read_format_cpio_bin_lzma.c
Normal file
60
lib/libarchive/test/test_read_format_cpio_bin_lzma.c
Normal file
@ -0,0 +1,60 @@
|
||||
/*-
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
static unsigned char archive[] = {
|
||||
93, 0, 0,128, 0,255,255,255,255,255,255,255,255, 0, 99,156,
|
||||
62,160, 67,124,230, 93,220,235,118, 29, 75, 27,226,158, 67,149,
|
||||
151, 96, 22, 54,198,209, 63,104,209,148,249,238, 71,187,201,243,
|
||||
162, 1, 42, 47, 43,178, 35, 90, 6,156,208, 74,107, 91,229,126,
|
||||
5, 85,255,136,255, 64, 0
|
||||
};
|
||||
|
||||
DEFINE_TEST(test_read_format_cpio_bin_lzma)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(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));
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
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));
|
||||
}
|
||||
|
||||
26
lib/libarchive/test/test_read_format_iso.iso.Z.uu
Normal file
26
lib/libarchive/test/test_read_format_iso.iso.Z.uu
Normal file
@ -0,0 +1,26 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1G@0#`6!Z-&!``1`XH$((`"``@4I,$%"%0PD`@`7%%2C
|
||||
MB@*IF,8"!UR``0O@"!#0B0=V:.212":IY)),-NGDDU!&*>645%9IY952-K%$
|
||||
M$E,\8<04('#Y!`@YV&`##"\@\24(1B3!1!%39#$%%45H*$05;A)1A!0@F`#"
|
||||
MA44,\804#PK8@A0O$&%%H5(4$005@X*`PA`I@!!##CG,`$(1+F3Q1!5.'$%$
|
||||
M$&]*2JFEF-X`@A(N0.&H%%TZ\0*K4PR!A)M,)!$JEKSVRJL,!-800PPPW"##
|
||||
M##+04,,-!((#+`S"$FLLLLHR"P,X!&:K[;8$`O!LM,4>F^RRS1;IZ[GHIJON
|
||||
MNNRVZ^Z[\,8K+Y/_U;O8/P(2:*"]_/;K[[\`!UR=EDF`T,0;;H#@Q!MV0*CJ
|
||||
ML3HDJ\.R('RK0!MKI#''&V;,4;$+,+B@:0MO@$!'&7/0T8*"89#QA1EOR-%&
|
||||
M&'2XH'')80BL\\X\]^SSSV<=6..00!=M]-%()ZWTTDPW[?334$?=&XD!U4BU
|
||||
MU%AGK?767'?M]==@ARWVV%K/./1`-PZD(X\^`BEDB4,>:+:-`.`8T-H]_A@D
|
||||
MT26:2/;?@`<N^."$%V[XX8@GKOCBC#?N^..01R[YY)17;OGEF&>N^>:<=^[Y
|
||||
MYZ"'+OKHI)=N^NFHIZ[ZZJRW[OKKL,<N^^RTUV[[[;CGKOONO/?N^^_`!R_\
|
||||
M\,07;_SQR">O_/+,-^_\\]!'+_WTU%=O_?789Z_]]MQW[_WWX(<O_OCDEV_^
|
||||
L^>BGK_[Z[+?O_OOPQR___/37;__]^.>O__[\]^___P`,H``'2,`"&O"`]`,`
|
||||
`
|
||||
end
|
||||
@ -29,20 +29,13 @@ DEFINE_TEST(test_read_format_iso_gz)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
const char *name = "test_read_format_iso_gz.iso.gz";
|
||||
const char *name = "test_read_format_iso.iso.Z";
|
||||
|
||||
extract_reference_file(name);
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(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));
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
@ -50,7 +43,7 @@ DEFINE_TEST(test_read_format_iso_gz)
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_next_header(a, &ae));
|
||||
assertEqualInt(archive_compression(a),
|
||||
ARCHIVE_COMPRESSION_GZIP);
|
||||
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));
|
||||
|
||||
66
lib/libarchive/test/test_read_format_iso_joliet.iso.Z.uu
Normal file
66
lib/libarchive/test/test_read_format_iso_joliet.iso.Z.uu
Normal file
@ -0,0 +1,66 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_joliet.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$PDX4056(#@X(,01BBA
|
||||
MA`)*\403$V:HX8,'X5*0AQX="$``(AZ(``(`6%"0!10DI*)`(@#`04$SHB@0
|
||||
MBD8$(,"!`1`@0$`E'KCAD$06:>212":IY)),-NGDDU!&*>645#YY1!%.)#'%
|
||||
M$TDT$<25(&CY!`@YV&`##"\@8<04(!B1!!-%3)'%%%04@>$04A01!!5/2`$"
|
||||
M"D.D`$(,.>0P`PA%N)#%$U4X<0010<#Y9Z"#%GI#"S(0:`,(2K@`A9Y2;.G$
|
||||
M"YU.,002;R;HZ*2"9@J##9@2>`,(%2Z1!!4@U!D$AE7VZJN3KN8`0Z8TR!!#
|
||||
M#3+,0`.!!`0[+`S%'IOLLC`00."UV&9+(`#.$FLLLLHR*^2OY)9K[KGHIJON
|
||||
MNNRVZ^Z[2?XG[V(""$B@@0$Q`4`2`#@!0!4`8`$`"`,73/#!!B=,\!``$`&`
|
||||
M%``\`4`3"E>,\,4=?EC""T5P%"20`)P(``8%84`R0AH,%*,'!;%L8T`XZLBC
|
||||
MCR"/*"+&.%NL<\X\[^QSST#_+'301`]M=-%('ZUTTDPO[7334#\M-<9'`-"Q
|
||||
MO_Q.$?&^$P,0!`!5=TQPUEL3G`,`-J`-``P`?`$`$@`8`8#6!,O-K[X=:YW%
|
||||
MW`!08777"S_\]]=^2PPQP2@`P'`*!<<`P-EGSU!PQRX`L+?$`/M;M<-?XSVU
|
||||
MT9\7';K0W4+[[;3,EAXMN-1:J^WKVZI^>KC5C@OO[;CGKOONO/?N^^]'SBO\
|
||||
M8?_86Z"(PR>O_/+,-^_\\]!'+_WTU%=O?50'SE@S``,`T(%`!Q*1!,37EV_^
|
||||
M^>BGK_[Z[+?O_OOPQT\8\C*.&%#W`GT?@/CDR^___P`,H``'2,`"&O"`"$Q@
|
||||
M>P[$LNT9```?`%]`R`"`-`!`#@K,H`8WR,$.>O"#(`RA"$=(PJ'0CV4B>J!`
|
||||
M(G@@"EH0@R6,H0QG2,,:VO"&.,RA#G<('D34CR`U&DC,=C0BFMG/9G.#P@$"
|
||||
MX(MW/$P*!0A`(*"`!1($H!U?$T@0VH&_@0R`?D#Z$4$$0`4C:"``#L@1$7ND
|
||||
MQIFU00`$J``-1$"`(12!`P$@&$'T6)!V]-$,/QQ($&\4-YD548Q!"H`4H"A%
|
||||
M*EH1BP/98A<%\L6"Z*@@9#0C&MM81$[VZ(UQG",!```'[Q7D>R\+62'7:,02
|
||||
M#8!_BXQB(IS0!`2T,`UR<.05LQB0+8IQ($0DR"7'6,8SIM&0;$0F`4`I1SH"
|
||||
M@`\`"$%!0J#"@1@@1Y6$HP1'M``D!$$*1%#5$ERP@QC$,@"S;$(##H2&,,B!
|
||||
M#&Q(@QO6H$M2!&(@@2#%+P42S($,$YC%W&0`LDD`;!X(CLP4I26B.<UJ"N2:
|
||||
M`SWH*&N&1B8\P5%?4,(3F."".F&AG$^4)2U'<"`VO,$-9VB!&MX0SS+0H05F
|
||||
M2`,;RM`"-X2A#65P`1W*@`<ZQ'2F];RG0/*YSX#T$WQ%!4`FC6E0I18THDY-
|
||||
M*!U!`8`8$<2J!6FJ-BFJ`#DU09SD=-PY&T%+!AQH#GEH0SSGJ<M_A&(@H?@'
|
||||
M&)$HS*0*8`I,*(&(/&!2E*J4I6EP*4QE2E.;XE2G//4I80/J`*DN$X[-?&PH
|
||||
MG<G#REH6?8#\'D%0*<15S@R10#K0.:=8Q5U&LAUVG>L_^<E83SZ5E8X%`""U
|
||||
M)TA5$M*UH+69(AE)VD?RTFM<+$@EZXK)UBK3M;&]K'*7R]SFWF9E+;,MS#Q[
|
||||
M2(H>"+H$<5EG<6O=`"0N@@2)8"J'^%F*/M"%%^060PE"S8)`E*#;#``$`(`&
|
||||
M`(0AO11D0P4!X`8`K`$`7ECO0-I+D/=*-+X\`(!^W\!?`)P!`"T`@!H`P&#]
|
||||
M6K`,`*`#A&6[7_UB.,+]O6\;`(#ARFD8PWC(,(<MZ.&U5;4@6"6(5B=Z1#0"
|
||||
M8`X`R`,`1FSA!O_7N4`.LI"'[),8@7<@XMVN,G-+HA<W<"#:O>V2NTOD*EOY
|
||||
MREB67A&DT(X`*(`*A]AM$J#P!4+E(`9[0D(10&"A(2R!S4D@`I@45"<IG"H(
|
||||
MCEHS%"S$IR%L%`1[?H(5XAPG$$RA"E"`0I]P980^`?H)4TA"@]PD*3G1R4Z&
|
||||
MMA.>J9"$(4P!"G`*PA36[&<G4"$(0\"5^$P%Z"H((4%34+.?&NVG3Q=A"$EP
|
||||
MTQ#VE(2+&II1=DZ4@T:M9U?#6M9A(@*6..VF+8?)"8"60I>^F0406&&C56C"
|
||||
MFI5M*FE#@4^S=G2I3YWJ9]/:2YR^:.6RS.YVN_O=2D%#&=A@4@7`^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
(&(_R.(_T:!4`
|
||||
`
|
||||
end
|
||||
@ -0,0 +1,71 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_joliet_long.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GA0+@6!Z-&!``1`XH$((`"`!@5I0$%"%@PD`@`<%%2C
|
||||
MB@*I:$0``B10(@D"!'3B@1T6:>212":IY)),-NGDDU!&*>645%9I991-+)'$
|
||||
M%$\8,04(6SX!0@XVV`##"TAX"8(123!1Q!193$%%$1H*446;1!0A!0@F@'!A
|
||||
M$4,\(<6#`K8@Q0M$6$&H%$4$086@(*`P1`H@Q)!##C.`4(0+63Q1A1-'$!&$
|
||||
MFY%.6NFE-X"@A`M0-"H%ETZ\L.H40R#1)A-)@'KEKKSN*@.!.<1`(`XPX!!#
|
||||
M##7D0"`)O\(0[+#%'IOLL@16:^VU!`+0[+/%1HNLLC"00&2OY)9K[KGHIJON
|
||||
MNNRVZ^Z[2_XG[V(""$B@@0$9`8`<`)31+P!"`#`%`$0``(+!"!^L<,((#T$P
|
||||
M`%(`\`0`33"\\,46(VR0B`/E4L(+17`TI)``I`@`.`6!@T%"+`HTXP<%P8QC
|
||||
M0#KRZ&,`0))<(HD8]YRQST#_+'301`]M=-%('ZUTTDPO[7334#\M==143VUU
|
||||
MU557O`0`20@L,8)>']SUP!,?G`,`-J`-``P`?`$`$F`/?+"^73,!0,@#9^$U
|
||||
M%7=3C'#`57`-@-T%AQSQP28T_'#$(3L\<<0%'^QPP2U`W/;#5CPLN>4A!W&U
|
||||
MU)\W';K3VPK;K;'?+ELZM*A/&RZVL%>K+;"F$]LZN.(:#._NO/?N^^_`!R_\
|
||||
M\$K.:_QA_]A;((G'-^_\\]!'+WUQ628!`A5HU`'"$V/0`2$.(!2KP[$Z)`O"
|
||||
MM@K(X$*!Z\<0A@V9MJ`$""VH\08;:91!1PMLO.'&&?2K0QK(4"GZG6&`YP.!
|
||||
M"Q;X@C3,X0W3BZ`$)TC!"EK0*;B8P8%JI+.2`<`#`CE0#&0P`QK4P`8WP,$%
|
||||
M5\C"%KKPA3",H0QG2,,:VO"&CF$>C4I$LX&`,``C+.$)4XC#(AKQB$A,HA*7
|
||||
MR,0F.O&)4+S/@6#606=HC(<`B(&V`#`#`-```#50VPT`H,*SL4V+,N"B%\$H
|
||||
M1C("P(Q9W&(7OQC&M(VQC&N+8QKGR$8[NA&.:%0C'=N(QS/*<8UU!,`=WYC'
|
||||
M0/(QD8L$Y"$'Z<="ZE&0?53D'QLYR4Q&,H]D`$`:]A7%4IKRE*A,I2I7R<I6
|
||||
MNO*5P=$AS$AD18$<3(2=A.0F#;E'1!*2D;S$I"XMZ4A?5A*8EWSD+R792TIJ
|
||||
MDIBY7"8GF^G)72;3F,]$9C&=^4FVA7*4_(*E.,=)SG*:\YSH3*<ZU\E.F$!B
|
||||
MAP2YT4!JUJ,?!0F+)A(8%`X0`%^\`V)2*$```@$%++`@`.WPG$""T(X!%&0`
|
||||
M.A32/0<B``X.A`-4,((&`N"`'=439VU00(H6L`,2A'2D)1U"$3@0@!`4Q*4&
|
||||
M:4=!VN$&>%[4@SE"D,WLJ3,3!4`*`1UH00^:T($PU*$$@6A!>%20BMHHHQOM
|
||||
MZ$Y!*E($D-2D5;TJ`'#QP8*`<&8>].C-<H9/!`31A"A4(5`%F@@G-($-(B0A
|
||||
M6E.HK+,.$0=UE>M=\RK$M/)UKG@MD%[]*MB^TK6P@/WK7A&[6#*D00XJ96D'
|
||||
M"C)9@^B+(/K2!0!F1!`1&*`@!A#KCT(HI`78-:TNV$$,UAJ`MKXUKH8-[&D/
|
||||
M.UO9#I:VM[5M;!5+V-KR%K>[+6QD`U#9@73@L@,Q`G(%HB]";+8@G@6M:'%&
|
||||
MVA(M``E!&!2NG+"$U*XVJ*YMP('0$`8YD`%_;EC#4`-`BD`,)!"DF*A`!!#1
|
||||
M$LDW(`+@K(R@RM'IDL"_)[5J2=M)X`*+<[U%76@[[@L`^BZ5P0(`(4$\P%^I
|
||||
M?O2_4\4J2DFPWO:^-[Y-K2]3"9)?Z%;8OP#.ZH`-S.(6N_C%\JJIA'V(TQ[Z
|
||||
M]YXC8RU!#8I0A0:$H1`6,81G+!`*:[2_&0[P594\X)I:5"#RS.F->VHB'2/8
|
||||
MQP`XZD.%W-0G!P2C1[;P6)FL80&3`,9H3K.:UYR9E\6LQF'-,(Z%="`W$T1F
|
||||
M\]3IA>>\LP#`X[F=_2Q!0IOAZ@;`BMNL)C2I.4QM1O.8S!2F-(.I3$A/4]*6
|
||||
MIC0VNWE-;EHST8V.=*6S*6H`_/E@!#D86.DY5CX?NM.*=C2C)PWK4%]ZU)P&
|
||||
M-:UUG>E:[_K1I+[UIC\-;$Y_DY1IU*_+!#T00E_8T!```!H`$`92AI(-H@1`
|
||||
M3=?`YFY[^]M<F1&J!Z+J/$\9GW4&`!4'@F<IRYG*]06WO.=-[WKW1T_M"(`"
|
||||
MJ'"(GTHA"5#X@J6"Y2@D%`$$&!K"$A">!"(<X>"YFI,4:A4$4!T<"AAZ5*"8
|
||||
M``*,/\$*#7\3"*90!2A`05!46!.D3CZ%)&!A36TZ.)SD1*>1TZGB5$C"$*8`
|
||||
M!3<%80H'#Y03J!"$(:2<"%L:0L>K(`1<3<'@>S("I'@.J"2P:0B.2L(3G#!R
|
||||
M3TU\4Q`"^L69[G2H@RE/0[=Z$O0$)JYC/`E-R&X60&"%)S"A"DTX>)YH]6\H
|
||||
M/"KJD!(ZT8W>=JE+(>XYW[H+[,WXQCO^\4%!0QG8T#\%0/[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
|
||||
MV9(N^9(P&9,R.9,T69,V>9,XF9,ZN9,\V9,^^9-`&91".91$691&>91(F91*
|
||||
MN91,V91.^910&952.9546956>958F95:N95<V95>^95@&99B.99D699F>99H
|
||||
MF99JN99LV99N^99P&9=R.9=T69=V>9=XF9=ZN9=\V9=^^9>`&9B".9B$69B&
|
||||
4>9B(F9B*N9B,V9B.^9B0&9F2J90`
|
||||
`
|
||||
end
|
||||
@ -0,0 +1,68 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_joliet_rockridge.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1G@0+@6!Z-&!``1`XH$((`"`!0590$%"+`HD`@`<%%2C
|
||||
MB@*I:$0``B10(@D"!'3B@1T6:>212":IY)),-NGDDU!&*>645%9I991-+)'$
|
||||
M%$\8,04(6SX!0@XVV`##"TAX"8(123!1Q!193$%%$1H*446;1!0A!0@F@'!A
|
||||
M$4,\(<6#`K8@Q0M$6$&H%$4$086@(*`P1`H@Q)!##C.`4(0+63Q1A1-'$!&$
|
||||
MFY%.6NFE-X"@A`M0-"H%ETZ\L.H40R#1)A-)@'KEKKSN*@.!.<1`(`XQU""#
|
||||
M##340"`)O\(0[+#%'IOLL@16:^VU!`+0[+,P$&LLLLK"0`*1O99K[KGHIJON
|
||||
MNNRVZ^Z[\"[YW[R+"2`@@08&9`0`<@!0AK\`"`'`%``0`0`(!R>,\,(*)SQ$
|
||||
MP0!(`<`3`#31,,,87YRP02(.A$L)+Q3!T9!"`I`B`!@4A$'*"&DPT(P>%!0S
|
||||
MC@'IR*./`0!9<HDD9NRSQC\'#?300A=-]-%&)XWTTDHWS?333D<-]=125TWU
|
||||
MU59;;?$2`"0Q\,0(?HVPUP13C'`.`-B0-@`P`/`%`$B$33#"^WK-!``B$YS%
|
||||
MUU3@77'"`E?1-0!W&RRRQ`B;X##$$HO\,,42&XSPPP:W$+';$%L!\>27BQP$
|
||||
MUE.#[K3H3V\K;+?1@KNLZ=!^.ZVXV,9>K;;`GNZMM.&.>W"\O/?N^^_`!R_\
|
||||
M\,0K2>_QA_US;X$D(N_\\]!'+_WTQ669!`A4H%$'"$^,00>$.%1:@P['ZI`L
|
||||
M"-LJ((,+!;(?0Q@V9-J"$B"T4$<:9%1:_QGXHP^""P!\01KF\`;J&?"`"$R@
|
||||
M`A>X%5QHX$`UVAD`!@"`#@CD0$1(@L08R,$.>O"#(`RA"$=(PA*:\(0HE$SS
|
||||
M:%2B@%!0(!8,0`8WF,(:VO"&.,RA#G?(PQ[Z\(=`U,^!8B9!`P#@`Q<,"!D`
|
||||
MD`9^!?&)4(RB%*=(Q2I:\8I8S*(6H;+"F)'(B`)!XH&6V,1^;?&,:$RC&M?(
|
||||
MQC:Z\8UPC"-[(,%"@MQH(#;KT8^"U$*>#0P*!PB`+]X1,2D4(`"!@`(66!"`
|
||||
M=GQ.($%HQPL',H`5"HF/`Q%`!`?"`2H8X8$.V)$><]8&!2#@`19H`0E*><I4
|
||||
MDF`(1>!``!!&$%H6I!VW=$,=.6DR/"+H9GO<F8D"(`5#(E*1C'3D0"(Y28%4
|
||||
MLB`\*H@F;>1)4(H29ZLT)2I5R<IMD@``>*A@02Q(LUY>,YA]#,``9EC,0R;"
|
||||
M"4U`P!C3(`=D-O*1`8DD)@4B`$N6:)\!$8`%"=*!:@8@E,#,V3E)J4U7`H`0
|
||||
M``A!04(`QH$88*'?%.8"D!"$0>'*"4MPP0YBT,X`O+,)#3@0&L(@!S*P(0UN
|
||||
M6(,]21&(@02"%``%0#^AF5,!2)0@(3`H0D=)`HQVTY6>B.A$*RJ0BR8TH^ET
|
||||
M`!.>`*HO*.$)3'#!G+`PTD*Z$YXC.!`;WN"&,[1`#6]X:1GHT`(SI($-96B!
|
||||
M&\+0AC*X@`YEP`,=W`K7F=94(#?MJ3^C21"?3E2HJ0U6)"@#`XQ^0C2P\
|
||||
M#H+1))9(`7!JPD=#VM62-@*>##C0'/+0AI?&U)[M",5`0M&.P0ZVIX^-+&3A
|
||||
M,04FE(!$'AAK6<^:UC2LM:UOC>M<ZWK7O.XUN(A5IX\$4%3EZC2;K52E'*=+
|
||||
M7?7H<J`#(:<O,<I'DI4TD8N\YS+;(5B>2A.[,$PN48_*S<5^4Y>;%,@=<_1+
|
||||
MHG972";Z+FKQ"0!F%N29!"%L)N,;D$Y^\J"*C2YTO5G=!COXP1!N#<QDUDOZ
|
||||
M<E>8!YHP06:VW:?>EV<!0,$1"X+$<N81FQ\.@!')Z$09*!6H3`V(4XEJV0!`
|
||||
M``!H`$`8G+A$-C`1`+I<`P"\\.*!4+0@,\9FC7D``!\74)=G`(#EU`"``OJX
|
||||
MB?^B@Y0!8(8?^_A?EM/ECML`,!<`0,O_"J>6N]S$+[/-L;*=+66?6F,'`&`.
|
||||
M`,@#`,A\92`#0,@1#K2@!TWHH<P(B00I<8?MBV$`:'@@'+:PAS'LST);^M*8
|
||||
MSO0!]=1:!5#A$,240A*@\`5+!<M12"@""#`TA"6L.@E$.(*J<S4G*=0J"*!2
|
||||
M-10P]*A`,0$$NWZ"%6#])A!,H0I0@(*@J+`F2"E["DG`PIK:I&HXR8E.QJ83
|
||||
MKJF0A"%,`0IN"L(45!TH)U`A"$-@=@9I!>PJ"`%74TCUGHP`J6\#*@EL&H*C
|
||||
MDD!58WO*UIN"T+AU[6YXRQM,>3(WOI.@)S`Y`=BB;D)'LP`"*V"U"DU0=9YH
|
||||
M)6HH/&K>D"KWN=/M<'I+0>+<IJJ9-<WREKO\Y4]!0QG8,%8%P/SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
|
||||
.V9(N^9(P&9,R.9,T^8(`
|
||||
`
|
||||
end
|
||||
94
lib/libarchive/test/test_read_format_iso_multi_extent.c
Normal file
94
lib/libarchive/test/test_read_format_iso_multi_extent.c
Normal file
@ -0,0 +1,94 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
DEFINE_TEST(test_read_format_iso_multi_extent)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_multi_extent.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* Retrieve each of the 2 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 2; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("file", archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(262280, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "head--head--head", 16);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,67 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_multi_extent.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GB0#0<*%(`-'X48@(D`((````H4I``%"5DPD`@`<%"0
|
||||
MC2L*M*(1`0B0```!D"!`0"8>V.&12":IY)),-NGDDU!&*>645%9IY9583LE$
|
||||
M$D($(<402"1A11$@)#'%$R#D8(,-,(!@1!),%#%%%E-0482&5TB1A)U29.GG
|
||||
MGX`&*FB2,A"80PP%WD!@#&PJ"@,)A<)P:**+-DH@"01FJNFF!`(0Z:0Q.,HH
|
||||
M#(Z28.2@J*:JZJJLMNKJJ[#&*FN5_]6ZF``"+AJB$0#(`4`9OP(@!`!3`$`$
|
||||
M`"`@JVRRS"ZK[!#&`B`%`$\`T(2SS6:+K;(&@3C0B"6\4`1'11*9XHHM$J0`
|
||||
M!@EI,",`'104;XX![=CCCT$."221(6KK[[;_!@SPP`(73/#!!B>,\,(*-\SP
|
||||
MPPY'#/'$$E=,\<466\P$`$D("T`0T@(`+1(<`V`%`.,FVW&QU2:;`P`DD@B#
|
||||
MLKQVO/&XQ69!+`!4H&RMLE>$W''/XTZ;,<9('ZUMT@\SK?"GB(9:*:F70DUI
|
||||
M@98^RNG6F7IJ:-2B9FTJLK.6;?;9:*>M]MILIVWKVX?]DVN!(<)M]]UXYZWW
|
||||
MWL4EX801:$X1!AT@/#$&X:&"0*`.C.I`*@B?*L!&&F*$(<<8:*1A1QF0NW"#
|
||||
M"SD0&`8(:<SQ1@MLE+$Y&SW,P,(;=[A1AAP]Q*"##'SGKOONO/?NNU4'VFCN
|
||||
M[\07;_SQR">O_/+,-^_\\]"#5G>-^T9O_?789Z_]]MQW[_WWX(>O]X'Q#B_^
|
||||
M^>BGK_[Z[+?O_OOPQR__5]/'._W\^.>O__[\]^___P`,H`#S`PGJ$01'`[&7
|
||||
MCX`DI.&=B%A0.$``?/$.:4FA``$(!!2PP((`M`%D`@E"&_0U$`'<#T@D%(@`
|
||||
MA#<0#E#!"!H(@`-XM,`@T1!?)&B#`B(```@<@`1#*`('`N"!@A31(.TH2#O<
|
||||
M8,`6IBB!"+H7`_55I`!(X8(9W&`'/S@0$:8P("8L2(\*LL(;O3"&,Y2B#=68
|
||||
MPQWV\(<`X`,`/E`0.N+#1/B(8@U)``@''N!-<7+!#F)P10PFP@E-2,"!S)"&
|
||||
MU&DQ2($82"#&1I`'5O*+`!``'0GR@3/*\(8,!&60=,A#'Y)`CEXH2"KO2*0\
|
||||
MBI*/?@1D$01)2"P>,I&+;&09'DF"2`IDDB>TY+<P*8!4$L0+GDSC'E])RC>>
|
||||
M$@"=*$@G$`&!@4``$:\4$9'^"*=9#K*0`;BE(@'`2$=R$)*2I.2W@DG,:!*D
|
||||
M$\E\)3/=:,H!VO.>^'P+C<HWD'E!\954Y!<`]BFO)^I(CS@,*)!.I((YUA$`
|
||||
MK`22*]G8Q^H%8$5F`$`:`,"&8#74F`-9)1X1RL"*F@BC&N6H1Z$I36I:$YML
|
||||
MU":04+K1C@(KGSC-J4YW&IPB2*$=`5``%0YA13U!X0LQR,&A@D`%))`)0T-8
|
||||
M`@CT1(0CD,EO?`)3$)Q@51!``4-4>,(0GL`$KV+("DD@@IQ`,(4J0`$*3Y`"
|
||||
M%=P45Z\^80I)P(*;NLE6.ME)0U.XTU:ID(0A3`$*<0I"8$$P5B=0(0A#F"L1
|
||||
MS#0$KU9!"%N:@E/[!+@^';8(0TC"FX;`U"0\P0EL?4(5OC1+"`663%"X;&8W
|
||||
M6R:U.E:T2?!IF5#[U20TP4M9`($5R%J%)I!)K5,8@E'#RMFZ-O:QD=UM9W]+
|
||||
MV-.Z@*?8S:YVM]L7-)0A#&1H00N\"U[QDC>\X_TN>L]K7O6&X;WPC:]\YTO?
|
||||
M^7+WOOC-KW[WR]_^^O>_``ZP@`=,X`(;^,`(3K""%\S@!COXP1".L(0G3.$*
|
||||
M6_C"&,ZPAC?,X0Y[^,,@#K&(1TSB$IOXQ"A.L8I7S.(6N_C%,(ZQC&=,XQK;
|
||||
M^,8XSK&.=\SC'OOXQT`.LI"'3.0B&_G(2$ZRDI?,Y"8[^<E0CK*4ITSE*EOY
|
||||
MREC.LI:WS.4N>_G+8`ZSF,=,YC*;^<QH3K.:U\SF-KOYS7".LYSG3.<ZV_G.
|
||||
M>,ZSGO?,YS[[^<^`#K2@!TWH0AOZT(A.M*(7S>A&._K1D(ZTI"=-Z4I;^M*8
|
||||
MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
|
||||
MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
|
||||
MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/?FOJ2_SBTY<.86BD>)&O_!8PGPW+3S[TG2_]Z#=2^-C/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
0^9`0&9$2.9$469$6>9%O"```
|
||||
`
|
||||
end
|
||||
206
lib/libarchive/test/test_read_format_iso_rockridge.iso.Z.uu
Normal file
206
lib/libarchive/test/test_read_format_iso_rockridge.iso.Z.uu
Normal file
@ -0,0 +1,206 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_rockridge.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GA0#Q@,A$$/'QT(0``F'H@``@!84)`%$R14P4`B`'!!
|
||||
M03>R*!"+1@0@0`(GDB!`0"D>V.&12":IY)),-NGDDU!&*>645%9IY9583MG$
|
||||
M$DE,\8014X#0Y1,@Y&"##3"\@`28(!B1!!-%3)'%%%04H:$05;Q)1!%2@&`"
|
||||
M"!<6,<034CPH8`M2O$"$%89*44005!`*`@I#I`!"##GD,`,(1;B0Q1-5.'$$
|
||||
M$4'`.6FEEV9Z`PA*N`#%HU)XZ<0+K4XQ!!)O,I&$J%GVZFNO,A"8`PPYR'`#
|
||||
MIC'4,$.P,)#`[+#%'IM#LLL22`*!V&:K+8$`/$NLL<@JRRP)1OYJ[KGHIJON
|
||||
MNNRVZ^Z[\,;;Y'_T+O:/@`0:6.^^_/;K[[\`5[=E$B!,48<;!9<!!PC&IJI#
|
||||
MLCHLR["P"K2Q1AISO&'&'`R[4"`(B()<1QID7`KR&20S#((+++^`\1L!QRSS
|
||||
MS#37;'-:!]Y(I$`#`!#BSD0D(<7-1!=M]-%()ZWTTDPW[?334+]F8D`WFMBS
|
||||
M0"$&$/3047?M]==@ARWVV&27;?;9:">-B(TX`J!C0#SZ"&0`0NY\XH%30'%`
|
||||
M`+Z\`X`44A000"!08$%N.T$,%$0[5P\TP-0"^5B0`%08H4$`#O3X8Y!M)+#!
|
||||
M!`^`0$+GGX=.PA!%<!!`!@6Q;E`[!;5C!ML$Y3A0W)O3/>2)1*((N."$&QX`
|
||||
MXHHS7M#C!4E.$.668Z[YW*-[#KKHI$]/`@!P^%Q0B&^[C:#<0>Z>X@!;_QY`
|
||||
M(DXT@<"!9*0A1^&')R[0XKL/)`#D1-8O$/.79PX^W<_CG/1,!P`Z`$`#!=$`
|
||||
M%<+`BX#P(@R5^]_U[!:``[@)3B[800S,A[XF).!`9D@#&\H`OP"0(A`#"00I
|
||||
M]!>0^R6/A0#@G_,D&$"Z5<]T?#A@`A?80``\,(*YFR#O3K0`)`2A4+IRPA(R
|
||||
MN,'`G2]]#3@0&L(@!S*P(0UN6$,)3YC"%4X.?R>"H0S]%\0:1J]THC,$`$ZA
|
||||
M,ZJ=XB!FC!R1%""G)B1QB1K\FQ,;D3X&'&@.>6C#%;-8PG:$8B"A:`<84?3"
|
||||
MR4V!"0LP$0%".,+*]:]'`P"2`$B`24V>T7IK8^-`+O!&@]Q0='(D8AWO*`,F
|
||||
MFH^/38@B```I2"RN00:%/*1`$KG(18KQD7[T'@`&0(<VP,&2F#OE)TVG3$6L
|
||||
ML8TV*F5!.H<!!Q3@!$),T0)6N:LES,"5>X3B'P,YR#7,()>(5&3R?.E()CA`
|
||||
M10$AIC$)``!D.D"9^!R@Z!CQS%%*DR#*3&4`MID%.W:3!N`4'"QE2<MRT@"=
|
||||
MNU0G01@YT5\R`0('HN>0Z#G,8AZS>??4YS*I)U)']%,@I(2C!`5*4(,JL08)
|
||||
M#<!"QUG++-8`H@'AY3H;N;Q'1N!`0V*1CB8IPC+8LY,QY&0`,IG4@/)3E"C]
|
||||
MYT"H:4ULLI2;2K1!3&<Z2W+:T@8X!8!.)\K.GEX4GATU)HOH:<]\HG&D0DR;
|
||||
M7#,RNY^)2)AP^UX0Q=<[/0*OD/(+"/V^R%/['56";K4>`&8'3:KAU7MFY.O=
|
||||
M`F"^X,6O>(WC65D-"U(S)I:`<PVM:$=+VM):A$^*5``5#D%9*20!"E_`U+0@
|
||||
MA80B@`!#0UC";9-`A"/8=E=UDL*M@B`JVT(!0Y$:%!-`<-PG6(&W<2I8%:``
|
||||
M!4)1H4V2JNX4DH"%-KW)MG*BDYT*9B?B4B$)0\@;G((P!=L.R@E4",(0KALT
|
||||
M6S&W"D+0U11JVR<C2"IO@DJ"FX8`J20\P0D%`Y5P.P6A]AH7O_KEKYCV!%\!
|
||||
M)X%/8D+P<9/0A"-F`016>`(3JM`$V^[)5JZ%0J3Z*ZGWQG>^&?:O%#I\W@.[
|
||||
MP+0XSK&.=QPS-)2!#6QX@P)X3.0B&_G(2$ZRDI?,Y"8[^<E0CK*4ITSE*EOY
|
||||
MREC.LI:WS.4N>_G+8`ZSF,=,YC*;^<QH3K.:U\SF-KOYS7".LYSG3.<ZV_G.
|
||||
M>,ZSGO?,YS[[^<^`#K2@!TWH0AOZT(A.M*(7S>A&._K1D(ZTI"=-Z4I;^M*8
|
||||
MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
|
||||
MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
|
||||
MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
|
||||
MV9(N^9(P&9,R.9,T69,V>9,XF9,ZN9,\V9,^^9-`&91".91$691&>91(F91*
|
||||
MN91,V91.^910&952.9546956>958F95:N95<V95>^95@&99B.99D699F>99H
|
||||
MF99JN99LV99N^99P&9=R.9=T69=V>9=XF9=ZN9=\V9=^^9>`&9B".9B$69B&
|
||||
M>9B(F9B*N9B,V9B.^9B0&9F2.9F469F6>9F8F9F:N9F<V9F>^9F@&9JB.9JD
|
||||
M69JF>9JHF9JJN9JLV9JN^9JP&9NR.9NT69NV>9NXF9NZN9N\V9N^^9O`&9S"
|
||||
M.9S$69S&>9S(F9S*N9S,V9S.^9S0&9W2.9W469W6>9W8F9W:N9W<V9W>^9W@
|
||||
M&9[B.9[D69[F>9[HF9[JN9[LV9[N^9[P&9_R.9_T69_V>9_XF9_ZN9_\V9_^
|
||||
M^9\`&J`".J`$6J`&>J`(FJ`*NJ`,VJ`.^J`0&J$2.J$46J$6>J$8FJ$:NJ$<
|
||||
MVJ$>^J$@&J(B.J(D6J(F>J(HFJ(JNJ(LVJ(N^J(P&J,R.J,T6J,V>J,XFJ,Z
|
||||
MNJ,\VJ,^^J-`&J1".J1$6J1&>J1(FJ1*NJ1,VJ1.^J10&J52.J546J56>J58
|
||||
MFJ5:NJ5<VJ5>^J5@&J9B.J9D6J9F>J9HFJ9JNJ9LVJ9N^J9P&J=R.J=T6J=V
|
||||
M>J=XFJ=ZNJ=\VJ=^^J>`&JB".JB$6JB&>JB(FJB*NJB,VJB.^JB0&JF2.JF4
|
||||
M6JF6>JF8FJF:NJF<VJF>^JF@&JJB.JJD6JJF>JJHFJJJNJJLVJJN^JJP&JNR
|
||||
M.JNT6JNV>JNXFJNZNJN\VJN^^JO`&JS".JS$6JS&>JS(FJS*NJS,VJS.^JS0
|
||||
M&JW2.JW46JW6>JW8FJW:NJW<VJW>^JW@&J[B.J[D6J[F>J[HFJ[JNJ[LVJ[N
|
||||
M^J[P&J_R.J_T6J_V>J_XFJ_ZNJ_\VJ_^^J\`&[`".[`$6[`&>[`(F[`*N[`,
|
||||
MV[`.^[`0&[$2.[$46[$6>[$8F[$:N[$<V[$>^[$@&[(B.[(D6[(F>[(HF[(J
|
||||
MN[(LV[(N^[(P&[,R.[,T6[,V>[,XF[,ZN[,\V[,^^[-`&[1".[1$6[1&>[1(
|
||||
MF[1*N[1,V[1.^[10&[52.[546[56>[58F[5:N[5<V[5>^[5@&[9B.[9D6[9F
|
||||
M>[9HF[9JN[9LV[9N^[9P&[=R.[=T6[=V>[=XF[=ZN[=\V[=^^[>`&[B".[B$
|
||||
M6[B&>[B(F[B*N[B,V[B.^[B0&[F2.[F46[F6>[F8F[F:N[F<V[F>^[F@&[JB
|
||||
M.[JD6[JF>[JHF[JJN[JLV[JN^[JP&[NR.[NT6[NV>[NXF[NZN[N\V[N^^[O`
|
||||
M&[S".[S$6[S&>[S(F[S*N[S,V[S.^[S0&[W2.[W46[W6>[W8F[W:N[W<V[W>
|
||||
M^[W@&[[B.[[D6[[F>[[HF[[JN[[LV[[N^[[P&[_R.[_T6[_V>[_XF[_ZN[_\
|
||||
MV[_^^[\`',`"/,`$7,`&?,`(G,`*O,`,W,`._,`0',$2/,$47,$6?,$8G,$:
|
||||
MO,$<W,$>_,$@',(B/,(D7,(F?,(HG,(JO,(LW,(N_,(P',,R/,,T7,,V?,,X
|
||||
MG,,ZO,,\W,,^_,-`',1"/,1$7,1&?,1(G,1*O,1,W,1._,10',52/,547,56
|
||||
M?,58G,5:O,5<W,5>_,5@',9B/,9D7,9F?,9HG,9JO,9LW,9N_,9P',=R/,=T
|
||||
M7,=V?,=XG,=ZO,=\W,=^_,>`',B"/,B$7,B&?,B(G,B*O,B,W,B._,B0',F2
|
||||
M/,F47,F6?,F8G,F:O,F<W,F>_,F@',JB/,JD7,JF?,JHG,JJO,JLW,JN_,JP
|
||||
M',NR/,NT7,NV?,NXG,NZO,N\W,N^_,O`',S"/,S$7,S&?,S(G,S*O,S,W,S.
|
||||
M_,S0',W2/,W47,W6?,W8G,W:O,W<W,W>_,W@',[B/,[D7,[F?,[HG,[JO,[L
|
||||
MW,[N_,[P',_R/,_T7,_V?,_XG,_ZO,_\W,_^_,\`'=`"/=`$7=`&?=`(G=`*
|
||||
MO=`,W=`._=`0'=$2/=$47=$6?=$8G=$:O=$<W=$>_=$@'=(B/=(D7=(F?=(H
|
||||
MG=(JO=(LW=(N_=(P'=,R/=,T7=,V?=,XG=,ZO=,\W=,^_=-`'=1"/=1$7=1&
|
||||
M?=1(G=1*O=1,W=1._=10'=52/=547=56?=58G=5:O=5<W=5>_=5@'=9B/=9D
|
||||
M7=9F?=9HG=9JO=9LW=9N_=9P'==R/==T7==V?==XG==ZO==\W==^_=>`'=B"
|
||||
M/=B$7=B&?=B(G=B*O=B,W=B._=B0'=F2/=F47=F6?=F8G=F:O=F<W=F>_=F@
|
||||
M'=JB/=JD7=JF?=JHG=JJO=JLW=JN_=JP'=NR/=NT7=NV?=NXG=NZO=N\W=N^
|
||||
M_=O`'=S"/=S$7=S&?=S(G=S*O=S,W=S._=S0'=W2/=W47=W6?=W8G=W:O=W<
|
||||
MW=W>_=W@'=[B/=[D7=[F?=[HG=[JO=[LW=[N_=[P'=_R/=_T7=_V?=_XG=_Z
|
||||
MO=_\W=_^_=\`'N`"/N`$7N`&?N`(GN`*ON`,WN`._N`0'N$2/N$47N$6?N$8
|
||||
MGN$:ON$<WN$>_N$@'N(B/N(D7N(F?N(HGN(JON(LWN(N_N(P'N,R/N,T7N,V
|
||||
M?N,XGN,ZON,\WN,^_N-`'N1"/N1$7N1&?N1(GN1*ON1,WN1._N10'N52/N54
|
||||
M7N56?N58GN5:ON5<WN5>_N5@'N9B/N9D7N9F?N9HGN9JON9LWN9N_N9P'N=R
|
||||
M/N=T7N=V?N=XGN=ZON=\WN=^_N>`'NB"/NB$7NB&?NB(GNB*ONB,WNB._NB0
|
||||
M'NF2/NF47NF6?NF8GNF:ONF<WNF>_NF@'NJB/NJD7NJF?NJHGNJJONJLWNJN
|
||||
M_NJP'NNR/NNT7NNV?NNXGNNZONN\WNN^_NO`'NS"/NS$7NS&?NS(GNS*ONS,
|
||||
MWNS._NS0'NW2/NW47NW6?NW8GNW:ONW<WNW>_NW@'N[B/N[D7N[F?N[HGN[J
|
||||
MON[LWN[N_N[P'N_R/N_T7N_V?N_XGN_ZON_\WN_^_N\`'_`"/_`$7_`&?_`(
|
||||
MG_`*O_`,W_`.__`0'_$2/_$47_$6?_$8G_$:O_$<W_$>__$@'_(B/_(D7_(F
|
||||
M?_(HG_(JO_(LW_(N__(P'_,R/_,T7_,V?_,XG_,ZO_,\W_,^__-`'_1"/_1$
|
||||
M7_1&?_1(G_1*O_1,W_1.__10'_52/_547_56?_58G_5:O_5<W_5>__5@'_9B
|
||||
M/_9D7_9F?_9HG_9JO_9LW_9N__9P'_=R/_=T7_=V?_=XG_=ZO_=\W_=^__>`
|
||||
M'_B"/_B$7_B&?_B(G_B*O_B,W_B.__B0'_F2/_F47_F6?_F8G_F:O_F<W_F>
|
||||
M__F@'_JB/_JD7_JF?_JHG_JJO_JLW_JN__JP'_NR/_NT7_NV?_NXG_NZO_N\
|
||||
MW_N^__O`'_S"/_S$7_S&?_S(G_S*O_S,W_S.__S0'_W2/_W47_W6?_W8G_W:
|
||||
MO_W<W_W>__W@'_[B/_[D7_[F?_[HG_[JO_[LW_[N__[P'__R/__T7__V?__X
|
||||
MG__ZO__\W__^__\`,``*P`%(``N@`3R`"#`!*L`%R``;H`-\@!`P`DK`"4@!
|
||||
M*Z`%O(`8,`-JP`W(`3N@!_R`(#`$BL`12`)+H`D\@2@P!:K`%<@"6Z`+?($P
|
||||
M,`;*P!E(`VN@#;R!.#`'ZL`=R`-[H`_\@4`P"`K!(4@$BZ`1/()(,`DJP27(
|
||||
M!)N@$WR"4#`*2L$I2`6KH!6\@E@P"VK!+<@%NZ`7_()@,`R*P3%(!LN@&3R#
|
||||
M:#`-JL$UR`;;H!M\@W`P#LK!.4@'ZZ`=O(-X,`_JP3W(!_N@'_R#@#`0"L)!
|
||||
M2`@+H2$\A(@P$2K"1<@(&Z$C?(20,!)*PDE("2NA);R$F#`3:L)-R`D[H2?\
|
||||
MA*`P%(K"44@*2Z$I/(6H,!6JPE7("ENA*WR%L#`6RL)92`MKH2V\A;@P%^K"
|
||||
M7<@+>Z$O_(7`,!@*PV%(#(NA,3R&R#`9*L-ER`R;H3-\AM`P&DK#:4@-JZ$U
|
||||
MO(;8,!MJPVW(#;NA-_R&X#`<BL-Q2`[+H3D\A^@P':K#=<@.VZ$[?(?P,![*
|
||||
MPWE(#^NA/;R'^#`?ZL-]R`_[H3_\AP`Q(`K$@4@0"Z)!/(@(,2$JQ(7($!NB
|
||||
M0WR($#$B2L2)2!$KHD6\B!@Q(VK$C<@1.Z)'_(@@,22*Q)%($DNB23R)*#$E
|
||||
MJL25R!);HDM\B3`Q)LK$F4@3:Z)-O(DX,2?JQ)W($WNB3_R)0#$H"L6A2!2+
|
||||
MHE$\BD@Q*2K%I<@4FZ)3?(I0,2I*Q:E(%:NB5;R*6#$K:L6MR!6[HE?\BF`Q
|
||||
M+(K%L4@6RZ)9/(MH,2VJQ;7(%MNB6WR+<#$NRL6Y2!?KHEV\BW@Q+^K%O<@7
|
||||
M^Z)?_(N`,3`*QL%(&`NC83R,B#$Q*L;%R!@;HV-\C)`Q,DK&R4@9*Z-EO(R8
|
||||
M,3-JQLW(&3NC9_R,H#$TBL;12!I+HVD\C:@Q-:K&U<@:6Z-K?(VP,3;*QME(
|
||||
M&VNC;;R-N#$WZL;=R!M[HV_\C<`Q.`K'X4@<BZ-Q/([(,3DJQ^7(')NC<WR.
|
||||
MT#$Z2L?I2!VKHW6\CM@Q.VK'[<@=NZ-W_([@,3R*Q_%('LNC>3R/Z#$]JL?U
|
||||
MR![;HWM\C_`Q/LK'^4@?ZZ-]O(_X,3_JQ_W('_NC?_R/`#)`"L@!22`+I($\
|
||||
MD`@R02K(!<D@&Z2#?)`0,D)*R`E)(2NDA;R0&#)#:L@-R2$[I(?\D"`R1(K(
|
||||
M$4DB2Z2)/)$H,D6JR!7)(ENDBWR1,#)&RL@922-KI(V\D3@R1^K('<DC>Z2/
|
||||
M_)%`,D@*R2%))(NDD3R22#))*LDER22;I)-\DE`R2DK)*4DEJZ25O))8,DMJ
|
||||
MR2W));NDE_R28#),BLDQ22;+I)D\DV@R3:K)-<DFVZ2;?)-P,D[*R3E))^ND
|
||||
MG;R3>#)/ZLD]R2?[I)_\DX`R4`K*04DH"Z6A/)2(,E$JRD7)*!NEHWR4D#)2
|
||||
M2LI)22DKI:6\E)@R4VK*3<DI.Z6G_)2@,E2*RE%)*DNEJ3R5J#)5JLI5R2I;
|
||||
MI:M\E;`R5LK*64DK:Z6MO)6X,E?JREW)*WNEK_R5P#)8"LMA22R+I;$\EL@R
|
||||
M62K+9<DLFZ6S?);0,EI*RVE)+:NEM;R6V#);:LMMR2V[I;?\EN`R7(K+<4DN
|
||||
MRZ6Y/)?H,EVJRW7)+MNENWR7\#)>RLMY22_KI;V\E_@R7^K+?<DO^Z6__)<`
|
||||
M,V`*S(%),`NFP3R8"#-A*LR%R3`;IL-\F!`S8DK,B4DQ*Z;%O)@8,V-JS(W)
|
||||
M,3NFQ_R8(#-DBLR123)+ILD\F2@S9:K,E<DR6Z;+?)DP,V;*S)E),VNFS;R9
|
||||
M.#-GZLR=R3-[IL_\F4`S:`K-H4DTBZ;1/)I(,VDJS:7)-)NFTWR:4#-J2LVI
|
||||
M236KIM6\FE@S:VK-K<DUNZ;7_)I@,VR*S;%)-LNFV3R;:#-MJLVUR3;;IMM\
|
||||
MFW`S;LK-N4DWZZ;=O)MX,V_JS;W)-_NFW_R;@#-P"L[!23@+I^$\G(@S<2K.
|
||||
MQ<DX&Z?C?)R0,W)*SLE).2NGY;R<F#-S:L[-R3D[I^?\G*`S=(K.T4DZ2Z?I
|
||||
M/)VH,W6JSM7).ENGZWR=L#-VRL[923MKI^V\G;@S=^K.W<D[>Z?O_)W`,W@*
|
||||
MS^%)/(NG\3R>R#-Y*L_ER3R;I_-\GM`S>DK/Z4D]JZ?UO)[8,WMJS^W)/;NG
|
||||
M]_R>X#-\BL_Q23[+I_D\G^@S?:K/]<D^VZ?[?)_P,W[*S_E)/^NG_;R?^#-_
|
||||
MZL_]R3_[I__\GP`T@`K0`4I`"Z@!/:`(-($JT`7*0!NH`WV@$#2"2M`)2D$K
|
||||
MJ`6]H!@T@VK0#<I!.Z@'_:`@-(2*T!%*0DNH"3VA*#2%JM`5RD);J`M]H3`T
|
||||
MALK0&4I#:Z@-O:$X-(?JT!W*0WNH#_VA0#2("M$A2D2+J!$]HD@TB2K1)<I$
|
||||
MFZ@3?:)0-(I*T2E*1:NH%;VB6#2+:M$MRD6[J!?]HF`TC(K1,4I&RZ@9/:-H
|
||||
M-(VJT37*1MNH&WVC<#2.RM$Y2D?KJ!V]HW@TC^K1/<I'^Z@?_:.`-)`*TD%*
|
||||
M2`NI(3VDB#21*M)%RD@;J2-]I)`TDDK224I)*ZDEO:28-)-JTDW*23NI)_VD
|
||||
MH#24BM)12DI+J2D]I:@TE:K25<I*6ZDK?:6P-);*TEE*2VNI+;VEN#27ZM)=
|
||||
MRDM[J2_]I<`TF`K384I,BZDQ/:;(-)DJTV7*3)NI,WVFT#2:2M-I2DVKJ36]
|
||||
MIM@TFVK3;<I-NZDW_:;@-)R*TW%*3LNI.3VGZ#2=JM-URD[;J3M]I_`TGLK3
|
||||
M>4I/ZZD]O:?X-)_JTWW*3_NI/_VG`#6@"M2!2E`+JD$]J`@UH2K4A<I0&ZI#
|
||||
M?:@0-:)*U(E*42NJ1;VHC:M2-RE$[JD?]J"`UI(K4D4I22ZI)/:DH-:6J
|
||||
MU)7*4ENJ2WVI,#6FRM292E-KJDV]J3@UI^K4G<I3>ZI/_:E`-:@*U:%*5(NJ
|
||||
M43VJ2#6I*M6ERE2;JE-]JE`UJDK5J4I5JZI5O:I8-:MJU:W*5;NJ5_VJ8#6L
|
||||
MBM6Q2E;+JED]JV@UK:K5M<I6VZI;?:MP-:[*U;E*5^NJ7;VK>#6OZM6]RE?[
|
||||
MJE_]JX`UL`K6P4I8"ZMA/:R(-;$JUL7*6!NK8WVLD#6R2M;)2EDKJV6]K)@U
|
||||
MLVK6S<I9.ZMG_:R@-;2*UM%*6DNK:3VMJ#6UJM;5REI;JVM]K;`UMLK6V4I;
|
||||
M:ZMMO:VX-;?JUMW*6WNK;_VMP#6X"M?A2ER+JW$]KL@UN2K7Y<I<FZMS?:[0
|
||||
M-;I*U^E*7:NK=;VNV#6[:M?MREV[JW?]KN`UO(K7\4I>RZMY/:_H-;VJU_7*
|
||||
M7MNK>WVO\#6^RM?Y2E_KJWV]K_@UO^K7_<I?^ZM__:\`-L`*V`%+8`NL@3VP
|
||||
M"#;!*M@%RV`;K(-]L!`VPDK8"4MA*ZR%O;`8-L-JV`W+83NLA_VP(#;$BM@1
|
||||
M2V)+K(D]L2@VQ:K8%<MB6ZR+?;$P-L;*V!E+8VNLC;VQ.#;'ZM@=RV-[K(_]
|
||||
ML4`VR`K9(4MDBZR1/;)(-LDJV27+9)NLDWVR4#;*2MDI2V6KK)6]LE@VRVK9
|
||||
M+<MENZR7_;)@-LR*V3%+9LNLF3VS:#;-JMDURV;;K)M]LW`VSLK9.4MGZZR=
|
||||
MO;-X-L_JV3W+9_NLG_VS@#;0"MI!2V@+K:$]M(@VT2K:1<MH&ZVC?;20-M)*
|
||||
MVDE+:2NMI;VTF#;3:MI-RVD[K:?]M*`VU(K:44MJ2ZVI/;6H-M6JVE7+:ENM
|
||||
MJWVUL#;6RMI92VMKK:V]M;@VU^K:7<MK>ZVO_;7`-M@*VV%+;(NML3VVR#;9
|
||||
M*MMERVR;K;-]MM`VVDK;:4MMJZVUO;;8-MMJVVW+;;NMM_VVX#;<BMMQ2V[+
|
||||
MK;D]M^@VW:K;=<MNVZV[?;?P-M[*VWE+;^NMO;VW^#;?ZMM]RV_[K;_]MP`W
|
||||
MX`K<@4MP"Z[!/;@(-^$JW(7+<!NNPWVX$#?B2MR)2W$KKL6]N!@WXVK<C<MQ
|
||||
M.Z['_;@@-^2*W)%+<DNNR3VY*#?EJMR5RW);KLM]N3`WYLK<F4MS:Z[-O;DX
|
||||
M-^?JW)W+<WNNS_VY0#?H"MVA2W2+KM$]ND@WZ2K=I<MTFZ[3?;I0-^I*W:E+
|
||||
M=:NNU;VZ6#?K:MVMRW6[KM?]NF`W[(K=L4MVRZ[9/;MH-^VJW;7+=MNNVWV[
|
||||
M<#?NRMVY2W?KKMV]NW@W[^K=O<MW^Z[?_;N`-_`*WL%+>`NOX3V\B#?Q*M[%
|
||||
MRW@;K^-]O)`W\DK>R4MY*Z_EO;R8-_-JWLW+>3NOY_V\H#?TBM[12WI+K^D]
|
||||
MO:@W]:K>U<MZ6Z_K?;VP-_;*WME+>VNO[;V]N#?WZM[=RWM[K^_]O<`W^`K?
|
||||
MX4M\BZ_Q/;[(-_DJW^7+?)NO\WV^T#?Z2M_I2WVKK_6]OM@W^VK?[<M]NZ_W
|
||||
M_;[@-_R*W_%+?LNO^3V_Z#?]JM_URW[;K_M]O_`W_LK?^4M_ZZ_]O;_X-__J
|
||||
MW_W+?_NO__V_`#@`"^`!3(`+L`$^P`@X`2O@!<R`&[`#?L`0.`)+X`E,@2NP
|
||||
M!;[`&#@#:^`-S($[L`?^P"`X!(O@$4R"2[`)/L$H.`6KX!7,@ENP"W[!,#@&
|
||||
MR^`93(-KL`V^P3@X!^O@'<R#>[`/_L%`.`@+X2%,A(NP$3["2#@)*^$ES(2;
|
||||
ML!-^PE`X"DOA*4R%J[`5OL)8.`MKX2W,A;NP%_["8#@,B^$Q3(;+L!D^PV@X
|
||||
M#:OA-<R&V[`;?L-P.`[+X3E,A^NP';[#>#@/Z^$]S(?[L!_^PX`X$`OB04R(
|
||||
M"[$A/L2(.!$KXD7,B!NQ(W[$D#@22^))3(DKL26^Q)@X$VOB3<R).[$G_L2@
|
||||
M.!2+XE%,BDNQ*3[%J#@5J^)5S(I;L2M^Q;`X%LOB64R+:[$MOL6X.!?KXO`+
|
||||
`
|
||||
end
|
||||
@ -0,0 +1,63 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_rockridge_ce.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GC0+06!Z-&!``1`XH$((`"`!059,$%"%0PD`@`7%%2C
|
||||
MB@*I:$0``B10(@D"!'3B@1T6:>212":IY)),-NGDDU!&*>645%9I991-+)'$
|
||||
M%$\8,04(6SX!0@XVV`##"TAX"8(123!1Q!193$%%$1H*446;1!0A!0@F@'!A
|
||||
M$4,\(<6#`K8@Q0M$6$&H%$4$086@(*`P1`H@Q)!##C.`4(0+63Q1A1-'$!&$
|
||||
MFY%.6NFE-X"@A`M0-"H%ETZ\L.H40R#1)A-)@'KEKKSN*@.!.<10H`PQR%##
|
||||
MKV;"0,*O,`0[;+''PI`L"016:^VU!`+`K+/%0HLL@200V>NXY)9K[KGHIJON
|
||||
MNNRVZ^Z2_\6[V#\"$FB@O/CFJ^^^_/9;799)@-#$&VZ`\,08=%0J@\(Z'*N#
|
||||
MM"!LJX`,+A18<0QAV)"IH2"T4$<:9%3:\1D@1PR""RB_D,8<;_CK\LLPQRSS
|
||||
MS&G=0L^!-0HIT```9"#0@40D(07-1!=M]-%()ZWTTDPW[?334+]&8D`UDLBS
|
||||
M0#X'$/3047?M]==@ARWVV&27;?;9:"<-"8TV`H!C0#KRZ&,`0.I<XH%30'%`
|
||||
M`+Z\`X`44A000"!08,%"`.T$,5`0[5P]T`!3_QPD00+D/-`%5!BA00`.[-CC
|
||||
MCVTHP``#-!A`0NBCET["$$5P$(`&!<%N4#L%M>,&VP3=.%#<G],]^9`!`"XX
|
||||
MX88CKKA`C#N^<^1"3CY0Y39FOGGG<H,N.NFFHXX]"0"0`\`&!6V@SP,#/:"/
|
||||
MYW-S;W<`"P3AOOO5NK!##,('D(@335QB8AC\]^___P`,H``'2,`"&O"`"$R@
|
||||
M`@G(.M=AH"`/-`C7!B(%[W6@(!T87_G.5SVZ_4Q([7M?$.PE/_H%SG[XTU\`
|
||||
M%LC"%KKPA3",(0`;&(`(#@0#$Q2(%*)0D"AX[P,%^8`&!6(^]/WH@R4*H0C=
|
||||
M5\+ZW2]_^Y.A%*=(Q2HFD(8V%`@&2%$04D"A(%#`0\\*XK.WN0U!':Q;B80T
|
||||
M@*TY$7\(.!`9TB"'PATN<8MKA_,$(@#FE6B/`1&`SPB2`>EQSHAT0^3IKJ<Z
|
||||
M`(`#`/#XAR0G"8^#*!*)`3@`G)H0@R:>L!'X2\"!YI"'-L3`CH@+Q4!"T0X_
|
||||
MFJ@@/"J(`"(Y24G"8PI,$(.)`K`%*_KREV'`(@3I41!Z=*$@77CD.VHI2;\9
|
||||
MY)+KTV06FD"Q^=4/E$T0)0!(V089H+(=JA0(*UWI2D`"0`#+9.8[<*E+$_42
|
||||
MF/"4HC`)@L/(!<\+!?'"(]W!S'^XPY)IQ*0TFS`#3PH.F]KDY@R^&<Z`C!.6
|
||||
MY90E/YGI#G;N\IWQS*@+YWE#6-@3%E\H2$C3%A'\,>!``40E*0(QD$"0@IRP
|
||||
M-*<`P$>0#1B2>KTC@2*UISK\+0"E_U,I2P7B4I@2)):4NR!!.G!31>Z4D:8#
|
||||
M`/X4`-3^";6E+X5H3&4)1()\H*EI?&KJ3(?+(9"(!QJ5(5@'X",!+'*L;]T>
|
||||
M`'!)!!+U(*UJU=PA`\#6<\95=3PEJYM(Y`.\YG5Z.^JK6P/[UZB2]+&0C:QD
|
||||
M$W*[00ZDC+M#8TY_)Z0#U8]X=SQ>0!@GTXA2SK)8`VM.&<M8`-S.<@+178XT
|
||||
MFS[.WBUX)P2M\?*HO(!`;JN4@RW55)L^UD)5?9--KG*7RURQZ:F5"J#"(7";
|
||||
M!"A\P5+!<A02B@`"#`UA"=U-`A&.P-U<S4D*M0H"J+@+!0P]*E!,`$%[GV`%
|
||||
M\;X)!%.H`A2@("@JK`E2_)U"$K"PIC9Q%TYRHA-^Z:1>*B1A"'ES4Q"FP-U`
|
||||
M.8$*01B"?X-&*_E600BXFL)V]V0$2.4-4$E@TQ`<E80G.`&_GD+OIB!$8?9^
|
||||
M.,0C!E.>+ISB).@)3"]N;Q*:$`0I9`$$5G@"$ZK0!.[FB592J.ZC2`PI"V-8
|
||||
MPT`NL12([&`7NZ"Y8`ZSF,>L'S24@0UL>$.E:C`#!9#YS7".LYSG3.<ZV_G.
|
||||
M>,[S>\R,9C7'X%ANUK.@!TWH0AOZT(A.M*(7S6BO\#G-:XY!H!M-Z4I;^M*8
|
||||
MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
|
||||
MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
|
||||
MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
(>(F8F(F:^!,`
|
||||
`
|
||||
end
|
||||
208
lib/libarchive/test/test_read_format_iso_rockridge_new.iso.Z.uu
Normal file
208
lib/libarchive/test/test_read_format_iso_rockridge_new.iso.Z.uu
Normal file
@ -0,0 +1,208 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_rockridge_new.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GA0#Q@,A$$/'QT(0``F'H@``@!84)`%$R14P4`B`'!!
|
||||
M03>R*!"+1@0@0`(GDB!`0"D>V.&12":IY)),-NGDDU!&*>645%9IY9583MG$
|
||||
M$DE,\8014X#0Y1,@Y&"##3"\@`28(!B1!!-%3)'%%%04H:$05;Q)1!%2@&`"
|
||||
M"!<6,<034CPH8`M2O$"$%89*44005!`*`@I#I`!"##GD,`,(1;B0Q1-5.'$$
|
||||
M$4'`.6FEEV9Z`PA*N`#%HU)XZ<0+K4XQ!!)O,I&$J%GVZFNO,A"8`PPYR'"#
|
||||
M##/$,,.R!)(0++'$&HNLLLS"0`*!V&:K+8$`/#MLL<<FN^P,S1KYZ[GHIJON
|
||||
MNNRVZ^Z[\,8K;Y/_U;O8/P(2:*"]_/;K[[\`!US=EDF`,$4=;AA<!AP@&-OP
|
||||
M##HHJ\.R#0NK@`PN%)AQ#&'8L"FB(+101QID7!KR&20W#((+++^0QAQO""SS
|
||||
MS#37;//-:=URQ8$W$BG0``"$Z#,124B!\]%()ZWTTDPW[?334$<M]=2OF1C0
|
||||
MC28"+5"(`1!M--5@ARWVV&27;?;9:*>M]MI,0V(CC@#H&!"//@(9@)`^GWC@
|
||||
M%%`<$(`O[P`@A10%!!`(%%BP$$`[00P41#M:#S2`U0+Y6)``/0]T`15&:!"`
|
||||
M`SW^&&0;"6QP00,AD$"ZZ:B3,$01'`2004&S&]1.0>VX\39!.0Y$M^AW#WDB
|
||||
MD2@.7OCAB2_>N$"/1_XSY40*/Q#F.'+N.>AUCU[ZZ:FOSCT)`.`1=$$ARATW
|
||||
M@MD'GW<``WAM?`").-$$`@>2D88<B"O.N./M2"^0`-`[D?\"(@"AB<AZGPN=
|
||||
MW4B@0.VQ+G4`X`,`-%`0#5`A#+P(""_"P+GT@6]]!W`3G%RP@QB\+WY-2,"!
|
||||
MS)`&-I0A?P$@12`&$@A2#!```"R(Y0@B``H2Q(*=2Z`'&W@W[[6.$!.LX`4S
|
||||
M"(`-=A!X'QS>B1:`A"`42E=.6`()34@X^,FO`0="0QCD0`8VI,$-:X"A#&EH
|
||||
MP\L%<(?3\^%`@'@](C+0@T9,G2,``(]_^/&/\#B('2M')`7(J0E8U&()!=?%
|
||||
M1LB/`0>:0Q[:8$8TPK`=H1A(*-KQQC?>4`!]_*,?X3$%)BS`1`1@H0L1B+T!
|
||||
M`$D`=W0E#E6WO=9)`@#O$*4?`V<0(X(@BBE:P"$3B;$2OL^130`C`"1)R3.N
|
||||
M00:7S*1`-ME)'7XRE[I\1RD=H**`#(`.;8!#0%B91UH^T)S?HP0`W*'+?[CC
|
||||
M(*3#@`,*<`)@$DF864#DKI8P@RT>\XN1G&0EUS"#:&J2DSKTY.78J4MWE!("
|
||||
MW03`-\-)`(&0LY;=PR@Z6V<)`+2CG;?K92U_2<@I#G.?-/!G(P&Z3($ZDP8&
|
||||
MG29""8(B:U[NH[IL1RDE<*"*#JFB$@6G.`%PT7.6LYP=94<[V2%(#Y8T`/C4
|
||||
M9Q9KH-+"(5.9S!QH#6(:$&HFU*8\5*HNV5'*"!SHAJEL81E8V2-9PK*MK]PH
|
||||
M!#NZCG:N`YX)D"<][6G2?";2!E4-P%4#VDPTVH"K`/`J317*P[KJ<AT[C>A$
|
||||
MAPI4H@;1`4?5:#G9AA[=&7!KY]L1^J`HO"(Q\GB77%Y`'O=)QD[OLP'!`%OQ
|
||||
MJ%F-`D!WF1-([T1KQ](2+P#O0Y[^5`N`YA5D<F"=7FZO-ELH9O:<G(VN=*=+
|
||||
MW>HVA$^<5``5#@%<*20!"E_`5`YB`"DD%`$$&!K"$M";!"(<X;R[JI,4;A4$
|
||||
M49T7"AB*U*"8``+\/L$*[8V3P:H`!2@0B@IMDI2!IY`$++3I3>>5$YWL9#`[
|
||||
MU9<*21@"W^`4A"F<=U!.H$(0AH!@HMFJOU40@JZF8-X^&4%2?!-4$MPT!$@E
|
||||
MX0E.,!BHYMLI"'GXOBE><8O%M*<0SS@)?!)3CO&;A"98,0L@L,(3F%"%)IQW
|
||||
M3[;R+A0BY6))@5C$)%;RBZ7@9`SCV`763;.:U\SFFZ&A#&Q@PQL4T.8ZV_G.
|
||||
M>,ZSGO?,YS[[^<^`#K2@!TWH0AOZT(A.M*(7S>A&._K1D(ZTI"=-Z4I;^M*8
|
||||
MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
|
||||
MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
|
||||
MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
M>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN(JLV(JN^(JP&(NR.(NT
|
||||
M6(NV>(NXF(NZN(N\V(N^^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
|
||||
MV9(N^9(P&9,R.9,T69,V>9,XF9,ZN9,\V9,^^9-`&91".91$691&>91(F91*
|
||||
MN91,V91.^910&952.9546956>958F95:N95<V95>^95@&99B.99D699F>99H
|
||||
MF99JN99LV99N^99P&9=R.9=T69=V>9=XF9=ZN9=\V9=^^9>`&9B".9B$69B&
|
||||
M>9B(F9B*N9B,V9B.^9B0&9F2.9F469F6>9F8F9F:N9F<V9F>^9F@&9JB.9JD
|
||||
M69JF>9JHF9JJN9JLV9JN^9JP&9NR.9NT69NV>9NXF9NZN9N\V9N^^9O`&9S"
|
||||
M.9S$69S&>9S(F9S*N9S,V9S.^9S0&9W2.9W469W6>9W8F9W:N9W<V9W>^9W@
|
||||
M&9[B.9[D69[F>9[HF9[JN9[LV9[N^9[P&9_R.9_T69_V>9_XF9_ZN9_\V9_^
|
||||
M^9\`&J`".J`$6J`&>J`(FJ`*NJ`,VJ`.^J`0&J$2.J$46J$6>J$8FJ$:NJ$<
|
||||
MVJ$>^J$@&J(B.J(D6J(F>J(HFJ(JNJ(LVJ(N^J(P&J,R.J,T6J,V>J,XFJ,Z
|
||||
MNJ,\VJ,^^J-`&J1".J1$6J1&>J1(FJ1*NJ1,VJ1.^J10&J52.J546J56>J58
|
||||
MFJ5:NJ5<VJ5>^J5@&J9B.J9D6J9F>J9HFJ9JNJ9LVJ9N^J9P&J=R.J=T6J=V
|
||||
M>J=XFJ=ZNJ=\VJ=^^J>`&JB".JB$6JB&>JB(FJB*NJB,VJB.^JB0&JF2.JF4
|
||||
M6JF6>JF8FJF:NJF<VJF>^JF@&JJB.JJD6JJF>JJHFJJJNJJLVJJN^JJP&JNR
|
||||
M.JNT6JNV>JNXFJNZNJN\VJN^^JO`&JS".JS$6JS&>JS(FJS*NJS,VJS.^JS0
|
||||
M&JW2.JW46JW6>JW8FJW:NJW<VJW>^JW@&J[B.J[D6J[F>J[HFJ[JNJ[LVJ[N
|
||||
M^J[P&J_R.J_T6J_V>J_XFJ_ZNJ_\VJ_^^J\`&[`".[`$6[`&>[`(F[`*N[`,
|
||||
MV[`.^[`0&[$2.[$46[$6>[$8F[$:N[$<V[$>^[$@&[(B.[(D6[(F>[(HF[(J
|
||||
MN[(LV[(N^[(P&[,R.[,T6[,V>[,XF[,ZN[,\V[,^^[-`&[1".[1$6[1&>[1(
|
||||
MF[1*N[1,V[1.^[10&[52.[546[56>[58F[5:N[5<V[5>^[5@&[9B.[9D6[9F
|
||||
M>[9HF[9JN[9LV[9N^[9P&[=R.[=T6[=V>[=XF[=ZN[=\V[=^^[>`&[B".[B$
|
||||
M6[B&>[B(F[B*N[B,V[B.^[B0&[F2.[F46[F6>[F8F[F:N[F<V[F>^[F@&[JB
|
||||
M.[JD6[JF>[JHF[JJN[JLV[JN^[JP&[NR.[NT6[NV>[NXF[NZN[N\V[N^^[O`
|
||||
M&[S".[S$6[S&>[S(F[S*N[S,V[S.^[S0&[W2.[W46[W6>[W8F[W:N[W<V[W>
|
||||
M^[W@&[[B.[[D6[[F>[[HF[[JN[[LV[[N^[[P&[_R.[_T6[_V>[_XF[_ZN[_\
|
||||
MV[_^^[\`',`"/,`$7,`&?,`(G,`*O,`,W,`._,`0',$2/,$47,$6?,$8G,$:
|
||||
MO,$<W,$>_,$@',(B/,(D7,(F?,(HG,(JO,(LW,(N_,(P',,R/,,T7,,V?,,X
|
||||
MG,,ZO,,\W,,^_,-`',1"/,1$7,1&?,1(G,1*O,1,W,1._,10',52/,547,56
|
||||
M?,58G,5:O,5<W,5>_,5@',9B/,9D7,9F?,9HG,9JO,9LW,9N_,9P',=R/,=T
|
||||
M7,=V?,=XG,=ZO,=\W,=^_,>`',B"/,B$7,B&?,B(G,B*O,B,W,B._,B0',F2
|
||||
M/,F47,F6?,F8G,F:O,F<W,F>_,F@',JB/,JD7,JF?,JHG,JJO,JLW,JN_,JP
|
||||
M',NR/,NT7,NV?,NXG,NZO,N\W,N^_,O`',S"/,S$7,S&?,S(G,S*O,S,W,S.
|
||||
M_,S0',W2/,W47,W6?,W8G,W:O,W<W,W>_,W@',[B/,[D7,[F?,[HG,[JO,[L
|
||||
MW,[N_,[P',_R/,_T7,_V?,_XG,_ZO,_\W,_^_,\`'=`"/=`$7=`&?=`(G=`*
|
||||
MO=`,W=`._=`0'=$2/=$47=$6?=$8G=$:O=$<W=$>_=$@'=(B/=(D7=(F?=(H
|
||||
MG=(JO=(LW=(N_=(P'=,R/=,T7=,V?=,XG=,ZO=,\W=,^_=-`'=1"/=1$7=1&
|
||||
M?=1(G=1*O=1,W=1._=10'=52/=547=56?=58G=5:O=5<W=5>_=5@'=9B/=9D
|
||||
M7=9F?=9HG=9JO=9LW=9N_=9P'==R/==T7==V?==XG==ZO==\W==^_=>`'=B"
|
||||
M/=B$7=B&?=B(G=B*O=B,W=B._=B0'=F2/=F47=F6?=F8G=F:O=F<W=F>_=F@
|
||||
M'=JB/=JD7=JF?=JHG=JJO=JLW=JN_=JP'=NR/=NT7=NV?=NXG=NZO=N\W=N^
|
||||
M_=O`'=S"/=S$7=S&?=S(G=S*O=S,W=S._=S0'=W2/=W47=W6?=W8G=W:O=W<
|
||||
MW=W>_=W@'=[B/=[D7=[F?=[HG=[JO=[LW=[N_=[P'=_R/=_T7=_V?=_XG=_Z
|
||||
MO=_\W=_^_=\`'N`"/N`$7N`&?N`(GN`*ON`,WN`._N`0'N$2/N$47N$6?N$8
|
||||
MGN$:ON$<WN$>_N$@'N(B/N(D7N(F?N(HGN(JON(LWN(N_N(P'N,R/N,T7N,V
|
||||
M?N,XGN,ZON,\WN,^_N-`'N1"/N1$7N1&?N1(GN1*ON1,WN1._N10'N52/N54
|
||||
M7N56?N58GN5:ON5<WN5>_N5@'N9B/N9D7N9F?N9HGN9JON9LWN9N_N9P'N=R
|
||||
M/N=T7N=V?N=XGN=ZON=\WN=^_N>`'NB"/NB$7NB&?NB(GNB*ONB,WNB._NB0
|
||||
M'NF2/NF47NF6?NF8GNF:ONF<WNF>_NF@'NJB/NJD7NJF?NJHGNJJONJLWNJN
|
||||
M_NJP'NNR/NNT7NNV?NNXGNNZONN\WNN^_NO`'NS"/NS$7NS&?NS(GNS*ONS,
|
||||
MWNS._NS0'NW2/NW47NW6?NW8GNW:ONW<WNW>_NW@'N[B/N[D7N[F?N[HGN[J
|
||||
MON[LWN[N_N[P'N_R/N_T7N_V?N_XGN_ZON_\WN_^_N\`'_`"/_`$7_`&?_`(
|
||||
MG_`*O_`,W_`.__`0'_$2/_$47_$6?_$8G_$:O_$<W_$>__$@'_(B/_(D7_(F
|
||||
M?_(HG_(JO_(LW_(N__(P'_,R/_,T7_,V?_,XG_,ZO_,\W_,^__-`'_1"/_1$
|
||||
M7_1&?_1(G_1*O_1,W_1.__10'_52/_547_56?_58G_5:O_5<W_5>__5@'_9B
|
||||
M/_9D7_9F?_9HG_9JO_9LW_9N__9P'_=R/_=T7_=V?_=XG_=ZO_=\W_=^__>`
|
||||
M'_B"/_B$7_B&?_B(G_B*O_B,W_B.__B0'_F2/_F47_F6?_F8G_F:O_F<W_F>
|
||||
M__F@'_JB/_JD7_JF?_JHG_JJO_JLW_JN__JP'_NR/_NT7_NV?_NXG_NZO_N\
|
||||
MW_N^__O`'_S"/_S$7_S&?_S(G_S*O_S,W_S.__S0'_W2/_W47_W6?_W8G_W:
|
||||
MO_W<W_W>__W@'_[B/_[D7_[F?_[HG_[JO_[LW_[N__[P'__R/__T7__V?__X
|
||||
MG__ZO__\W__^__\`,``*P`%(``N@`3R`"#`!*L`%R``;H`-\@!`P`DK`"4@!
|
||||
M*Z`%O(`8,`-JP`W(`3N@!_R`(#`$BL`12`)+H`D\@2@P!:K`%<@"6Z`+?($P
|
||||
M,`;*P!E(`VN@#;R!.#`'ZL`=R`-[H`_\@4`P"`K!(4@$BZ`1/()(,`DJP27(
|
||||
M!)N@$WR"4#`*2L$I2`6KH!6\@E@P"VK!+<@%NZ`7_()@,`R*P3%(!LN@&3R#
|
||||
M:#`-JL$UR`;;H!M\@W`P#LK!.4@'ZZ`=O(-X,`_JP3W(!_N@'_R#@#`0"L)!
|
||||
M2`@+H2$\A(@P$2K"1<@(&Z$C?(20,!)*PDE("2NA);R$F#`3:L)-R`D[H2?\
|
||||
MA*`P%(K"44@*2Z$I/(6H,!6JPE7("ENA*WR%L#`6RL)92`MKH2V\A;@P%^K"
|
||||
M7<@+>Z$O_(7`,!@*PV%(#(NA,3R&R#`9*L-ER`R;H3-\AM`P&DK#:4@-JZ$U
|
||||
MO(;8,!MJPVW(#;NA-_R&X#`<BL-Q2`[+H3D\A^@P':K#=<@.VZ$[?(?P,![*
|
||||
MPWE(#^NA/;R'^#`?ZL-]R`_[H3_\AP`Q(`K$@4@0"Z)!/(@(,2$JQ(7($!NB
|
||||
M0WR($#$B2L2)2!$KHD6\B!@Q(VK$C<@1.Z)'_(@@,22*Q)%($DNB23R)*#$E
|
||||
MJL25R!);HDM\B3`Q)LK$F4@3:Z)-O(DX,2?JQ)W($WNB3_R)0#$H"L6A2!2+
|
||||
MHE$\BD@Q*2K%I<@4FZ)3?(I0,2I*Q:E(%:NB5;R*6#$K:L6MR!6[HE?\BF`Q
|
||||
M+(K%L4@6RZ)9/(MH,2VJQ;7(%MNB6WR+<#$NRL6Y2!?KHEV\BW@Q+^K%O<@7
|
||||
M^Z)?_(N`,3`*QL%(&`NC83R,B#$Q*L;%R!@;HV-\C)`Q,DK&R4@9*Z-EO(R8
|
||||
M,3-JQLW(&3NC9_R,H#$TBL;12!I+HVD\C:@Q-:K&U<@:6Z-K?(VP,3;*QME(
|
||||
M&VNC;;R-N#$WZL;=R!M[HV_\C<`Q.`K'X4@<BZ-Q/([(,3DJQ^7(')NC<WR.
|
||||
MT#$Z2L?I2!VKHW6\CM@Q.VK'[<@=NZ-W_([@,3R*Q_%('LNC>3R/Z#$]JL?U
|
||||
MR![;HWM\C_`Q/LK'^4@?ZZ-]O(_X,3_JQ_W('_NC?_R/`#)`"L@!22`+I($\
|
||||
MD`@R02K(!<D@&Z2#?)`0,D)*R`E)(2NDA;R0&#)#:L@-R2$[I(?\D"`R1(K(
|
||||
M$4DB2Z2)/)$H,D6JR!7)(ENDBWR1,#)&RL@922-KI(V\D3@R1^K('<DC>Z2/
|
||||
M_)%`,D@*R2%))(NDD3R22#))*LDER22;I)-\DE`R2DK)*4DEJZ25O))8,DMJ
|
||||
MR2W));NDE_R28#),BLDQ22;+I)D\DV@R3:K)-<DFVZ2;?)-P,D[*R3E))^ND
|
||||
MG;R3>#)/ZLD]R2?[I)_\DX`R4`K*04DH"Z6A/)2(,E$JRD7)*!NEHWR4D#)2
|
||||
M2LI)22DKI:6\E)@R4VK*3<DI.Z6G_)2@,E2*RE%)*DNEJ3R5J#)5JLI5R2I;
|
||||
MI:M\E;`R5LK*64DK:Z6MO)6X,E?JREW)*WNEK_R5P#)8"LMA22R+I;$\EL@R
|
||||
M62K+9<DLFZ6S?);0,EI*RVE)+:NEM;R6V#);:LMMR2V[I;?\EN`R7(K+<4DN
|
||||
MRZ6Y/)?H,EVJRW7)+MNENWR7\#)>RLMY22_KI;V\E_@R7^K+?<DO^Z6__)<`
|
||||
M,V`*S(%),`NFP3R8"#-A*LR%R3`;IL-\F!`S8DK,B4DQ*Z;%O)@8,V-JS(W)
|
||||
M,3NFQ_R8(#-DBLR123)+ILD\F2@S9:K,E<DR6Z;+?)DP,V;*S)E),VNFS;R9
|
||||
M.#-GZLR=R3-[IL_\F4`S:`K-H4DTBZ;1/)I(,VDJS:7)-)NFTWR:4#-J2LVI
|
||||
M236KIM6\FE@S:VK-K<DUNZ;7_)I@,VR*S;%)-LNFV3R;:#-MJLVUR3;;IMM\
|
||||
MFW`S;LK-N4DWZZ;=O)MX,V_JS;W)-_NFW_R;@#-P"L[!23@+I^$\G(@S<2K.
|
||||
MQ<DX&Z?C?)R0,W)*SLE).2NGY;R<F#-S:L[-R3D[I^?\G*`S=(K.T4DZ2Z?I
|
||||
M/)VH,W6JSM7).ENGZWR=L#-VRL[923MKI^V\G;@S=^K.W<D[>Z?O_)W`,W@*
|
||||
MS^%)/(NG\3R>R#-Y*L_ER3R;I_-\GM`S>DK/Z4D]JZ?UO)[8,WMJS^W)/;NG
|
||||
M]_R>X#-\BL_Q23[+I_D\G^@S?:K/]<D^VZ?[?)_P,W[*S_E)/^NG_;R?^#-_
|
||||
MZL_]R3_[I__\GP`T@`K0`4I`"Z@!/:`(-($JT`7*0!NH`WV@$#2"2M`)2D$K
|
||||
MJ`6]H!@T@VK0#<I!.Z@'_:`@-(2*T!%*0DNH"3VA*#2%JM`5RD);J`M]H3`T
|
||||
MALK0&4I#:Z@-O:$X-(?JT!W*0WNH#_VA0#2("M$A2D2+J!$]HD@TB2K1)<I$
|
||||
MFZ@3?:)0-(I*T2E*1:NH%;VB6#2+:M$MRD6[J!?]HF`TC(K1,4I&RZ@9/:-H
|
||||
M-(VJT37*1MNH&WVC<#2.RM$Y2D?KJ!V]HW@TC^K1/<I'^Z@?_:.`-)`*TD%*
|
||||
M2`NI(3VDB#21*M)%RD@;J2-]I)`TDDK224I)*ZDEO:28-)-JTDW*23NI)_VD
|
||||
MH#24BM)12DI+J2D]I:@TE:K25<I*6ZDK?:6P-);*TEE*2VNI+;VEN#27ZM)=
|
||||
MRDM[J2_]I<`TF`K384I,BZDQ/:;(-)DJTV7*3)NI,WVFT#2:2M-I2DVKJ36]
|
||||
MIM@TFVK3;<I-NZDW_:;@-)R*TW%*3LNI.3VGZ#2=JM-URD[;J3M]I_`TGLK3
|
||||
M>4I/ZZD]O:?X-)_JTWW*3_NI/_VG`#6@"M2!2E`+JD$]J`@UH2K4A<I0&ZI#
|
||||
M?:@0-:)*U(E*42NJ1;VHC:M2-RE$[JD?]J"`UI(K4D4I22ZI)/:DH-:6J
|
||||
MU)7*4ENJ2WVI,#6FRM292E-KJDV]J3@UI^K4G<I3>ZI/_:E`-:@*U:%*5(NJ
|
||||
M43VJ2#6I*M6ERE2;JE-]JE`UJDK5J4I5JZI5O:I8-:MJU:W*5;NJ5_VJ8#6L
|
||||
MBM6Q2E;+JED]JV@UK:K5M<I6VZI;?:MP-:[*U;E*5^NJ7;VK>#6OZM6]RE?[
|
||||
MJE_]JX`UL`K6P4I8"ZMA/:R(-;$JUL7*6!NK8WVLD#6R2M;)2EDKJV6]K)@U
|
||||
MLVK6S<I9.ZMG_:R@-;2*UM%*6DNK:3VMJ#6UJM;5REI;JVM]K;`UMLK6V4I;
|
||||
M:ZMMO:VX-;?JUMW*6WNK;_VMP#6X"M?A2ER+JW$]KL@UN2K7Y<I<FZMS?:[0
|
||||
M-;I*U^E*7:NK=;VNV#6[:M?MREV[JW?]KN`UO(K7\4I>RZMY/:_H-;VJU_7*
|
||||
M7MNK>WVO\#6^RM?Y2E_KJWV]K_@UO^K7_<I?^ZM__:\`-L`*V`%+8`NL@3VP
|
||||
M"#;!*M@%RV`;K(-]L!`VPDK8"4MA*ZR%O;`8-L-JV`W+83NLA_VP(#;$BM@1
|
||||
M2V)+K(D]L2@VQ:K8%<MB6ZR+?;$P-L;*V!E+8VNLC;VQ.#;'ZM@=RV-[K(_]
|
||||
ML4`VR`K9(4MDBZR1/;)(-LDJV27+9)NLDWVR4#;*2MDI2V6KK)6]LE@VRVK9
|
||||
M+<MENZR7_;)@-LR*V3%+9LNLF3VS:#;-JMDURV;;K)M]LW`VSLK9.4MGZZR=
|
||||
MO;-X-L_JV3W+9_NLG_VS@#;0"MI!2V@+K:$]M(@VT2K:1<MH&ZVC?;20-M)*
|
||||
MVDE+:2NMI;VTF#;3:MI-RVD[K:?]M*`VU(K:44MJ2ZVI/;6H-M6JVE7+:ENM
|
||||
MJWVUL#;6RMI92VMKK:V]M;@VU^K:7<MK>ZVO_;7`-M@*VV%+;(NML3VVR#;9
|
||||
M*MMERVR;K;-]MM`VVDK;:4MMJZVUO;;8-MMJVVW+;;NMM_VVX#;<BMMQ2V[+
|
||||
MK;D]M^@VW:K;=<MNVZV[?;?P-M[*VWE+;^NMO;VW^#;?ZMM]RV_[K;_]MP`W
|
||||
MX`K<@4MP"Z[!/;@(-^$JW(7+<!NNPWVX$#?B2MR)2W$KKL6]N!@WXVK<C<MQ
|
||||
M.Z['_;@@-^2*W)%+<DNNR3VY*#?EJMR5RW);KLM]N3`WYLK<F4MS:Z[-O;DX
|
||||
M-^?JW)W+<WNNS_VY0#?H"MVA2W2+KM$]ND@WZ2K=I<MTFZ[3?;I0-^I*W:E+
|
||||
M=:NNU;VZ6#?K:MVMRW6[KM?]NF`W[(K=L4MVRZ[9/;MH-^VJW;7+=MNNVWV[
|
||||
M<#?NRMVY2W?KKMV]NW@W[^K=O<MW^Z[?_;N`-_`*WL%+>`NOX3V\B#?Q*M[%
|
||||
MRW@;K^-]O)`W\DK>R4MY*Z_EO;R8-_-JWLW+>3NOY_V\H#?TBM[12WI+K^D]
|
||||
MO:@W]:K>U<MZ6Z_K?;VP-_;*WME+>VNO[;V]N#?WZM[=RWM[K^_]O<`W^`K?
|
||||
MX4M\BZ_Q/;[(-_DJW^7+?)NO\WV^T#?Z2M_I2WVKK_6]OM@W^VK?[<M]NZ_W
|
||||
M_;[@-_R*W_%+?LNO^3V_Z#?]JM_URW[;K_M]O_`W_LK?^4M_ZZ_]O;_X-__J
|
||||
MW_W+?_NO__V_`#@`"^`!3(`+L`$^P`@X`2O@!<R`&[`#?L`0.`)+X`E,@2NP
|
||||
M!;[`&#@#:^`-S($[L`?^P"`X!(O@$4R"2[`)/L$H.`6KX!7,@ENP"W[!,#@&
|
||||
MR^`93(-KL`V^P3@X!^O@'<R#>[`/_L%`.`@+X2%,A(NP$3["2#@)*^$ES(2;
|
||||
ML!-^PE`X"DOA*4R%J[`5OL)8.`MKX2W,A;NP%_["8#@,B^$Q3(;+L!D^PV@X
|
||||
M#:OA-<R&V[`;?L-P.`[+X3E,A^NP';[#>#@/Z^$]S(?[L!_^PX`X$`OB04R(
|
||||
M"[$A/L2(.!$KXD7,B!NQ(W[$D#@22^))3(DKL26^Q)@X$VOB3<R).[$G_L2@
|
||||
M.!2+XE%,BDNQ*3[%J#@5J^)5S(I;L2M^Q;`X%LOB64R+:[$MOL6X.!?KXEW,
|
||||
MBWNQ+_[%P#@8"^-A3(R+L3$^QL@X&2OC9<R,F[$S?L;0.!I+XVE,C:NQ-;[&
|
||||
DV#@;:^-MS(V[L3?^QN`X'(OC<4R.R[$Y/L?H.!VKXW7,CKDM
|
||||
`
|
||||
end
|
||||
@ -0,0 +1,304 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_rockridge_rr_moved.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1G@0-2\,]`(U'QT(0``F'H@``@!04A`E$R14P4`B`'!!
|
||||
M03>R*!"+1@0@0`(GDB!`0"D>V.&12":IY)),-NGDDU!&*>645%9IY9583MG$
|
||||
M$DE,\8014X#0Y1,@Y&"##3"\@`28(!B1!!-%3)'%%%04H:$05;Q)1!%2@&`"
|
||||
M"!<6,<034CPH8`M2O$"$%89*44005!`*`@I#I`!"##GD,`,(1;B0Q1-5.'$$
|
||||
M$4'`.6FEEV9Z`PA*N`#%HU)XZ<0+K4XQ!!)O,I&$J%GVZFNO,A"80PP%RA`#
|
||||
M#C/0(`,-!)(0+`S#%GMLLLLV2^"UV&9+(`#/1AN#L<@JRRP,)!CYZ[GHIJON
|
||||
MNNRVZ^Z[\,8K;Y/_U;O8/P(2:*"]_/;K[[\`!US=EDF`T,0;;H#PQ!AT7"K#
|
||||
MI3CHD*P.RX+0K0(RN%"@QC&$8<.FB(+00AUID'&IR&>4;#$(+K3\0AISO"'P
|
||||
MS#37;//-.*>5BR8'WDBD0`0`P(%`!Q*1A!0QL(@!T0!((<4733QA11%$!-V!
|
||||
M0$,:+84,06<@T```:(U#T!X`'?;1,P2M@4`%G"U%#D%_()`!;M/0]@8"'>`V
|
||||
ML0`$#<*.;M<0=`@"*>"V#4'7&-`";M^0\^.01R[YY)17;OGEF&>N^>8PF1C0
|
||||
MC28&+=#0`6B=]$!+!^`TU%)3+7I`5PN@-=<#>3V`V*\#4#8!6J<]T-H%:`WW
|
||||
M0'(;H+7=`^%]@.DP]#W0WPAH+?A`A"N@->(T`K"`UHYS[OWWX(<O_OCDEV_^
|
||||
M^>BG;QDD-N((@(X!\>@CD`$(^?.)!TX!Q0$!^/).TU(H0``"`04LL"``[0C"
|
||||
M0(+0#K`19`">(]J0""(`GPWD`E0P@@8"X(`>_2A(;5```R0@`@R0((0C+"$)
|
||||
MAE`$#@1@!`6!H4':49!VN*%]!,G10.3WP?I-L$BJ"^``"WC`!"ZP@06!8$%\
|
||||
M5)`*XBB#&^S@_$`H0A*:$(56)`$`]""T@@P-?N]#T!1]>+\`\.YH,0"@`!/A
|
||||
MA"8DX$!D2(,<8D!$!"I0(`QTX$"42!`F4G!H!.$`%#GH0?J1H)!43*$)^0``
|
||||
M+1*$!%0(`R\"PHLP9'",CCP1D0[@)CBY8`<Q<-H:V_A&`)@A#6PH0QU)$8B!
|
||||
M!((4$212+$\TP8$((),"@:0&"8E)1-8/BRHT!`"61I"E@9%%P#3A#XF$@-5%
|
||||
M;6I$4&,`DM'&!AQ(#G+X0AO>8(<RD*&.;;AC0(+0!CU^;99^M"4Q43=(!R3S
|
||||
MA%54X3L=18!9JN^>^,QG<VZX3H$8<X<`>.<R\2=-`AHP`.%<8#F3B,Y:8JV?
|
||||
M`<%`.]])T7B:$``WM*!`=`@X7]I/D_@+H@`-6D1Q`H"!N0M(/9?HT(`X,8?M
|
||||
M]&A%%:E%/P#`:P3QVC$#:M&/INB,4L"!-*GI1CC*$0=U-"(>D?C`AC81I[6+
|
||||
M:2\Q.<\BK%2?6,VJ5K?ZFAM"52`Z!:A'!XJB@B;5I'ED*$N?6I`,2+6'\*3I
|
||||
M.[<XS(+\LZ.8)"N*1!F`4)SUB.8,"!\'DLZ'VO6MAIQI%J'`!`8$0''9X^+:
|
||||
M"+*VG8ZUC$#-@3396%0`Q%$..?CK4@,+@,%*L(F3_1UB@R33GG+UM;"-K6P?
|
||||
M<\/4"J2R8LUK&0_$5Y+:$;!J[6-+`2``VP9$`ZO]94_GZM6VAA&O<-6K2(=X
|
||||
M4*6.DZE[="H%OQH0M^Y2BG!5K`H!P$B\$01OEM4M2`,0/#3"@*^<58!1YP@#
|
||||
MT5YWN`+0KBW-F[SD'I*JKIVM@`=,X`(#YH;\%0AZ<QO=W9JUNFAM!W[UB[4$
|
||||
M!V0#_A7O16M;$-Q"UY#2[:U]3XK=<ZZ5@L8%`'*_VUJYNI:1L=#H!6(1R4D"
|
||||
MH)*7A"O33K2\(A0!"I\,I1`Y6THR+`@.JVRE0%Z)3@J[-,87I#&+IQK>`!OX
|
||||
MREC.LI;+<D-`#N2+#`:Q@T4,8>`V]<2V]/+H,KQ<UV;4?>EM\'KW*D3?6I?$
|
||||
M*>V;DXFKT<^QV<4TI>O5"'*U.(MYO4"5P69).5\9C#BM9Q9N$P<]D`[XM\59
|
||||
MW+*F-\WI3D/EAI062*'#'"2]/KBD9LXNFK$6:MC].8O,[6(@GQL_,<H9B&1&
|
||||
M]6B#2UC\JCD@@IQRE0&=:2Z6C2!E,W2I,=N[17?VLS-X=(D%NV<!''L@'K@T
|
||||
M@`/MZ6Y[^]O@MLD-KRV09).:C',^]6]W'>E>-Y'<`<FVL!/;YD"#NB"C_O"R
|
||||
MYSQ=.T>8M*8E$GY;#0!+SSN1L'8M%^5&$+DI&]T_/9ZSBRQ'&D@;X-5F./&T
|
||||
M/>Q,A_OC(`^YR#MR0XT+Q.'G]JDLU7UG2*M:TA0T>4`^\&IYNEEW!3&WOB$N
|
||||
MRWY?G->GI2"\=5?S*RH<`'\C"/123E:@UF#B\ZW!S]L==%LF_7D<IS>W1\[U
|
||||
MKGO]ZP.YX=4%LO2=JYR@N5[W=3&^:I>./2`@*'I<,UWR@J#<["&N\]1?[NZ8
|
||||
MVUWN<^4BX0A"N(>?W8S7@[IGY6B#O9L8YK8<//6RCO#Q@OWRF,]\IV\H>8$4
|
||||
MGNECUGN9V<WWJF.M\P$)`>!O_G:DTSJ,E^5WVEL^[=)6N_5Q/[ARB3U>+D)6
|
||||
M(#4R?-.YI_C/WL#QU&X[<7\?$!%0?O<>U[STIT]]V-Z0^0`(/NC3/?M_`UW@
|
||||
M3<2^\W4_=YO;&P"H1__K>7AH7(M>UVO_/BV;F'[5DU_#6A0F//[!__[#XR`>
|
||||
MM6.(=S1"Q5>9P&B+)P=(-7KQ1W7@1T'[UW_\!P_/5WXF-`2-%0#<=5/5UX$>
|
||||
M^(&:PR?M$``*0`6'$$1)``5?@"G#`BE(4`0@@"%#L`0QF`1$<`0PN"MU(@6W
|
||||
M$@2B`H-0@"&1,BA,``)!*#4V&"<@,`55``500"A4T":2\H13D`18T"9O`H-R
|
||||
M0B=VLH1VXH-4D`1#H#]P$@13`(.#X@14$`1#$(5&8RM&6`5"H"M3\()]8@22
|
||||
MHC^"D@1N,@20D@1/X`1+""H\V"D0<H9`*(=T:(=BLB=JR(=)P"=B(HA!F`1-
|
||||
M$`12D`4@8`5/P`15T`0PN">V(@4I&"EW*"EIN(9M.(EX*`67&(:!Z`(@.(NT
|
||||
M6(NVF!%H4`9LP`9O8#BW^(O`&(S".(S$6(S&>(S(F(S*N(S,V(S.^(S0&(W2
|
||||
M.(W46(W6>(W8F(W:N(W<V(W>^(W@&([B.([D6([F>([HF([JN([LV([N^([P
|
||||
M&(_R.(_T6(_V>(_XF(_ZN(_\V(_^^(\`&9`".9`$69`&>9`(F9`*N9`,V9`.
|
||||
M^9`0&9$2.9$469$6>9$8F9$:N9$<V9$>^9$@&9(B.9(D69(F>9(HF9(JN9(L
|
||||
MV9(N^9(P&9,R.9,T69,V>9,XF9,ZN9,\V9,^^9-`&91".91$691&>91(F91*
|
||||
MN91,V91.^910&952.9546956>958F95:N95<V95>^95@&99B.99D699F>99H
|
||||
MF99JN99LV99N^99P&9=R.9=T69=V>9=XF9=ZN9=\V9=^^9>`&9B".9B$69B&
|
||||
M>9B(F9B*N9B,V9B.^9B0&9F2.9F469F6>9F8F9F:N9F<V9F>^9F@&9JB.9JD
|
||||
M69JF>9JHF9JJN9JLV9JN^9JP&9NR.9NT69NV>9NXF9NZN9N\V9N^^9O`&9S"
|
||||
M.9S$69S&>9S(F9S*N9S,V9S.^9S0&9W2.9W469W6>9W8F9W:N9W<V9W>^9W@
|
||||
M&9[B.9[D69[F>9[HF9[JN9[LV9[N^9[P&9_R.9_T69_V>9_XF9_ZN9_\V9_^
|
||||
M^9\`&J`".J`$6J`&>J`(FJ`*NJ`,VJ`.^J`0&J$2.J$46J$6>J$8FJ$:NJ$<
|
||||
MVJ$>^J$@&J(B.J(D6J(F>J(HFJ(JNJ(LVJ(N^J(P&J,R.J,T6J,V>J,XFJ,Z
|
||||
MNJ,\VJ,^^J-`&J1".J1$6J1&>J1(FJ1*NJ1,VJ1.^J10&J52.J546J56>J58
|
||||
MFJ5:NJ5<VJ5>^J5@&J9B.J9D6J9F>J9HFJ9JNJ9LVJ9N^J9P&J=R.J=T6J=V
|
||||
M>J=XFJ=ZNJ=\VJ=^^J>`&JB".JB$6JB&>JB(FJB*NJB,VJB.^JB0&JF2.JF4
|
||||
M6JF6>JF8FJF:NJF<VJF>^JF@&JJB.JJD6JJF>JJHFJJJNJJLVJJN^JJP&JNR
|
||||
M.JNT6JNV>JNXFJNZNJN\VJN^^JO`&JS".JS$6JS&>JS(FJS*NJS,VJS.^JS0
|
||||
M&JW2.JW46JW6>JW8FJW:NJW<VJW>^JW@&J[B.J[D6J[F>J[HFJ[JNJ[LVJ[N
|
||||
M^J[P&J_R.J_T6J_V>J_XFJ_ZNJ_\VJ_^^J\`&[`".[`$6[`&>[`(F[`*N[`,
|
||||
MV[`.^[`0&[$2.[$46[$6>[$8F[$:N[$<V[$>^[$@&[(B.[(D6[(F>[(HF[(J
|
||||
MN[(LV[(N^[(P&[,R.[,T6[,V>[,XF[,ZN[,\V[,^^[-`&[1".[1$6[1&>[1(
|
||||
MF[1*N[1,V[1.^[10&[52.[546[56>[58F[5:N[5<V[5>^[5@&[9B.[9D6[9F
|
||||
M>[9HF[9JN[9LV[9N^[9P&[=R.[=T6[=V>[=XF[=ZN[=\V[=^^[>`&[B".[B$
|
||||
M6[B&>[B(F[B*N[B,V[B.^[B0&[F2.[F46[F6>[F8F[F:N[F<V[F>^[F@&[JB
|
||||
M.[JD6[JF>[JHF[JJN[JLV[JN^[JP&[NR.[NT6[NV>[NXF[NZN[N\V[N^^[O`
|
||||
M&[S".[S$6[S&>[S(F[S*N[S,V[S.^[S0&[W2.[W46[W6>[W8F[W:N[W<V[W>
|
||||
M^[W@&[[B.[[D6[[F>[[HF[[JN[[LV[[N^[[P&[_R.[_T6[_V>[_XF[_ZN[_\
|
||||
MV[_^^[\`',`"/,`$7,`&?,`(G,`*O,`,W,`._,`0',$2/,$47,$6?,$8G,$:
|
||||
MO,$<W,$>_,$@',(B/,(D7,(F?,(HG,(JO,(LW,(N_,(P',,R/,,T7,,V?,,X
|
||||
MG,,ZO,,\W,,^_,-`',1"/,1$7,1&?,1(G,1*O,1,W,1._,10',52/,547,56
|
||||
M?,58G,5:O,5<W,5>_,5@',9B/,9D7,9F?,9HG,9JO,9LW,9N_,9P',=R/,=T
|
||||
M7,=V?,=XG,=ZO,=\W,=^_,>`',B"/,B$7,B&?,B(G,B*O,B,W,B._,B0',F2
|
||||
M/,F47,F6?,F8G,F:O,F<W,F>_,F@',JB/,JD7,JF?,JHG,JJO,JLW,JN_,JP
|
||||
M',NR/,NT7,NV?,NXG,NZO,N\W,N^_,O`',S"/,S$7,S&?,S(G,S*O,S,W,S.
|
||||
M_,S0',W2/,W47,W6?,W8G,W:O,W<W,W>_,W@',[B/,[D7,[F?,[HG,[JO,[L
|
||||
MW,[N_,[P',_R/,_T7,_V?,_XG,_ZO,_\W,_^_,\`'=`"/=`$7=`&?=`(G=`*
|
||||
MO=`,W=`._=`0'=$2/=$47=$6?=$8G=$:O=$<W=$>_=$@'=(B/=(D7=(F?=(H
|
||||
MG=(JO=(LW=(N_=(P'=,R/=,T7=,V?=,XG=,ZO=,\W=,^_=-`'=1"/=1$7=1&
|
||||
M?=1(G=1*O=1,W=1._=10'=52/=547=56?=58G=5:O=5<W=5>_=5@'=9B/=9D
|
||||
M7=9F?=9HG=9JO=9LW=9N_=9P'==R/==T7==V?==XG==ZO==\W==^_=>`'=B"
|
||||
M/=B$7=B&?=B(G=B*O=B,W=B._=B0'=F2/=F47=F6?=F8G=F:O=F<W=F>_=F@
|
||||
M'=JB/=JD7=JF?=JHG=JJO=JLW=JN_=JP'=NR/=NT7=NV?=NXG=NZO=N\W=N^
|
||||
M_=O`'=S"/=S$7=S&?=S(G=S*O=S,W=S._=S0'=W2/=W47=W6?=W8G=W:O=W<
|
||||
MW=W>_=W@'=[B/=[D7=[F?=[HG=[JO=[LW=[N_=[P'=_R/=_T7=_V?=_XG=_Z
|
||||
MO=_\W=_^_=\`'N`"/N`$7N`&?N`(GN`*ON`,WN`._N`0'N$2/N$47N$6?N$8
|
||||
MGN$:ON$<WN$>_N$@'N(B/N(D7N(F?N(HGN(JON(LWN(N_N(P'N,R/N,T7N,V
|
||||
M?N,XGN,ZON,\WN,^_N-`'N1"/N1$7N1&?N1(GN1*ON1,WN1._N10'N52/N54
|
||||
M7N56?N58GN5:ON5<WN5>_N5@'N9B/N9D7N9F?N9HGN9JON9LWN9N_N9P'N=R
|
||||
M/N=T7N=V?N=XGN=ZON=\WN=^_N>`'NB"/NB$7NB&?NB(GNB*ONB,WNB._NB0
|
||||
M'NF2/NF47NF6?NF8GNF:ONF<WNF>_NF@'NJB/NJD7NJF?NJHGNJJONJLWNJN
|
||||
M_NJP'NNR/NNT7NNV?NNXGNNZONN\WNN^_NO`'NS"/NS$7NS&?NS(GNS*ONS,
|
||||
MWNS._NS0'NW2/NW47NW6?NW8GNW:ONW<WNW>_NW@'N[B/N[D7N[F?N[HGN[J
|
||||
MON[LWN[N_N[P'N_R/N_T7N_V?N_XGN_ZON_\WN_^_N\`'_`"/_`$7_`&?_`(
|
||||
MG_`*O_`,W_`.__`0'_$2/_$47_$6?_$8G_$:O_$<W_$>__$@'_(B/_(D7_(F
|
||||
M?_(HG_(JO_(LW_(N__(P'_,R/_,T7_,V?_,XG_,ZO_,\W_,^__-`'_1"/_1$
|
||||
M7_1&?_1(G_1*O_1,W_1.__10'_52/_547_56?_58G_5:O_5<W_5>__5@'_9B
|
||||
M/_9D7_9F?_9HG_9JO_9LW_9N__9P'_=R/_=T7_=V?_=XG_=ZO_=\W_=^__>`
|
||||
M'_B"/_B$7_B&?_B(G_B*O_B,W_B.__B0'_F2/_F47_F6?_F8G_F:O_F<W_F>
|
||||
M__F@'_JB/_JD7_JF?_JHG_JJO_JLW_JN__JP'_NR/_NT7_NV?_NXG_NZO_N\
|
||||
MW_N^__O`'_S"/_S$7_S&?_S(G_S*O_S,W_S.__S0'_W2/_W47_W6?_W8G_W:
|
||||
MO_W<W_W>__W@'_[B/_[D7_[F?_[HG_[JO_[LW_[N__[P'__R/__T7__V?__X
|
||||
MG__ZO__\W__^__\`,``*P`%(``N@`3R`"#`!*L`%R``;H`-\@!`P`DK`"4@!
|
||||
M*Z`%O(`8,`-JP`W(`3N@!_R`(#`$BL`12`)+H`D\@2@P!:K`%<@"6Z`+?($P
|
||||
M,`;*P!E(`VN@#;R!.#`'ZL`=R`-[H`_\@4`P"`K!(4@$BZ`1/()(,`DJP27(
|
||||
M!)N@$WR"4#`*2L$I2`6KH!6\@E@P"VK!+<@%NZ`7_()@,`R*P3%(!LN@&3R#
|
||||
M:#`-JL$UR`;;H!M\@W`P#LK!.4@'ZZ`=O(-X,`_JP3W(!_N@'_R#@#`0"L)!
|
||||
M2`@+H2$\A(@P$2K"1<@(&Z$C?(20,!)*PDE("2NA);R$F#`3:L)-R`D[H2?\
|
||||
MA*`P%(K"44@*2Z$I/(6H,!6JPE7("ENA*WR%L#`6RL)92`MKH2V\A;@P%^K"
|
||||
M7<@+>Z$O_(7`,!@*PV%(#(NA,3R&R#`9*L-ER`R;H3-\AM`P&DK#:4@-JZ$U
|
||||
MO(;8,!MJPVW(#;NA-_R&X#`<BL-Q2`[+H3D\A^@P':K#=<@.VZ$[?(?P,![*
|
||||
MPWE(#^NA/;R'^#`?ZL-]R`_[H3_\AP`Q(`K$@4@0"Z)!/(@(,2$JQ(7($!NB
|
||||
M0WR($#$B2L2)2!$KHD6\B!@Q(VK$C<@1.Z)'_(@@,22*Q)%($DNB23R)*#$E
|
||||
MJL25R!);HDM\B3`Q)LK$F4@3:Z)-O(DX,2?JQ)W($WNB3_R)0#$H"L6A2!2+
|
||||
MHE$\BD@Q*2K%I<@4FZ)3?(I0,2I*Q:E(%:NB5;R*6#$K:L6MR!6[HE?\BF`Q
|
||||
M+(K%L4@6RZ)9/(MH,2VJQ;7(%MNB6WR+<#$NRL6Y2!?KHEV\BW@Q+^K%O<@7
|
||||
M^Z)?_(N`,3`*QL%(&`NC83R,B#$Q*L;%R!@;HV-\C)`Q,DK&R4@9*Z-EO(R8
|
||||
M,3-JQLW(&3NC9_R,H#$TBL;12!I+HVD\C:@Q-:K&U<@:6Z-K?(VP,3;*QME(
|
||||
M&VNC;;R-N#$WZL;=R!M[HV_\C<`Q.`K'X4@<BZ-Q/([(,3DJQ^7(')NC<WR.
|
||||
MT#$Z2L?I2!VKHW6\CM@Q.VK'[<@=NZ-W_([@,3R*Q_%('LNC>3R/Z#$]JL?U
|
||||
MR![;HWM\C_`Q/LK'^4@?ZZ-]O(_X,3_JQ_W('_NC?_R/`#)`"L@!22`+I($\
|
||||
MD`@R02K(!<D@&Z2#?)`0,D)*R`E)(2NDA;R0&#)#:L@-R2$[I(?\D"`R1(K(
|
||||
M$4DB2Z2)/)$H,D6JR!7)(ENDBWR1,#)&RL@922-KI(V\D3@R1^K('<DC>Z2/
|
||||
M_)%`,D@*R2%))(NDD3R22#))*LDER22;I)-\DE`R2DK)*4DEJZ25O))8,DMJ
|
||||
MR2W));NDE_R28#),BLDQ22;+I)D\DV@R3:K)-<DFVZ2;?)-P,D[*R3E))^ND
|
||||
MG;R3>#)/ZLD]R2?[I)_\DX`R4`K*04DH"Z6A/)2(,E$JRD7)*!NEHWR4D#)2
|
||||
M2LI)22DKI:6\E)@R4VK*3<DI.Z6G_)2@,E2*RE%)*DNEJ3R5J#)5JLI5R2I;
|
||||
MI:M\E;`R5LK*64DK:Z6MO)6X,E?JREW)*WNEK_R5P#)8"LMA22R+I;$\EL@R
|
||||
M62K+9<DLFZ6S?);0,EI*RVE)+:NEM;R6V#);:LMMR2V[I;?\EN`R7(K+<4DN
|
||||
MRZ6Y/)?H,EVJRW7)+MNENWR7\#)>RLMY22_KI;V\E_@R7^K+?<DO^Z6__)<`
|
||||
M,V`*S(%),`NFP3R8"#-A*LR%R3`;IL-\F!`S8DK,B4DQ*Z;%O)@8,V-JS(W)
|
||||
M,3NFQ_R8(#-DBLR123)+ILD\F2@S9:K,E<DR6Z;+?)DP,V;*S)E),VNFS;R9
|
||||
M.#-GZLR=R3-[IL_\F4`S:`K-H4DTBZ;1/)I(,VDJS:7)-)NFTWR:4#-J2LVI
|
||||
M236KIM6\FE@S:VK-K<DUNZ;7_)I@,VR*S;%)-LNFV3R;:#-MJLVUR3;;IMM\
|
||||
MFW`S;LK-N4DWZZ;=O)MX,V_JS;W)-_NFW_R;@#-P"L[!23@+I^$\G(@S<2K.
|
||||
MQ<DX&Z?C?)R0,W)*SLE).2NGY;R<F#-S:L[-R3D[I^?\G*`S=(K.T4DZ2Z?I
|
||||
M/)VH,W6JSM7).ENGZWR=L#-VRL[923MKI^V\G;@S=^K.W<D[>Z?O_)W`,W@*
|
||||
MS^%)/(NG\3R>R#-Y*L_ER3R;I_-\GM`S>DK/Z4D]JZ?UO)[8,WMJS^W)/;NG
|
||||
M]_R>X#-\BL_Q23[+I_D\G^@S?:K/]<D^VZ?[?)_P,W[*S_E)/^NG_;R?^#-_
|
||||
MZL_]R3_[I__\GP`T@`K0`4I`"Z@!/:`(-($JT`7*0!NH`WV@$#2"2M`)2D$K
|
||||
MJ`6]H!@T@VK0#<I!.Z@'_:`@-(2*T!%*0DNH"3VA*#2%JM`5RD);J`M]H3`T
|
||||
MALK0&4I#:Z@-O:$X-(?JT!W*0WNH#_VA0#2("M$A2D2+J!$]HD@TB2K1)<I$
|
||||
MFZ@3?:)0-(I*T2E*1:NH%;VB6#2+:M$MRD6[J!?]HF`TC(K1,4I&RZ@9/:-H
|
||||
M-(VJT37*1MNH&WVC<#2.RM$Y2D?KJ!V]HW@TC^K1/<I'^Z@?_:.`-)`*TD%*
|
||||
M2`NI(3VDB#21*M)%RD@;J2-]I)`TDDK224I)*ZDEO:28-)-JTDW*23NI)_VD
|
||||
MH#24BM)12DI+J2D]I:@TE:K25<I*6ZDK?:6P-);*TEE*2VNI+;VEN#27ZM)=
|
||||
MRDM[J2_]I<`TF`K384I,BZDQ/:;(-)DJTV7*3)NI,WVFT#2:2M-I2DVKJ36]
|
||||
MIM@TFVK3;<I-NZDW_:;@-)R*TW%*3LNI.3VGZ#2=JM-URD[;J3M]I_`TGLK3
|
||||
M>4I/ZZD]O:?X-)_JTWW*3_NI/_VG`#6@"M2!2E`+JD$]J`@UH2K4A<I0&ZI#
|
||||
M?:@0-:)*U(E*42NJ1;VHC:M2-RE$[JD?]J"`UI(K4D4I22ZI)/:DH-:6J
|
||||
MU)7*4ENJ2WVI,#6FRM292E-KJDV]J3@UI^K4G<I3>ZI/_:E`-:@*U:%*5(NJ
|
||||
M43VJ2#6I*M6ERE2;JE-]JE`UJDK5J4I5JZI5O:I8-:MJU:W*5;NJ5_VJ8#6L
|
||||
MBM6Q2E;+JED]JV@UK:K5M<I6VZI;?:MP-:[*U;E*5^NJ7;VK>#6OZM6]RE?[
|
||||
MJE_]JX`UL`K6P4I8"ZMA/:R(-;$JUL7*6!NK8WVLD#6R2M;)2EDKJV6]K)@U
|
||||
MLVK6S<I9.ZMG_:R@-;2*UM%*6DNK:3VMJ#6UJM;5REI;JVM]K;`UMLK6V4I;
|
||||
M:ZMMO:VX-;?JUMW*6WNK;_VMP#6X"M?A2ER+JW$]KL@UN2K7Y<I<FZMS?:[0
|
||||
M-;I*U^E*7:NK=;VNV#6[:M?MREV[JW?]KN`UO(K7\4I>RZMY/:_H-;VJU_7*
|
||||
M7MNK>WVO\#6^RM?Y2E_KJWV]K_@UO^K7_<I?^ZM__:\`-L`*V`%+8`NL@3VP
|
||||
M"#;!*M@%RV`;K(-]L!`VPDK8"4MA*ZR%O;`8-L-JV`W+83NLA_VP(#;$BM@1
|
||||
M2V)+K(D]L2@VQ:K8%<MB6ZR+?;$P-L;*V!E+8VNLC;VQ.#;'ZM@=RV-[K(_]
|
||||
ML4`VR`K9(4MDBZR1/;)(-LDJV27+9)NLDWVR4#;*2MDI2V6KK)6]LE@VRVK9
|
||||
M+<MENZR7_;)@-LR*V3%+9LNLF3VS:#;-JMDURV;;K)M]LW`VSLK9.4MGZZR=
|
||||
MO;-X-L_JV3W+9_NLG_VS@#;0"MI!2V@+K:$]M(@VT2K:1<MH&ZVC?;20-M)*
|
||||
MVDE+:2NMI;VTF#;3:MI-RVD[K:?]M*`VU(K:44MJ2ZVI/;6H-M6JVE7+:ENM
|
||||
MJWVUL#;6RMI92VMKK:V]M;@VU^K:7<MK>ZVO_;7`-M@*VV%+;(NML3VVR#;9
|
||||
M*MMERVR;K;-]MM`VVDK;:4MMJZVUO;;8-MMJVVW+;;NMM_VVX#;<BMMQ2V[+
|
||||
MK;D]M^@VW:K;=<MNVZV[?;?P-M[*VWE+;^NMO;VW^#;?ZMM]RV_[K;_]MP`W
|
||||
MX`K<@4MP"Z[!/;@(-^$JW(7+<!NNPWVX$#?B2MR)2W$KKL6]N!@WXVK<C<MQ
|
||||
M.Z['_;@@-^2*W)%+<DNNR3VY*#?EJMR5RW);KLM]N3`WYLK<F4MS:Z[-O;DX
|
||||
M-^?JW)W+<WNNS_VY0#?H"MVA2W2+KM$]ND@WZ2K=I<MTFZ[3?;I0-^I*W:E+
|
||||
M=:NNU;VZ6#?K:MVMRW6[KM?]NF`W[(K=L4MVRZ[9/;MH-^VJW;7+=MNNVWV[
|
||||
M<#?NRMVY2W?KKMV]NW@W[^K=O<MW^Z[?_;N`-_`*WL%+>`NOX3V\B#?Q*M[%
|
||||
MRW@;K^-]O)`W\DK>R4MY*Z_EO;R8-_-JWLW+>3NOY_V\H#?TBM[12WI+K^D]
|
||||
MO:@W]:K>U<MZ6Z_K?;VP-_;*WME+>VNO[;V]N#?WZM[=RWM[K^_]O<`W^`K?
|
||||
MX4M\BZ_Q/;[(-_DJW^7+?)NO\WV^T#?Z2M_I2WVKK_6]OM@W^VK?[<M]NZ_W
|
||||
M_;[@-_R*W_%+?LNO^3V_Z#?]JM_URW[;K_M]O_`W_LK?^4M_ZZ_]O;_X-__J
|
||||
MW_W+?_NO__V_`#@`"^`!3(`+L`$^P`@X`2O@!<R`&[`#?L`0.`)+X`E,@2NP
|
||||
M!;[`&#@#:^`-S($[L`?^P"`X!(O@$4R"2[`)/L$H.`6KX!7,@ENP"W[!,#@&
|
||||
MR^`93(-KL`V^P3@X!^O@'<R#>[`/_L%`.`@+X2%,A(NP$3["2#@)*^$ES(2;
|
||||
ML!-^PE`X"DOA*4R%J[`5OL)8.`MKX2W,A;NP%_["8#@,B^$Q3(;+L!D^PV@X
|
||||
M#:OA-<R&V[`;?L-P.`[+X3E,A^NP';[#>#@/Z^$]S(?[L!_^PX`X$`OB04R(
|
||||
M"[$A/L2(.!$KXD7,B!NQ(W[$D#@22^))3(DKL26^Q)@X$VOB3<R).[$G_L2@
|
||||
M.!2+XE%,BDNQ*3[%J#@5J^)5S(I;L2M^Q;`X%LOB64R+:[$MOL6X.!?KXEW,
|
||||
MBWNQ+_[%P#@8"^-A3(R+L3$^QL@X&2OC9<R,F[$S?L;0.!I+XVE,C:NQ-;[&
|
||||
MV#@;:^-MS(V[L3?^QN`X'(OC<4R.R[$Y/L?H.!VKXW7,CMNQ.W['\#@>R^-Y
|
||||
M3(_KL3V^Q_@X'^OC?<R/^[$__L<`.2`+Y(%,D`NR03[("#DA*^2%S)`;LD-^
|
||||
MR!`Y(DODB4R1*[)%OL@8.2-KY(W,D3NR1_[((#DDB^213))+LDD^R2@Y):OD
|
||||
ME<R26[)+?LDP.2;+Y)E,DVNR3;[).#DGZ^2=S)-[LD_^R4`Y*`OEH4R4B[)1
|
||||
M/LI(.2DKY:7,E)NR4W[*4#DJ2^6I3)6KLE6^RE@Y*VOEK<R5N[)7_LI@.2R+
|
||||
MY;%,ELNR63[+:#DMJ^6US);;LEM^RW`Y+LOEN4R7Z[)=OLMX.2_KY;W,E_NR
|
||||
M7_[+@#DP"^;!3)@+LV$^S(@Y,2OFQ<R8&[-C?LR0.3)+YLE,F2NS9;[,F#DS
|
||||
M:^;-S)D[LV?^S*`Y-(OFT4R:2[-I/LVH.36KYM7,FENS:W[-L#DVR^;93)MK
|
||||
MLVV^S;@Y-^OFW<R;>[-O_LW`.3@+Y^%,G(NS<3[.R#DY*^?ES)R;LW-^SM`Y
|
||||
M.DOGZ4R=J[-UOL[8.3MKY^W,G;NS=_[.X#D\B^?Q3)[+LWD^S^@Y/:OG]<R>
|
||||
MV[-[?L_P.3[+Y_E,G^NS?;[/^#D_Z^?]S)_[LW_^SP`Z0`OH`4V@"[2!/M`(
|
||||
M.D$KZ`7-H!NT@W[0$#I"2^@)3:$KM(6^T!@Z0VOH#<VA.[2'_M`@.D2+Z!%-
|
||||
MHDNTB3[1*#I%J^@5S:);M(M^T3`Z1LOH&4VC:[2-OM$X.D?KZ!W-HWNTC_[1
|
||||
M0#I("^DA3:2+M)$^TD@Z22OI)<VDF[23?M)0.DI+Z2E-I:NTE;[26#I+:^DM
|
||||
MS:6[M)?^TF`Z3(OI,4VFR[29/M-H.DVKZ37-IMNTFW[3<#I.R^DY3:?KM)V^
|
||||
MTW@Z3^OI/<VG^[2?_M.`.E`+ZD%-J`NUH3[4B#I1*^I%S:@;M:-^U)`Z4DOJ
|
||||
M24VI*[6EOM28.E-KZDW-J3NUI_[4H#I4B^I13:I+M:D^U:@Z5:OJ5<VJ6[6K
|
||||
M?M6P.E;+ZEE-JVNUK;[5N#I7Z^I=S:M[M:_^U<`Z6`OK84VLB[6Q/M;(.EDK
|
||||
MZV5-A'/1+NI%S#I:2^MI3:VKM;6^UM@Z6VOK;<VMN[6W_M;@.ER+ZW%-KLNU
|
||||
MN3[7Z#I=J^MUS:[;M;M^U_`Z7LOK>4VOZ[6]OM?X.E_KZWW-K_NUO_[7`#M@
|
||||
M"^R!3;`+ML$^V`@[82OLA<VP&[;#?M@0.V)+[(E-L2NVQ;[8&#MC:^R-S;$[
|
||||
MML?^V"`[9(OLD4VR2[;)/MDH.V6K[)7-LENVRW[9,#MFR^R93;-KMLV^V3@[
|
||||
M9^OLG<VS>[;/_ME`.V@+[:%-M(NVT3[:2#MI*^VES;2;MM-^VE`[:DOMJ4VU
|
||||
MJ[;5OMI8.VMK[:W-M;NVU_[:8#MLB^VQ3;;+MMD^VV@[;:OMM<VVV[;;?MMP
|
||||
M.V[+[;E-M^NVW;[;>#MOZ^V]S;?[MM_^VX`[<`ONP4VX"[?A/MR(.W$K[L7-
|
||||
MN!NWXW[<D#MR2^[)3;DKM^6^W)@[<VONS<VY.[?G_MR@.W2+[M%-NDNWZ3[=
|
||||
MJ#MUJ^[5S;I;M^M^W;`[=LONV4V[:[?MOMVX.W?K[MW-NWNW[_[=P#MX"^_A
|
||||
M3;R+M_$^WL@[>2OOY<V\F[?S?M[0.WI+[^E-O:NW];[>V#M[:^_MS;V[M_?^
|
||||
MWN`[?(OO\4V^R[?Y/M_H.WVK[_7-OMNW^W[?\#M^R^_Y3;_KM_V^W_@[?^OO
|
||||
M_<V_^[?__M\`/(`+\`%.P`NX`3_@"#R!*_`%SL`;N`-_X!`\@DOP"4[!*[@%
|
||||
MO^`8/(-K\`W.P3NX!__@(#R$B_`13L)+N`D_X2@\A:OP%<["6[@+?^$P/(;+
|
||||
M\!E.PVNX#;_A.#R'Z_`=SL-[N`__X4`\B`OQ(4[$B[@1/^)(/(DK\27.Q)NX
|
||||
M$W_B4#R*2_$I3L6KN!6_XE@\BVOQ+<[%N[@7_^)@/(R+\3%.QLNX&3_C:#R-
|
||||
MJ_$USL;;N!M_XW`\CLOQ.4['Z[@=O^-X/(_K\3W.Q_NX'__C@#R0"_)!3L@+
|
||||
MN2$_Y(@\D2OR1<[(&[DC?^20/))+\DE.R2NY);_DF#R3:_)-SLD[N2?_Y*`\
|
||||
ME(OR44[*2[DI/^6H/)6K\E7.RENY*W_EL#R6R_)93LMKN2V_Y;@\E^OR7<[+
|
||||
M>[DO_^7`/)@+\V%.S(NY,3_FR#R9*_-ESLR;N3-_YM`\FDOS:4[-J[DUO^;8
|
||||
M/)MK\VW.S;NY-__FX#R<B_-Q3L[+N3D_Y^@\G:OS=<[.V[D[?^?P/)[+\WE.
|
||||
MS^NY/;_G^#R?Z_-]SL_[N3__YP`]H`OT@4[0"[I!/^@(/:$K](7.T!NZ0W_H
|
||||
M$#VB2_2)3M$KND6_Z!@]HVOTC<[1.[I'_^@@/:2+])%.TDNZ23_I*#VEJ_25
|
||||
MSM);NDM_Z3`]ILOTF4[3:[I-O^DX/:?K])W.TWNZ3__I0#VH"_6A3M2+NE$_
|
||||
MZD@]J2OUI<[4F[I3?^I0/:I+]:E.U:NZ5;_J6#VK:_6MSM6[NE?_ZF`]K(OU
|
||||
ML4[6R[I9/^MH/:VK];7.UMNZ6W_K<#VNR_6Y3M?KNEV_ZW@]K^OUO<[7^[I?
|
||||
M_^N`/;`+]L%.V`N[83_LB#VQ*_;%SM@;NV-_[)`]LDOVR4[9*[MEO^R8/;-K
|
||||
M]LW.V3N[9__LH#VTB_;13MI+NVD_[:@]M:OVU<[:6[MK?^VP/;;+]ME.VVN[
|
||||
M;;_MN#VWZ_;=SMM[NV__[<`]N`OWX4[<B[MQ/^[(/;DK]^7.W)N[<W_NT#VZ
|
||||
M2_?I3MVKNW6_[M@]NVOW[<[=N[MW_^[@/;R+]_%.WLN[>3_OZ#V]J_?USM[;
|
||||
MNWM_[_`]OLOW^4[?Z[M]O^_X/;_K]_W.W_N[?__O`#[`"_@!3^`+O($_\`@^
|
||||
MP2OX!<_@&[R#?_`0/L)+^`E/X2N\A;_P&#[#:_@-S^$[O(?_\"`^Q(OX$4_B
|
||||
M2[R)/_$H/L6K^!7/XEN\BW_Q,#[&R_@93^-KO(V_\3@^Q^OX'<_C>[R/__%`
|
||||
M/L@+^2%/Y(N\D3_R2#[)*_DES^2;O)-_\E`^RDOY*4_EJ[R5O_)8/LMK^2W/
|
||||
MY;N\E__R8#[,B_DQ3^;+O)D_\V@^S:OY-<_FV[R;?_-P/L[+^3E/Y^N\G;_S
|
||||
M>#[/Z_D]S^?[O)__\X`^T`OZ04_H"[VA/_2(/M$K^D7/Z!N]HW_TD#[22_I)
|
||||
M3^DKO:6_])@^TVOZ3<_I.[VG__2@/M2+^E%/ZDN]J3_UJ#[5J_I5S^I;O:M_
|
||||
M];`^ULOZ64_K:[VMO_6X/M?K^EW/ZWN]K__UP#[8"_MA3^R+O;$_]L@^V2O[
|
||||
M9<_LF[VS?_;0/MI+^VE/[:N]M;_VV#[;:_MMS^V[O;?_]N`^W(O[<4_NR[VY
|
||||
M/_?H/MVK^W7/[MN]NW_W\#[>R_MY3^_KO;V_]_@^W^O[?<_O^[V___<`/^`+
|
||||
M_(%/\`N^P3_X"#_A*_R%S_`;OL-_^!`_XDO\B4_Q*[[%O_@8/^-K_(W/\3N^
|
||||
MQ__X(#_DB_R13_)+OLD_^2@_Y:O\E<_R6[[+?_DP/^;+_)E/\VN^S;_Y.#_G
|
||||
MZ_R=S_-[OL__^4`_Z`O]H4_TB[[1/_I(/^DK_:7/])N^TW_Z4#_J2_VI3_6K
|
||||
MOM6_^E@_ZVO]K<_UN[[7__I@/^R+_;%/]LN^V3_[:#_MJ_VUS_;;OMM_^W`_
|
||||
M[LO]N4_WZ[[=O_MX/^_K_;W/]_N^W__[@#_P"_[!3_@+O^$__(@_\2O^Q<_X
|
||||
M&[_C?_R0/_)+_LE/^2N_Y;_\F#_S:_[-S_D[O^?__*`_](O^T4_Z2[_I/_VH
|
||||
M/_6K_M7/^EN_ZW_]L#_VR_[93_MKO^V__;@_]^O^W<_[>[_O__W`/_@+_^%/
|
||||
M_(N_\3_^R#_Y*__ES_R;O_-__M`_^DO_Z4_]J[_UO_[8/_MK_^W/_;N_]__^
|
||||
MX#_\B__Q3_[+O_D__^@__:O_]<_^V[_[?__P/_[+__E/_^N__;__^#__Z__]
|
||||
MS__[O____P!@`"@`#H`$8`%H`!Z`"&`"J``N@`Q@`^@`/H`08`0H`4Z`%&`%
|
||||
M:`%>@!A@!J@!;H`<8`?H`7Z`(&`(*`*.@"1@"6@"GH`H8`JH`JZ`+&`+Z`*^
|
||||
M@#!@#"@#SH`T8`UH`]Z`.&`.J`/N@#Q@#^@#_H!`8!`H!`Z!1&`1:`0>@4A@
|
||||
M$J@$+H%,8!/H!#Z!4&`4*`5.@51@%6@%7H%88!:H!6Z!7&`7Z`5^@6!@&"@&
|
||||
MCH%D8!EH!IZ!:&`:J`:N@6Q@&^@&OH%P8!PH!\Z!=&`=:`?>@7A@'J@'[H%\
|
||||
M8!_H!_Z!@&`@*`@.@H1@(6@('H*(8"*H""Z"C&`CZ`@^@I!@)"@)3H*48"5H
|
||||
M"5Z"F&`FJ`EN@IQ@)^@)?H*@8"@H"HZ"I&`I:`J>@JA@*J@*KH*L8"OH"KZ"
|
||||
ML&`L*`O.@K1@+6@+WH*X8"ZH"^Z"O&`OZ`O^@L!@,"@,#H/$8#%H#!Z#R&`R
|
||||
MJ`PN@\Q@,^@,/H/08#0H#4Z#U&`U:`U>@]A@-J@-;H/<8#?H#7Z#X&`X*`Z.
|
||||
M@^1@.6@.GH/H8#JH#JZ#[&`[Z`Z^@_!@/"@/SH/T8#UH#]Z#^&`^J`_N@_Q@
|
||||
M/^@/_H,`84`H$`Z$!&%!:!`>A`AA0J@0+H0,84/H$#Z$$&%$*!%.A!1A16@1
|
||||
M7H0884:H$6Z$'&%'Z!%^A"!A2"@2CH0D84EH$IZ$*&%*J!*NA"QA2^@2OH0P
|
||||
M84PH$\Z$-&%-:!/>A#AA3J@3[H0\84_H$_Z$0&%0*!0.A41A46@4'H5(85*H
|
||||
M%"Z%3&%3Z!0^A5!A5"@53H54855H%5Z%6&%6J!5NA5QA5^@5?H5@85@H%HZ%
|
||||
M9&%9:!:>A6AA6J@6KH5L85OH%KZ%<&%<*!?.A71A76@7WH5X85ZH%^Z%?&%?
|
||||
MZ!?^A8!A8"@8#H:$86%H&!Z&B&%BJ!@NAHQA8^@8/H:0860H&4Z&E&%E:!E>
|
||||
MAIAA9J@9;H:<86?H&7Z&H&%H*!J.AJ1A:6@:GH:H86JH&JZ&K&%KZ!J^AK!A
|
||||
M;"@;SH:T86UH&]Z&N&%NJ!ONAKQA;^@;_H;`87`H'`Z'Q&%Q:!P>A\AA<J@<
|
||||
M+H?,87/H'#Z'T&%T*!U.A]1A=6@=7H?887:H'6Z'W&%WZ!U^A^!A>"@>CH?D
|
||||
M87EH'IZ'Z&%ZJ!ZNA^QA>^@>OH?P87PH'\Z']&%]:!_>A_AA?J@?[H?\87_H
|
||||
M'_Z'`&*`*"`.B`1B@6@@'H@(8H*H("Z(#&*#Z"`^B!!BA"@A3H@48H5H(5Z(
|
||||
M&&*&J"%NB!QBA^@A?H@@8H@H(HZ()&*):"*>B"ABBJ@BKH@L8HOH(KZ(,&*,
|
||||
M*"/.B#1BC6@CWH@X8HZH(^Z(/&*/Z"/^B$!BD"@D#HE$8I%H)!Z)2&*2J"0N
|
||||
MB4QBD^@D/HE08I0H)4Z)5&*5:"5>B5ABEJ@E;HE<8I?H)7Z)8&*8*":.B61B
|
||||
MF6@FGHEH8IJH)JZ);&*;Z":^B7!BG"@GSHET8IUH)]Z)>&*>J"?NB7QBG^@G
|
||||
M_HF`8J`H*`Z*A&*A:"@>BHABHJ@H+HJ,8J/H*#Z*D&*D*"E.BI1BI6@I7HJ8
|
||||
M8J:H*6Z*G&*GZ"E^BJ!BJ"@JCHJD8JEH*IZ*J&*JJ"JNBJQBJ^@JOHJP8JPH
|
||||
M*\Z*M&*M:"O>BKABKJ@K[HJ\8J_H*_Z*P&*P*"P.B\1BL6@L'HO(8K*H+"Z+
|
||||
MS&*SZ"P^B]!BM"@M3HO48K5H+5Z+V&*VJ"UNB]QBM^@M?HO@8K@H+HZ+Y&*Y
|
||||
M:"Z>B^ABNJ@NKHOL8KOH+KZ+\&*\*"_.B_1BO6@OWHOX8KZH+^Z+_&*_Z"_^
|
||||
'BP!CP+@7`0``
|
||||
`
|
||||
end
|
||||
63
lib/libarchive/test/test_read_format_iso_zisofs.iso.Z.uu
Normal file
63
lib/libarchive/test/test_read_format_iso_zisofs.iso.Z.uu
Normal file
@ -0,0 +1,63 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_iso_zisofs.iso.Z
|
||||
M'YV0``(*'$BPH,&#"!,J7,BPH<.'$"-*G$BQHL6+&#-JW,BQH\>/($.*'$FR
|
||||
MI,F3*%.J7,FRI<N7,&/*G$FSILV;.'/JW,FSI\^?0(,*'4JTJ-&C2),J7<JT
|
||||
MJ=.G4*-*G4JUJM6K6+-JW<JUJ]>O8,.*'4NVK-FS:-.J7<NVK=NW<./*G4NW
|
||||
MKMV[>//JW<NWK]^_@`,+'DRXL.'#B!,K7LRXL>/'D"-+GDRYLN7+F#-KWLRY
|
||||
ML^?/H$.+'DVZM.G3J%.K7LVZM>O7L&/+GDV[MNW;N'/KWLV[M^_?P(,+'TZ\
|
||||
MN/'CR),K7\Z\N?/GT*-+GTZ]NO7KV+-KW\Z]N_?OX,.+'T^^O/GSZ-.K7\^^
|
||||
MO?OW\./+GT^_OOW[^//KW\^_O_^_`0Q!!`PPQ!```$;(44890DQ!!`@01BCA
|
||||
MA!1***`43S11X88<1GA0+`6!Z-&!``1`XH$((`"`!059,$%"%0PD`@`7%%2C
|
||||
MB@*I:$0``B10(@D"!'3B@1T6:>212":IY)),-NGDDU!&*>645%9I991-+)'$
|
||||
M%$\8,04(6SX!0@XVV`##"TAX"8(123!1Q!193$%%$1H*446;1!0A!0@F@'!A
|
||||
M$4,\(<6#`K8@Q0M$6$&H%$4$086@(*`P1`H@Q)!##C.`4(0+63Q1A1-'$!&$
|
||||
MFY%.6NFE-X"@A`M0-"H%ETZ\L.H40R#1)A-)@'KEKKSN*@.!.<`0K`PRQ$!#
|
||||
M#300"`,)OPKK++'&(JLL"<I6:VVU`#0;[+#%'ILL@200V>NXY)9K[KGHIJON
|
||||
MNNRVZ^Z2_\6[V#\"$FB@O/CFJ^^^_/9;799)@'!%&62`,$49<$`H`PC%ZG"L
|
||||
MPS`P#*P";:R1QAQOF#$'PRX4"(*A']>11L$Q?'S&R`Q_K`<(+K3\@AX7O^'O
|
||||
MS#37;//-.)=U8(U""C0``!@(="`124B1\]%()ZWTTDPW[?334$<M]=2OD1A0
|
||||
MC23^+%#0`1!M--5@ARWVV&27;?;9:*>M]MI,(T*CC0#@&)".//H8`)`]EWC@
|
||||
M%%`<$(`O[P`@A10%!!`(%%B$VTX0`P71CM8##6"UT$$2)``51F@0@`,[]OAC
|
||||
M&PD(4$$+*)``NNBDDS!$$1P$D$%!KQO43D'MF/$V03<.1+?G=U<^9`"#%WYX
|
||||
MX@$LWOCC!4E>$(\%79[YYIW;;7KHHY=^>O4D```'T`4%+7?<"-;]H^]"#N!U
|
||||
M\`$DXD03"!Q(1AIR(*XXXP(Y7OE``DPNY/T".:\YY^*[6_0^1[W4`8`0`-!`
|
||||
M031@`P,,Q``V&.#=A":D`[#)32[800S0I[XF).!`9D@#&\H@OP"0(A`#"00I
|
||||
M^!>0_"V/A0#P'_0"2`()3@]UI=."$2`0`#CH@0`/H$(8>!$07H2!"HQ(X`(;
|
||||
M^,`(TI"")5H`$H(P*%PY80D9W"#ATK>^!AP(#6&0`QG8D`8WK*&$)TSA"ING
|
||||
MOQ+!4(8`Y-T-L7>]U.F0ASX$HA")"``C4L$0`-A`001I$!M",0`*@%,3K(A%
|
||||
M#0INBXU8'P,.-(<\M(&,9BPA,$(QD%``HXTF>F'SIL"$!9"(`"$<(>;^MZ,!
|
||||
M^$@`-0R`*V,XQ]2YC9`#P25!ZEBZ0RY`D8R401;1%\DF>!$`E;QD&=<@`TUR
|
||||
M4B">!"4HWTC*28(/``.@0QO@L,K-\;*6UBM@Z101R$$>Y'0%^%GV\A:`7V9A
|
||||
MD;E:P@R&"<DN4M*2F%S##)S9R4\N;YJC9((#4!20;&Z3``#HI@.^R5!QDB")
|
||||
MN@Q(1`7R35\",YXTH&?ABGG,9.:3!OR$IC\)$DJ24I,)/`0`0H.$4&QJDYO/
|
||||
M6ZA#&XK#=;+MIDNS7=`(XCW=A4^.Y-/;(X570N/5KQUO!*CE%&I#FF(/`+;C
|
||||
MV4!REZ.?2B^H)@+>%H<WO^-!SF=*Q1]3:>A4`^+TK&A-JUK7:A$]M0.15#B$
|
||||
M5I,`A2]8*@<Q<!02B@`"#`UA"7U-`A&.P-=<S4D*M0H"J/@*!0P]*E!,`$%C
|
||||
MGV`%P;[)8%6``A0$184U06JS4T@"%M;4)K["24YT,AB=%$N%)`R!;VX*PA3X
|
||||
M&B@G4"$(0^@LT6@EV2H(`5=3V.N>C``IO@$J"6P:@J.2\`0G&,Q3B-T4A&;+
|
||||
M6-\"5[A@RI-MD9L$/8')N8U-0A.HF`406.$)3*A"$_B:)UI)@:Z/&BZD:GO;
|
||||
MW'Z7N%(8;VN;ZP*V^O>_``[PS&Y`CBE8(AG;L,8!]JC2!P0$'P4("!,!,.$*
|
||||
M.Y#"%[:PA#/,X0U[&,,?UC"(1RSB$G>8Q"<V<8A3S.(5NQC%+U8QC&<LXQJW
|
||||
MF,8WMG&,<\SC'?L8QS_6,9"'+.0B]YC(1S9RD)/,Y"4[&<E/5C*4IRSE*C>9
|
||||
MRE>V<I2SS.4M>QG+7]8RF,<LYC)WF<QG-G.8T\SF-;L9S6]6,YSG+.<ZMYG.
|
||||
M=\:#-MH1C%@T("`(A<$L?E`"`R3B'S<X!!JV48-9Q(XC\-!&`!8A!P%\0,"8
|
||||
MSK2F-\WI3GOZTZ`.M:A'3>I2F_K4J$ZUJE?-ZE:[^M6PCK6L9TWK6MOZUKC.
|
||||
MM:YWS>M>^_K7P`ZVL(=-[&(;^]C(3K:RE\WL9CO[V=".MK2G3>UJ6_O:V,ZV
|
||||
MMK?-[6Y[^]O@#K>XQTWN<IO[W.A.M[K7S>YVN_O=\(ZWO.=-[WK;^][XSK>^
|
||||
M]\WO?OO[WP`/N,`'3O""&_S@"$^XPA?.\(8[_.$0C[C$)T[QBEO\XAC/N,8W
|
||||
MSO&.>_SC(`^YR$=.\I*;_.0H3[G*5\[REKO\Y3"/N<QG3O.:V_SF.,^YSG?.
|
||||
M\Y[[_.=`#[K0AT[THAO]Z$A/NM*7SO2F._WI4(^ZU*=.]:I;_>I8S[K6M\[U
|
||||
MKGO]ZV`/N]C'3O:RF_WL:$^[VM?.]K:[_>UPC[O<YT[WNMO][GC/N][WSO>^
|
||||
M^_WO@`^\X`=/^,(;_O"(3[SB%\_XQCO^\9"/O.0G3_G*6_[RF,^\YC?/^<Y[
|
||||
M_O.@#[WH1T_ZTIO^]*A/O>I7S_K6N_[UL(^][&=/^]K;_O:XS[WN=\_[WOO^
|
||||
M]\`/OO"'3_SB&__XR$^^\I?/_.8[__G0C[[TIT_]ZEO_^MC/OO:WS_WN>__[
|
||||
MX`^_^,=/_O*;__SH3[_ZU\_^]KO__?"/O_SG3__ZV__^^,^__O?/__[[__\`
|
||||
M&(`".(`$6(`&>(`(F(`*N(`,V(`.^(`0&($2.($46($6>($8F($:N($<V($>
|
||||
M^($@&((B.((D6((F>((HF((JN((LV((N^((P&(,R.(,T6(,V>(,XF(,ZN(,\
|
||||
MV(,^^(-`&(1".(1$6(1&>(1(F(1*N(1,V(1.^(10&(52.(546(56>(58F(5:
|
||||
MN(5<V(5>^(5@&(9B.(9D6(9F>(9HF(9JN(9LV(9N^(9P&(=R.(=T6(=V>(=X
|
||||
MF(=ZN(=\V(=^^(>`&(B".(B$6(B&>(B(F(B*N(B,V(B.^(B0&(F2.(F46(F6
|
||||
@>(F8F(F:N(F<V(F>^(F@&(JB.(JD6(JF>(JHF(JJN'``
|
||||
`
|
||||
end
|
||||
@ -46,49 +46,39 @@ else
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso /tmp/iso/long-joliet-file-name.textfile /tmp/iso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink
|
||||
fi
|
||||
mkhybrid -J -uid 1 -gid 2 /tmp/iso | bzip2 > test_read_format_isojoliet_bz2.iso.bz2
|
||||
F=test_read_format_isojoliet_bz2.iso.bz2
|
||||
F=test_read_format_iso_joliet.iso.Z
|
||||
mkhybrid -J -uid 1 -gid 2 /tmp/iso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
*/
|
||||
|
||||
static void
|
||||
joliettest(int withrr)
|
||||
DEFINE_TEST(test_read_format_isojoliet_bz2)
|
||||
{
|
||||
const char *refname = "test_read_format_isojoliet_bz2.iso.bz2";
|
||||
const char *refname = "test_read_format_iso_joliet.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int r;
|
||||
|
||||
if (withrr) {
|
||||
refname = "test_read_format_isojolietrr_bz2.iso.bz2";
|
||||
}
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
r = archive_read_support_compression_bzip2(a);
|
||||
if (r == ARCHIVE_WARN) {
|
||||
skipping("bzip2 reading not fully supported on this platform");
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
return;
|
||||
}
|
||||
assertEqualInt(0, r);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_set_options(a, "iso9660:!rockridge"));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* First entry is '.' root directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(".", archive_entry_pathname(ae));
|
||||
assert(S_ISDIR(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(86401, archive_entry_ctime(ae));
|
||||
assertEqualInt(0, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(0, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
@ -97,100 +87,48 @@ joliettest(int withrr)
|
||||
/* A directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assert(S_ISDIR(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
if (withrr) {
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
}
|
||||
|
||||
/* A regular file with two names ("hardlink" gets returned
|
||||
* first, so it's not marked as a hardlink). */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assert(S_ISREG(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assert(archive_entry_hardlink(ae) == NULL);
|
||||
assertEqualInt(6, archive_entry_size(ae));
|
||||
assertEqualInt(0, archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(6, (int)size);
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualInt(0, memcmp(p, "hello\n", 6));
|
||||
if (withrr) {
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
/* TODO: Actually, libarchive should be able to
|
||||
* compute nlinks correctly even without RR
|
||||
* extensions. See comments in libarchive source. */
|
||||
assertEqualInt(2, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
}
|
||||
|
||||
/* Second name for the same regular file (this happens to be
|
||||
* returned second, so does get marked as a hardlink). */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_pathname(ae));
|
||||
assert(S_ISREG(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualString("hardlink", archive_entry_hardlink(ae));
|
||||
archive_entry_hardlink(ae));
|
||||
assert(!archive_entry_size_is_set(ae));
|
||||
if (withrr) {
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
/* TODO: See above. */
|
||||
assertEqualInt(2, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
}
|
||||
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("symlink", archive_entry_pathname(ae));
|
||||
if (withrr) {
|
||||
assert(S_ISLNK(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_symlink(ae));
|
||||
}
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
if (withrr) {
|
||||
assertEqualInt(1, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
|
||||
if (withrr) {
|
||||
assertEqualInt(archive_format(a),
|
||||
ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
}
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
DEFINE_TEST(test_read_format_isojoliet_bz2)
|
||||
{
|
||||
joliettest(0);
|
||||
|
||||
/* XXXX This doesn't work today; can it be made to work? */
|
||||
#if 0
|
||||
joliettest(1);
|
||||
#else
|
||||
skipping("Mixed Joliet/RR not fully supported yet.");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
141
lib/libarchive/test/test_read_format_isojoliet_long.c
Normal file
141
lib/libarchive/test/test_read_format_isojoliet_long.c
Normal file
@ -0,0 +1,141 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following to rebuild the data for this program:
|
||||
tail -n +35 test_read_format_isojoliet_long.c | /bin/sh
|
||||
|
||||
rm -rf /tmp/iso
|
||||
mkdir /tmp/iso
|
||||
num=0
|
||||
file="";
|
||||
while [ $num -lt 100 ]
|
||||
do
|
||||
num=$((num+10))
|
||||
file="${file}1234567890"
|
||||
done
|
||||
dir="${file}dir"
|
||||
mkdir /tmp/iso/${dir}
|
||||
file="${file}123"
|
||||
echo "hello" > /tmp/iso/${file}
|
||||
ln /tmp/iso/${file} /tmp/iso/hardlink
|
||||
if [ "$(uname -s)" = "Linux" ]; then # gnu coreutils touch doesn't have -h
|
||||
TZ=utc touch -afm -t 197001020000.01 /tmp/iso /tmp/iso/${file} /tmp/iso/${dir}
|
||||
else
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso /tmp/iso/${file} /tmp/iso/${dir}
|
||||
fi
|
||||
F=test_read_format_iso_joliet_long.iso.Z
|
||||
mkhybrid -J -joliet-long -uid 1 -gid 2 /tmp/iso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
rm -rf /tmp/iso
|
||||
exit 1
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isojoliet_long)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_joliet_long.iso.Z";
|
||||
char pathname[104];
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 100; i++)
|
||||
pathname[i] = '0' + ((i+1) % 10);
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_set_options(a, "iso9660:!rockridge"));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* First entry is '.' root directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(".", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(86401, archive_entry_ctime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(0, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
|
||||
/* A directory. */
|
||||
pathname[100] = 'd';
|
||||
pathname[101] = 'i';
|
||||
pathname[102] = 'r';
|
||||
pathname[103] = '\0';
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(pathname, archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
|
||||
/* A regular file with two names (pathname gets returned
|
||||
* first, so it's not marked as a hardlink). */
|
||||
pathname[100] = '1';
|
||||
pathname[101] = '2';
|
||||
pathname[102] = '3';
|
||||
pathname[103] = '\0';
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(pathname, archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assert(archive_entry_hardlink(ae) == NULL);
|
||||
assertEqualInt(6, archive_entry_size(ae));
|
||||
assertEqualInt(0, archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(6, (int)size);
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualInt(0, memcmp(p, "hello\n", 6));
|
||||
|
||||
/* Second name for the same regular file (this happens to be
|
||||
* returned second, so does get marked as a hardlink). */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString(pathname, archive_entry_hardlink(ae));
|
||||
assert(!archive_entry_size_is_set(ae));
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
159
lib/libarchive/test/test_read_format_isojoliet_rr.c
Normal file
159
lib/libarchive/test/test_read_format_isojoliet_rr.c
Normal file
@ -0,0 +1,159 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Based on libarchive/test/test_read_format_isorr_bz2.c with
|
||||
* bugs introduced by Andreas Henriksson <andreas@fatal.se> for
|
||||
* testing ISO9660 image with Joliet extension.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following to rebuild the data for this program:
|
||||
tail -n +35 test_read_format_isojoliet_rr.c | /bin/sh
|
||||
|
||||
rm -rf /tmp/iso
|
||||
mkdir /tmp/iso
|
||||
mkdir /tmp/iso/dir
|
||||
file="long-joliet-file-name.textfile"
|
||||
echo "hello" >/tmp/iso/$file
|
||||
ln /tmp/iso/$file /tmp/iso/hardlink
|
||||
(cd /tmp/iso; ln -s $file symlink)
|
||||
if [ "$(uname -s)" = "Linux" ]; then # gnu coreutils touch doesn't have -h
|
||||
TZ=utc touch -afm -t 197001020000.01 /tmp/iso/hardlink /tmp/iso/$file /tmp/iso/dir
|
||||
TZ=utc touch -afm -t 197001030000.02 /tmp/iso/symlink
|
||||
TZ=utc touch -afm -t 197001020000.01 /tmp/iso
|
||||
else
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso/hardlink /tmp/iso/$file /tmp/iso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso
|
||||
fi
|
||||
F=test_read_format_iso_joliet_rockridge.iso.Z
|
||||
mkhybrid -J -uid 1 -gid 2 /tmp/iso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isojoliet_rr)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_joliet_rockridge.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* First entry is '.' root directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(".", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
|
||||
/* A directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* A regular file with two names ("hardlink" gets returned
|
||||
* first, so it's not marked as a hardlink). */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assert(archive_entry_hardlink(ae) == NULL);
|
||||
assertEqualInt(6, archive_entry_size(ae));
|
||||
assertEqualInt(0, archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(6, (int)size);
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualInt(0, memcmp(p, "hello\n", 6));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
/* mkisofs records their access time. */
|
||||
/*assertEqualInt(86401, archive_entry_atime(ae));*/
|
||||
/* TODO: Actually, libarchive should be able to
|
||||
* compute nlinks correctly even without RR
|
||||
* extensions. See comments in libarchive source. */
|
||||
assertEqualInt(2, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* Second name for the same regular file (this happens to be
|
||||
* returned second, so does get marked as a hardlink). */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_hardlink(ae));
|
||||
assert(!archive_entry_size_is_set(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
/* TODO: See above. */
|
||||
assertEqualInt(2, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("symlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("long-joliet-file-name.textfile",
|
||||
archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_nlink(ae));
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
@ -26,124 +26,178 @@
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
PLEASE use old cdrtools; mkisofs verion is 2.01.
|
||||
This version mkisofs made wrong "SL" System Use Entry of RRIP.
|
||||
|
||||
Execute the following command to rebuild the data for this program:
|
||||
tail -n +32 test_read_format_isorr_bz2.c | /bin/sh
|
||||
tail -n +34 test_read_format_isorr_bz2.c | /bin/sh
|
||||
|
||||
rm -rf /tmp/iso
|
||||
mkdir /tmp/iso
|
||||
mkdir /tmp/iso/dir
|
||||
echo "hello" >/tmp/iso/file
|
||||
dd if=/dev/zero bs=1 count=12345678 >>/tmp/iso/file
|
||||
dd if=/dev/zero count=1 bs=12345678 >>/tmp/iso/file
|
||||
ln /tmp/iso/file /tmp/iso/hardlink
|
||||
(cd /tmp/iso; ln -s file symlink)
|
||||
(cd /tmp/iso; ln -s /tmp/ symlink2)
|
||||
(cd /tmp/iso; ln -s /tmp/../ symlink3)
|
||||
(cd /tmp/iso; ln -s .././../tmp/ symlink4)
|
||||
(cd /tmp/iso; ln -s .///file symlink5)
|
||||
(cd /tmp/iso; ln -s /tmp//../ symlink6)
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso /tmp/iso/file /tmp/iso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink
|
||||
mkhybrid -R -uid 1 -gid 2 /tmp/iso | bzip2 > test_read_format_isorr_bz2.iso.bz2
|
||||
F=test_read_format_isorr_bz2.iso.bz2
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink /tmp/iso/symlink5
|
||||
F=test_read_format_iso_rockridge.iso.Z
|
||||
mkhybrid -R -uid 1 -gid 2 /tmp/iso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isorr_bz2)
|
||||
{
|
||||
const char *refname = "test_read_format_isorr_bz2.iso.bz2";
|
||||
const char *refname = "test_read_format_iso_rockridge.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int r;
|
||||
int i;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
r = archive_read_support_compression_bzip2(a);
|
||||
if (r == ARCHIVE_WARN) {
|
||||
skipping("bzip2 reading not fully supported on this platform");
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
return;
|
||||
}
|
||||
assertEqualInt(0, r);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* First entry is '.' root directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString(".", archive_entry_pathname(ae));
|
||||
assert(S_ISDIR(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(86401, archive_entry_ctime(ae));
|
||||
assertEqualInt(0, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(0, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
/* Retrieve each of the 8 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 10; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
/* A directory. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assert(S_ISDIR(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* A regular file. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assert(S_ISREG(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
assertEqualInt(0, archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* A hardlink to the regular file. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assert(S_ISREG(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualString("file", archive_entry_hardlink(ae));
|
||||
assert(!archive_entry_size_is_set(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
assertEqualString("symlink", archive_entry_pathname(ae));
|
||||
assert(S_ISLNK(archive_entry_stat(ae)->st_mode));
|
||||
assertEqualString("file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
/* Now, we read timestamp recorded by RRIP "TF". */
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
/* Now, we read links recorded by RRIP "PX". */
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("dir", archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("hardlink", archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("file", archive_entry_pathname(ae)) == 0) {
|
||||
/* A hardlink to the regular file. */
|
||||
/* Note: If "hardlink" gets returned before "file",
|
||||
* then "hardlink" will get returned as a regular file
|
||||
* and "file" will get returned as the hardlink.
|
||||
* This test should tolerate that, since it's a
|
||||
* perfectly permissible thing for libarchive to do. */
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString("hardlink", archive_entry_hardlink(ae));
|
||||
assertEqualInt(0, archive_entry_size_is_set(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink2", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp (an absolute path) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink3", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp/.. (with a ".." component) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp/..", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink4", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to a path with ".." and "." components */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(".././../tmp",
|
||||
archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink5", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file with "/" components. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(".///file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink6", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp//..
|
||||
* (with "/" and ".." components) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp//..", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_BZIP2);
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
223
lib/libarchive/test/test_read_format_isorr_ce.c
Normal file
223
lib/libarchive/test/test_read_format_isorr_ce.c
Normal file
@ -0,0 +1,223 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following command to rebuild the data for this program:
|
||||
tail -n +32 test_read_format_isorr_ce.c | /bin/sh
|
||||
|
||||
dirname=/tmp/iso
|
||||
#
|
||||
rm -rf $dirname
|
||||
mkdir $dirname
|
||||
#
|
||||
num=0
|
||||
file=""
|
||||
while [ $num -lt 150 ]
|
||||
do
|
||||
num=$((num+1))
|
||||
file="a$file"
|
||||
done
|
||||
#
|
||||
num=0
|
||||
while [ $num -lt 3 ]
|
||||
do
|
||||
num=$((num+1))
|
||||
file="a$file"
|
||||
echo "hello $((num+150))" > $dirname/$file
|
||||
dd if=/dev/zero count=1 bs=4080 >> $dirname/$file
|
||||
(cd $dirname; ln -s $file sym$num)
|
||||
done
|
||||
#
|
||||
mkdir $dirname/dir
|
||||
#
|
||||
time1="197001020000.01"
|
||||
time2="197001030000.02"
|
||||
TZ=utc touch -afhm -t $time1 $dirname/dir $dirname/aaaa*
|
||||
TZ=utc touch -afhm -t $time2 $dirname/sym*
|
||||
TZ=utc touch -afhm -t $time1 $dirname
|
||||
#
|
||||
F=test_read_format_iso_rockridge_ce.iso.Z
|
||||
mkisofs -R -uid 1 -gid 2 $dirname | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
rm -rf $dirname
|
||||
exit 1
|
||||
*/
|
||||
|
||||
/*
|
||||
* Test reading SUSP "CE" extension is works fine.
|
||||
*/
|
||||
|
||||
static void
|
||||
mkpath(char *p, int len)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
p[i] = 'a';
|
||||
p[len] = '\0';
|
||||
}
|
||||
|
||||
DEFINE_TEST(test_read_format_isorr_ce)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_rockridge_ce.iso.Z";
|
||||
char path1[160];
|
||||
char path2[160];
|
||||
char path3[160];
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
mkpath(path1, 151);
|
||||
mkpath(path2, 152);
|
||||
mkpath(path3, 153);
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* Retrieve each of the 8 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 8; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
/* Now, we read timestamp recorded by RRIP "TF". */
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
/* Now, we read links recorded by RRIP "PX". */
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("dir", archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp(path1, archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString(path1, archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(4090, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello 151\n", 10);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp(path2, archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString(path2, archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(4090, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello 152\n", 10);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp(path3, archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString(path3, archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(4090, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello 153\n", 10);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("sym1", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(path1, archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("sym2", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(path2, archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("sym3", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(path3, archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
204
lib/libarchive/test/test_read_format_isorr_new_bz2.c
Normal file
204
lib/libarchive/test/test_read_format_isorr_new_bz2.c
Normal file
@ -0,0 +1,204 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
|
||||
/*
|
||||
PLEASE use latest cdrtools at least mkisofs version is 2.01.01a63 or later.
|
||||
Old version mkisofs made wrong "SL" System Use Entry of RRIP.
|
||||
|
||||
Execute the following command to rebuild the data for this program:
|
||||
tail -n +34 test_read_format_isorr_new_bz2.c | /bin/sh
|
||||
|
||||
rm -rf /tmp/iso
|
||||
mkdir /tmp/iso
|
||||
mkdir /tmp/iso/dir
|
||||
echo "hello" >/tmp/iso/file
|
||||
dd if=/dev/zero count=1 bs=12345678 >>/tmp/iso/file
|
||||
ln /tmp/iso/file /tmp/iso/hardlink
|
||||
(cd /tmp/iso; ln -s file symlink)
|
||||
(cd /tmp/iso; ln -s /tmp/ symlink2)
|
||||
(cd /tmp/iso; ln -s /tmp/../ symlink3)
|
||||
(cd /tmp/iso; ln -s .././../tmp/ symlink4)
|
||||
(cd /tmp/iso; ln -s .///file symlink5)
|
||||
(cd /tmp/iso; ln -s /tmp//../ symlink6)
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso /tmp/iso/file /tmp/iso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink
|
||||
F=test_read_format_iso_rockridge_new.iso.Z
|
||||
mkhybrid -R -uid 1 -gid 2 /tmp/iso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isorr_new_bz2)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_rockridge_new.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* Retrieve each of the 8 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 10; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
/* Now, we read timestamp recorded by RRIP "TF". */
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
/* Now, we read links recorded by RRIP "PX". */
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("dir", archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("hardlink", archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("file", archive_entry_pathname(ae)) == 0) {
|
||||
/* A hardlink to the regular file. */
|
||||
/* Note: If "hardlink" gets returned before "file",
|
||||
* then "hardlink" will get returned as a regular file
|
||||
* and "file" will get returned as the hardlink.
|
||||
* This test should tolerate that, since it's a
|
||||
* perfectly permissible thing for libarchive to do. */
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString("hardlink", archive_entry_hardlink(ae));
|
||||
assertEqualInt(0, archive_entry_size_is_set(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink2", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp/ (an absolute path) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp/", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink3", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp/../ (with a ".." component) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp/../", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink4", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to a path with ".." and "." components */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(".././../tmp/",
|
||||
archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink5", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file with "/" components. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(".///file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink6", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp//../
|
||||
* (with "/" and ".." components) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp//../", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
270
lib/libarchive/test/test_read_format_isorr_rr_moved.c
Normal file
270
lib/libarchive/test/test_read_format_isorr_rr_moved.c
Normal file
@ -0,0 +1,270 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following command to rebuild the data for this program:
|
||||
tail -n +32 test_read_format_isorr_rr_moved.c | /bin/sh
|
||||
|
||||
dirname=/tmp/iso
|
||||
rm -rf $dirname
|
||||
mkdir -p $dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/dir9/dir10
|
||||
echo "hello" >$dirname/file
|
||||
dd if=/dev/zero count=1 bs=12345678 >>$dirname/file
|
||||
deepfile=$dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/dir9/dir10/deep
|
||||
echo "hello" >$deepfile
|
||||
dd if=/dev/zero count=1 bs=12345678 >>$deepfile
|
||||
time="197001020000.01"
|
||||
TZ=utc touch -afhm -t $time $deepfile
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/dir9/dir10
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8/dir9
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7/dir8
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5/dir6/dir7
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5/dir6
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4/dir5
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3/dir4
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2/dir3
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1/dir2
|
||||
TZ=utc touch -afhm -t $time $dirname/dir1
|
||||
TZ=utc touch -afhm -t $time $dirname/file
|
||||
TZ=utc touch -afhm -t $time $dirname
|
||||
F=test_read_format_isorr_rockridge_moved.iso.Z
|
||||
mkhybrid -R -uid 1 -gid 2 $dirname | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isorr_rr_moved)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_rockridge_rr_moved.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* Retrieve each of the 8 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 13; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
/* Now, we read timestamp recorded by RRIP "TF". */
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
/* Now, we read links recorded by RRIP "PX". */
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("dir1", archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6/dir7",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6/dir7",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9/dir10",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9/dir10",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("file", archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9/dir10/deep",
|
||||
archive_entry_pathname(ae)) == 0) {
|
||||
/* A regular file. */
|
||||
assertEqualString("dir1/dir2/dir3/dir4/dir5/dir6/dir7"
|
||||
"/dir8/dir9/dir10/deep",
|
||||
archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
assertEqualInt(0,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
187
lib/libarchive/test/test_read_format_isozisofs_bz2.c
Normal file
187
lib/libarchive/test/test_read_format_isozisofs_bz2.c
Normal file
@ -0,0 +1,187 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
Execute the following command to rebuild the data for this program:
|
||||
tail -n +32 test_read_format_isozisofs_bz2.c | /bin/sh
|
||||
|
||||
rm -rf /tmp/iso /tmp/ziso
|
||||
mkdir /tmp/iso
|
||||
mkdir /tmp/iso/dir
|
||||
echo "hello" >/tmp/iso/file
|
||||
dd if=/dev/zero count=1 bs=12345678 >>/tmp/iso/file
|
||||
ln /tmp/iso/file /tmp/iso/hardlink
|
||||
(cd /tmp/iso; ln -s file symlink)
|
||||
(cd /tmp/iso; ln -s /tmp/ symlink2)
|
||||
(cd /tmp/iso; ln -s /tmp/../ symlink3)
|
||||
(cd /tmp/iso; ln -s .././../tmp/ symlink4)
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/iso /tmp/iso/file /tmp/iso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/iso/symlink
|
||||
mkzftree /tmp/iso /tmp/ziso
|
||||
TZ=utc touch -afhm -t 197001020000.01 /tmp/ziso /tmp/ziso/file /tmp/ziso/dir
|
||||
TZ=utc touch -afhm -t 197001030000.02 /tmp/ziso/symlink
|
||||
F=test_read_format_iso_zisofs.iso.Z
|
||||
mkhybrid -R -uid 1 -gid 2 -z /tmp/ziso | compress > $F
|
||||
uuencode $F $F > $F.uu
|
||||
exit 1
|
||||
|
||||
*/
|
||||
|
||||
DEFINE_TEST(test_read_format_isozisofs_bz2)
|
||||
{
|
||||
const char *refname = "test_read_format_iso_zisofs.iso.Z";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
const void *p;
|
||||
size_t size;
|
||||
off_t offset;
|
||||
int i;
|
||||
|
||||
extract_reference_file(refname);
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualInt(0, archive_read_support_compression_all(a));
|
||||
assertEqualInt(0, archive_read_support_format_all(a));
|
||||
assertEqualInt(ARCHIVE_OK,
|
||||
archive_read_open_filename(a, refname, 10240));
|
||||
|
||||
/* Retrieve each of the 8 files on the ISO image and
|
||||
* verify that each one is what we expect. */
|
||||
for (i = 0; i < 8; ++i) {
|
||||
assertEqualInt(0, archive_read_next_header(a, &ae));
|
||||
|
||||
if (strcmp(".", archive_entry_pathname(ae)) == 0) {
|
||||
/* '.' root directory. */
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
/* Now, we read timestamp recorded by RRIP "TF". */
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
/* Now, we read links recorded by RRIP "PX". */
|
||||
assertEqualInt(3, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualIntA(a, ARCHIVE_EOF,
|
||||
archive_read_data_block(a, &p, &size, &offset));
|
||||
assertEqualInt((int)size, 0);
|
||||
} else if (strcmp("dir", archive_entry_pathname(ae)) == 0) {
|
||||
/* A directory. */
|
||||
assertEqualString("dir", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
assertEqualInt(2048, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("hardlink", archive_entry_pathname(ae)) == 0) {
|
||||
int r;
|
||||
/* A regular file. */
|
||||
assertEqualString("hardlink", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(12345684, archive_entry_size(ae));
|
||||
r = archive_read_data_block(a, &p, &size, &offset);
|
||||
if (r == ARCHIVE_FAILED) {
|
||||
skipping("Can't read body of ZISOFS entry.");
|
||||
} else {
|
||||
assertEqualInt(ARCHIVE_OK, r);
|
||||
assertEqualInt(0, offset);
|
||||
assertEqualMem(p, "hello\n", 6);
|
||||
}
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("file", archive_entry_pathname(ae)) == 0) {
|
||||
/* A hardlink to the regular file. */
|
||||
/* Note: If "hardlink" gets returned before "file",
|
||||
* then "hardlink" will get returned as a regular file
|
||||
* and "file" will get returned as the hardlink.
|
||||
* This test should tolerate that, since it's a
|
||||
* perfectly permissible thing for libarchive to do. */
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualString("hardlink", archive_entry_hardlink(ae));
|
||||
assertEqualInt(0, archive_entry_size_is_set(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(86401, archive_entry_mtime(ae));
|
||||
assertEqualInt(86401, archive_entry_atime(ae));
|
||||
assertEqualInt(2, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to the regular file. */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("file", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(172802, archive_entry_mtime(ae));
|
||||
assertEqualInt(172802, archive_entry_atime(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink2", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp (an absolute path) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink3", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to /tmp/.. (with a ".." component) */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString("/tmp/..", archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else if (strcmp("symlink4", archive_entry_pathname(ae)) == 0) {
|
||||
/* A symlink to a path with ".." and "." components */
|
||||
assertEqualInt(AE_IFLNK, archive_entry_filetype(ae));
|
||||
assertEqualString(".././../tmp",
|
||||
archive_entry_symlink(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualInt(1, archive_entry_stat(ae)->st_nlink);
|
||||
assertEqualInt(1, archive_entry_uid(ae));
|
||||
assertEqualInt(2, archive_entry_gid(ae));
|
||||
} else {
|
||||
failure("Saw a file that shouldn't have been there");
|
||||
assertEqualString(archive_entry_pathname(ae), "");
|
||||
}
|
||||
}
|
||||
|
||||
/* End of archive. */
|
||||
assertEqualInt(ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
|
||||
/* Verify archive format. */
|
||||
assertEqualInt(archive_compression(a), ARCHIVE_COMPRESSION_COMPRESS);
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_ISO9660_ROCKRIDGE);
|
||||
|
||||
/* Close the archive. */
|
||||
assertEqualInt(0, archive_read_close(a));
|
||||
assertEqualInt(0, archive_read_finish(a));
|
||||
}
|
||||
|
||||
|
||||
@ -25,34 +25,16 @@
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/* Single entry with a hardlink. */
|
||||
static unsigned char archive[] = {
|
||||
"#mtree\n"
|
||||
"file type=file uid=18 mode=0123 size=3\n"
|
||||
"dir type=dir\n"
|
||||
" file\\040with\\040space type=file uid=18\n"
|
||||
" ..\n"
|
||||
"file\\04with\\040space type=file\n"
|
||||
"dir2 type=dir\n"
|
||||
" dir3a type=dir\n"
|
||||
" indir3a type=file\n"
|
||||
"dir2/fullindir2 type=file mode=0777\n"
|
||||
" ..\n"
|
||||
" indir2 type=file\n"
|
||||
" dir3b type=dir\n"
|
||||
" indir3b type=file\n"
|
||||
" ..\n"
|
||||
" ..\n"
|
||||
"notindir type=file\n"
|
||||
"dir2/fullindir2 mode=0644\n"
|
||||
};
|
||||
|
||||
DEFINE_TEST(test_read_format_mtree)
|
||||
static void
|
||||
test_read_format_mtree1(void)
|
||||
{
|
||||
const char reffile[] = "test_read_format_mtree.mtree";
|
||||
char buff[16];
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int fd;
|
||||
FILE *f;
|
||||
|
||||
extract_reference_file(reffile);
|
||||
|
||||
/*
|
||||
* An access error occurred on some platform when mtree
|
||||
@ -60,29 +42,28 @@ DEFINE_TEST(test_read_format_mtree)
|
||||
* the routine which open a directory that we create
|
||||
* "dir" and "dir2" directories.
|
||||
*/
|
||||
assertEqualInt(0, mkdir("dir", 0775));
|
||||
assertEqualInt(0, mkdir("dir2", 0775));
|
||||
assertMakeDir("dir", 0775);
|
||||
assertMakeDir("dir2", 0775);
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_file(a, reffile, 11));
|
||||
|
||||
/*
|
||||
* Read "file", whose data is available on disk.
|
||||
*/
|
||||
fd = open("file", O_WRONLY | O_CREAT, 0777);
|
||||
assert(fd >= 0);
|
||||
assertEqualInt(3, write(fd, "hi\n", 3));
|
||||
close(fd);
|
||||
f = fopen("file", "wb");
|
||||
assert(f != NULL);
|
||||
assertEqualInt(3, fwrite("hi\n", 1, 3, f));
|
||||
fclose(f);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
|
||||
assertEqualString(archive_entry_pathname(ae), "file");
|
||||
assertEqualInt(archive_entry_uid(ae), 18);
|
||||
assert(S_ISREG(archive_entry_mode(ae)));
|
||||
assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
|
||||
assertEqualInt(archive_entry_mode(ae), AE_IFREG | 0123);
|
||||
assertEqualInt(archive_entry_size(ae), 3);
|
||||
assertEqualInt(3, archive_read_data(a, buff, 3));
|
||||
@ -90,13 +71,13 @@ DEFINE_TEST(test_read_format_mtree)
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString(archive_entry_pathname(ae), "dir");
|
||||
assert(S_ISDIR(archive_entry_mode(ae)));
|
||||
assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString(archive_entry_pathname(ae), "dir/file with space");
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString(archive_entry_pathname(ae), "file\\04with space");
|
||||
assertEqualString(archive_entry_pathname(ae), "file with space");
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualString(archive_entry_pathname(ae), "dir2");
|
||||
@ -125,11 +106,38 @@ DEFINE_TEST(test_read_format_mtree)
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
test_read_format_mtree2(void)
|
||||
{
|
||||
static char archive[] =
|
||||
"#mtree\n"
|
||||
"d type=dir content=.\n";
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualInt(archive_format(a), ARCHIVE_FORMAT_MTREE);
|
||||
assertEqualString(archive_entry_pathname(ae), "d");
|
||||
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));
|
||||
}
|
||||
|
||||
|
||||
|
||||
DEFINE_TEST(test_read_format_mtree)
|
||||
{
|
||||
test_read_format_mtree1();
|
||||
test_read_format_mtree2();
|
||||
}
|
||||
|
||||
13
lib/libarchive/test/test_read_format_mtree.mtree.uu
Normal file
13
lib/libarchive/test/test_read_format_mtree.mtree.uu
Normal file
@ -0,0 +1,13 @@
|
||||
$FreeBSD$
|
||||
|
||||
begin 644 test_read_format_mtree.mtree
|
||||
M(VUT<F5E"F9I;&4@='EP93UF:6QE('5I9#TQ."!M;V1E/3`Q,C,@<VEZ93TS
|
||||
M"F1I<B!T>7!E/61I<@H@9FEL95PP-#!W:71H7#`T,'-P86-E('1Y<&4]9FEL
|
||||
M92!U:60],3@*("XN"F9I;&5<,#0P=VET:%PP-#!S<&%C92!T>7!E/69I;&4*
|
||||
M9&ER,B!T>7!E/61I<@H@9&ER,V$@='EP93UD:7(*("!I;F1I<C-A('1Y<&4]
|
||||
M9FEL90ID:7(R+V9U;&QI;F1I<C(@='EP93UF:6QE(&UO9&4],#<W-PH@("XN
|
||||
M"B!I;F1I<C(@='EP93UF:6QE"B!D:7(S8B!T>7!E/61I<@H@(&EN9&ER,V(@
|
||||
M='EP93UF:6QE"B`@+BX*("XN"FYO=&EN9&ER('1Y<&4]9FEL90ID:7(R+V9U
|
||||
3;&QI;F1I<C(@;6]D93TP-C0T"@``
|
||||
`
|
||||
end
|
||||
@ -44,9 +44,15 @@ DEFINE_TEST(test_read_format_pax_bz2)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a,ARCHIVE_OK, archive_read_support_compression_all(a));
|
||||
r = archive_read_support_compression_bzip2(a);
|
||||
if (r != ARCHIVE_OK) {
|
||||
archive_read_close(a);
|
||||
skipping("Bzip2 unavailable");
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a,ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a,ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
|
||||
@ -101,9 +101,9 @@ static unsigned char archive1[] = {
|
||||
static void verify1(struct archive_entry *ae)
|
||||
{
|
||||
/* A hardlink is not a symlink. */
|
||||
assert(!S_ISLNK(archive_entry_mode(ae)));
|
||||
assert(archive_entry_filetype(ae) != AE_IFLNK);
|
||||
/* Nor is it a directory. */
|
||||
assert(!S_ISDIR(archive_entry_mode(ae)));
|
||||
assert(archive_entry_filetype(ae) != AE_IFDIR);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0644);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -132,7 +132,7 @@ static unsigned char archive2[] = {
|
||||
|
||||
static void verify2(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISLNK(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -161,7 +161,7 @@ static unsigned char archive3[] = {
|
||||
|
||||
static void verify3(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISCHR(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFCHR);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -190,7 +190,7 @@ static unsigned char archive4[] = {
|
||||
|
||||
static void verify4(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISBLK(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFBLK);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -219,7 +219,7 @@ static unsigned char archive5[] = {
|
||||
|
||||
static void verify5(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISDIR(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFDIR);
|
||||
assertEqualInt(archive_entry_mtime(ae), 1131430878);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
@ -245,7 +245,7 @@ static unsigned char archive6[] = {
|
||||
|
||||
static void verify6(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISFIFO(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFIFO);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -316,7 +316,7 @@ static unsigned char archiveK[] = {
|
||||
|
||||
static void verifyK(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISLNK(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
@ -402,7 +402,7 @@ static unsigned char archivexL[] = {
|
||||
|
||||
static void verifyxL(struct archive_entry *ae)
|
||||
{
|
||||
assert(S_ISLNK(archive_entry_mode(ae)));
|
||||
assertEqualInt(archive_entry_filetype(ae), AE_IFLNK);
|
||||
assertEqualInt(archive_entry_mode(ae) & 0777, 0755);
|
||||
assertEqualInt(archive_entry_uid(ae), 1000);
|
||||
assertEqualInt(archive_entry_gid(ae), 1000);
|
||||
|
||||
@ -37,9 +37,15 @@ DEFINE_TEST(test_read_format_tbz)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(a));
|
||||
r = archive_read_support_compression_bzip2(a);
|
||||
if (r != ARCHIVE_OK) {
|
||||
skipping("Bzip2 support");
|
||||
archive_read_finish(a);
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
|
||||
60
lib/libarchive/test/test_read_format_tlz.c
Normal file
60
lib/libarchive/test/test_read_format_tlz.c
Normal file
@ -0,0 +1,60 @@
|
||||
/*-
|
||||
* Copyright (c) 2009 Michihiro NAKAJIMA
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
static unsigned char archive[] = {
|
||||
93, 0, 0,128, 0,255,255,255,255,255,255,255,255, 0, 23, 0,
|
||||
51, 80, 24,164,204,238, 45, 77, 28,191, 13,144, 8, 10, 70, 5,
|
||||
173,215, 47,132,237,145,162, 96, 6,131,168,152, 8,135,161,189,
|
||||
73,110,132, 27,195, 52,109,203, 22, 17,168,211, 18,181, 76, 93,
|
||||
120, 88,154,155,244,141,193,206,170,224, 80,137,134, 67, 1, 9,
|
||||
123,121,189, 74,137,197, 63,255,214, 55,119, 0
|
||||
};
|
||||
|
||||
DEFINE_TEST(test_read_format_tlz)
|
||||
{
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
int r;
|
||||
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_compression_all(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));
|
||||
return;
|
||||
}
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, archive, sizeof(archive)));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
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));
|
||||
}
|
||||
@ -29,6 +29,11 @@ static unsigned char testdata[10 * 1024 * 1024];
|
||||
static unsigned char testdatacopy[10 * 1024 * 1024];
|
||||
static unsigned char buff[11 * 1024 * 1024];
|
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
#define open _open
|
||||
#define close _close
|
||||
#endif
|
||||
|
||||
/* Check correct behavior on large reads. */
|
||||
DEFINE_TEST(test_read_large)
|
||||
{
|
||||
@ -38,6 +43,7 @@ DEFINE_TEST(test_read_large)
|
||||
size_t used;
|
||||
struct archive *a;
|
||||
struct archive_entry *entry;
|
||||
FILE *f;
|
||||
|
||||
for (i = 0; i < sizeof(testdata); i++)
|
||||
testdata[i] = (unsigned char)(rand());
|
||||
@ -52,11 +58,7 @@ DEFINE_TEST(test_read_large)
|
||||
assertA(0 == archive_write_header(a, entry));
|
||||
archive_entry_free(entry);
|
||||
assertA(sizeof(testdata) == archive_write_data(a, testdata, sizeof(testdata)));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(a);
|
||||
#else
|
||||
assertA(0 == archive_write_finish(a));
|
||||
#endif
|
||||
|
||||
assert(NULL != (a = archive_read_new()));
|
||||
assertA(0 == archive_read_support_format_all(a));
|
||||
@ -64,11 +66,7 @@ DEFINE_TEST(test_read_large)
|
||||
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)));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertA(0 == archive_read_finish(a));
|
||||
#endif
|
||||
assert(0 == memcmp(testdata, testdatacopy, sizeof(testdata)));
|
||||
|
||||
|
||||
@ -77,18 +75,19 @@ DEFINE_TEST(test_read_large)
|
||||
assertA(0 == archive_read_support_compression_all(a));
|
||||
assertA(0 == archive_read_open_memory(a, buff, sizeof(buff)));
|
||||
assertA(0 == archive_read_next_header(a, &entry));
|
||||
assert(0 < (tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT | O_BINARY, 0755)));
|
||||
#if defined(__BORLANDC__)
|
||||
tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT | O_BINARY);
|
||||
#else
|
||||
tmpfilefd = open(tmpfilename, O_WRONLY | O_CREAT | O_BINARY, 0755);
|
||||
#endif
|
||||
assert(0 < tmpfilefd);
|
||||
assertA(0 == archive_read_data_into_fd(a, tmpfilefd));
|
||||
close(tmpfilefd);
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_read_finish(a);
|
||||
#else
|
||||
assertA(0 == archive_read_finish(a));
|
||||
#endif
|
||||
tmpfilefd = open(tmpfilename, O_RDONLY);
|
||||
read(tmpfilefd, testdatacopy, sizeof(testdatacopy));
|
||||
close(tmpfilefd);
|
||||
assert(0 == memcmp(testdata, testdatacopy, sizeof(testdata)));
|
||||
|
||||
unlink(tmpfilename);
|
||||
f = fopen(tmpfilename, "rb");
|
||||
assertEqualInt(sizeof(testdatacopy),
|
||||
fread(testdatacopy, 1, sizeof(testdatacopy), f));
|
||||
fclose(f);
|
||||
assert(0 == memcmp(testdata, testdatacopy, sizeof(testdata)));
|
||||
}
|
||||
|
||||
@ -190,7 +190,7 @@ memory_read_skip(struct archive *a, void *_private, off_t skip)
|
||||
}
|
||||
if (private->filebytes > 0) {
|
||||
if (private->filebytes < skip)
|
||||
skip = private->filebytes;
|
||||
skip = (off_t)private->filebytes;
|
||||
private->filebytes -= skip;
|
||||
} else {
|
||||
skip = 0;
|
||||
|
||||
@ -38,12 +38,9 @@ DEFINE_TEST(test_write_compress_program)
|
||||
size_t used;
|
||||
int blocksize = 1024;
|
||||
int r;
|
||||
const char *compprog, *decompprog;
|
||||
|
||||
decompprog = external_gzip_program(1);
|
||||
if ((compprog = external_gzip_program(0)) == NULL) {
|
||||
skipping("There is no gzip compression "
|
||||
"program in this platform");
|
||||
if (!canGzip()) {
|
||||
skipping("Cannot run 'gzip'");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -51,7 +48,7 @@ DEFINE_TEST(test_write_compress_program)
|
||||
/* Write it through an external "gzip" program. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertA(0 == archive_write_set_format_ustar(a));
|
||||
r = archive_write_set_compression_program(a, compprog);
|
||||
r = archive_write_set_compression_program(a, "gzip");
|
||||
if (r == ARCHIVE_FATAL) {
|
||||
skipping("Write compression via external "
|
||||
"program unsupported on this platform");
|
||||
@ -91,8 +88,8 @@ DEFINE_TEST(test_write_compress_program)
|
||||
/* The compression_gzip() handler will fall back to gunzip
|
||||
* automatically, but if we know gunzip isn't available, then
|
||||
* skip the rest. */
|
||||
if (r != ARCHIVE_OK && decompprog == NULL) {
|
||||
skipping("No gzip decompression is available; "
|
||||
if (r != ARCHIVE_OK && !canGunzip()) {
|
||||
skipping("No libz and no gunzip program, "
|
||||
"unable to verify gzip compression");
|
||||
assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
|
||||
return;
|
||||
|
||||
@ -28,6 +28,14 @@ __FBSDID("$FreeBSD$");
|
||||
#if ARCHIVE_VERSION_NUMBER >= 1009000
|
||||
|
||||
#define UMASK 022
|
||||
/*
|
||||
* When comparing mode values, ignore high-order bits
|
||||
* that are set on some OSes. This should cover the bits
|
||||
* we're interested in (standard mode bits + file type bits)
|
||||
* while ignoring extra markers such as Haiku/BeOS index
|
||||
* flags.
|
||||
*/
|
||||
#define MODE_MASK 0777777
|
||||
|
||||
static void create(struct archive_entry *ae, const char *msg)
|
||||
{
|
||||
@ -46,14 +54,15 @@ static void create(struct archive_entry *ae, const char *msg)
|
||||
#endif
|
||||
/* Test the entries on disk. */
|
||||
assert(0 == stat(archive_entry_pathname(ae), &st));
|
||||
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
|
||||
st.st_mode, archive_entry_mode(ae));
|
||||
failure("%s", msg);
|
||||
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
/* When verifying a dir, ignore the S_ISGID bit, as some systems set
|
||||
* that automatically. */
|
||||
if (archive_entry_filetype(ae) == AE_IFDIR)
|
||||
st.st_mode &= ~S_ISGID;
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
assertEqualInt(st.st_mode, archive_entry_mode(ae) & ~UMASK);
|
||||
assertEqualInt(st.st_mode & MODE_MASK,
|
||||
archive_entry_mode(ae) & ~UMASK & MODE_MASK);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -61,8 +70,6 @@ static void create_reg_file(struct archive_entry *ae, const char *msg)
|
||||
{
|
||||
static const char data[]="abcdefghijklmnopqrstuvwxyz";
|
||||
struct archive *ad;
|
||||
struct stat st;
|
||||
time_t now;
|
||||
|
||||
/* Write the entry to disk. */
|
||||
assert((ad = archive_write_disk_new()) != NULL);
|
||||
@ -96,28 +103,20 @@ static void create_reg_file(struct archive_entry *ae, const char *msg)
|
||||
assertEqualInt(0, archive_write_finish(ad));
|
||||
#endif
|
||||
/* Test the entries on disk. */
|
||||
assert(0 == stat(archive_entry_pathname(ae), &st));
|
||||
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
|
||||
st.st_mode, archive_entry_mode(ae));
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
|
||||
#endif
|
||||
assertEqualInt(st.st_size, sizeof(data));
|
||||
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
|
||||
assertFileSize(archive_entry_pathname(ae), sizeof(data));
|
||||
/* test_write_disk_times has more detailed tests of this area. */
|
||||
assertEqualInt(st.st_mtime, 123456789);
|
||||
failure("No atime was specified, so atime should get set to current time");
|
||||
now = time(NULL);
|
||||
assert(st.st_atime <= now && st.st_atime > now - 5);
|
||||
assertFileMtime(archive_entry_pathname(ae), 123456789, 0);
|
||||
failure("No atime given, so atime should get set to current time");
|
||||
assertFileAtimeRecent(archive_entry_pathname(ae));
|
||||
}
|
||||
|
||||
static void create_reg_file2(struct archive_entry *ae, const char *msg)
|
||||
{
|
||||
const int datasize = 100000;
|
||||
char *data;
|
||||
char *compare;
|
||||
struct archive *ad;
|
||||
struct stat st;
|
||||
int i, fd;
|
||||
int i;
|
||||
|
||||
data = malloc(datasize);
|
||||
for (i = 0; i < datasize; i++)
|
||||
@ -137,26 +136,12 @@ static void create_reg_file2(struct archive_entry *ae, const char *msg)
|
||||
archive_write_data_block(ad, data + i, 1000, i));
|
||||
}
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(ad);
|
||||
#else
|
||||
assertEqualInt(0, archive_write_finish(ad));
|
||||
#endif
|
||||
/* Test the entries on disk. */
|
||||
assert(0 == stat(archive_entry_pathname(ae), &st));
|
||||
failure("st.st_mode=%o archive_entry_mode(ae)=%o",
|
||||
st.st_mode, archive_entry_mode(ae));
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
assertEqualInt(st.st_mode, (archive_entry_mode(ae) & ~UMASK));
|
||||
#endif
|
||||
assertEqualInt(st.st_size, i);
|
||||
|
||||
compare = malloc(datasize);
|
||||
fd = open(archive_entry_pathname(ae), O_RDONLY);
|
||||
assertEqualInt(datasize, read(fd, compare, datasize));
|
||||
close(fd);
|
||||
assert(memcmp(compare, data, datasize) == 0);
|
||||
free(compare);
|
||||
/* Test the entries on disk. */
|
||||
assertIsReg(archive_entry_pathname(ae), archive_entry_mode(ae) & 0777);
|
||||
assertFileSize(archive_entry_pathname(ae), i);
|
||||
assertFileContents(data, datasize, archive_entry_pathname(ae));
|
||||
free(data);
|
||||
}
|
||||
|
||||
@ -268,7 +253,7 @@ DEFINE_TEST(test_write_disk)
|
||||
struct archive_entry *ae;
|
||||
|
||||
/* Force the umask to something predictable. */
|
||||
umask(UMASK);
|
||||
assertUmask(UMASK);
|
||||
|
||||
/* A regular file. */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
|
||||
@ -42,13 +42,13 @@ DEFINE_TEST(test_write_disk_failures)
|
||||
int fd;
|
||||
|
||||
/* Force the umask to something predictable. */
|
||||
umask(UMASK);
|
||||
assertUmask(UMASK);
|
||||
|
||||
/* A directory that we can't write to. */
|
||||
assertEqualInt(0, mkdir("dir", 0555));
|
||||
assertMakeDir("dir", 0555);
|
||||
|
||||
/* Can we? */
|
||||
fd = open("dir/testfile", O_WRONLY | O_CREAT, 0777);
|
||||
fd = open("dir/testfile", O_WRONLY | O_CREAT | O_BINARY, 0777);
|
||||
if (fd >= 0) {
|
||||
/* Apparently, we can, so the test below won't work. */
|
||||
close(fd);
|
||||
|
||||
@ -43,16 +43,16 @@ __FBSDID("$FreeBSD$");
|
||||
*/
|
||||
DEFINE_TEST(test_write_disk_hardlink)
|
||||
{
|
||||
#if ARCHIVE_VERSION_NUMBER < 1009000
|
||||
skipping("archive_write_disk_hardlink tests");
|
||||
#if defined(__HAIKU__)
|
||||
skipping("archive_write_disk_hardlink; hardlinks are not supported on bfs");
|
||||
#else
|
||||
static const char data[]="abcdefghijklmnopqrstuvwxyz";
|
||||
struct archive *ad;
|
||||
struct archive_entry *ae;
|
||||
struct stat st, st2;
|
||||
int r;
|
||||
|
||||
/* Force the umask to something predictable. */
|
||||
umask(UMASK);
|
||||
assertUmask(UMASK);
|
||||
|
||||
/* Write entries to disk. */
|
||||
assert((ad = archive_write_disk_new()) != NULL);
|
||||
@ -79,10 +79,12 @@ DEFINE_TEST(test_write_disk_hardlink)
|
||||
archive_entry_set_mode(ae, S_IFREG | 0642);
|
||||
archive_entry_set_size(ae, 0);
|
||||
archive_entry_copy_hardlink(ae, "link1a");
|
||||
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
|
||||
assertEqualInt(ARCHIVE_WARN,
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r >= ARCHIVE_WARN) {
|
||||
assertEqualInt(ARCHIVE_WARN,
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
}
|
||||
archive_entry_free(ae);
|
||||
|
||||
/*
|
||||
@ -107,10 +109,12 @@ DEFINE_TEST(test_write_disk_hardlink)
|
||||
archive_entry_set_mode(ae, S_IFREG | 0642);
|
||||
archive_entry_unset_size(ae);
|
||||
archive_entry_copy_hardlink(ae, "link2a");
|
||||
assertEqualIntA(ad, 0, archive_write_header(ad, ae));
|
||||
assertEqualInt(ARCHIVE_WARN,
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r >= ARCHIVE_WARN) {
|
||||
assertEqualInt(ARCHIVE_WARN,
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
}
|
||||
archive_entry_free(ae);
|
||||
|
||||
/*
|
||||
@ -134,9 +138,12 @@ DEFINE_TEST(test_write_disk_hardlink)
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
archive_entry_set_size(ae, sizeof(data));
|
||||
archive_entry_copy_hardlink(ae, "link3a");
|
||||
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));
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r > ARCHIVE_WARN) {
|
||||
assertEqualInt(sizeof(data),
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
}
|
||||
archive_entry_free(ae);
|
||||
|
||||
/*
|
||||
@ -164,34 +171,26 @@ DEFINE_TEST(test_write_disk_hardlink)
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
archive_entry_set_size(ae, sizeof(data));
|
||||
archive_entry_copy_hardlink(ae, "link4a");
|
||||
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));
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r > ARCHIVE_FAILED) {
|
||||
assertEqualInt(sizeof(data),
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
}
|
||||
archive_entry_free(ae);
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(ad);
|
||||
#else
|
||||
assertEqualInt(0, archive_write_finish(ad));
|
||||
#endif
|
||||
|
||||
/* Test the entries on disk. */
|
||||
|
||||
/* Test #1 */
|
||||
assert(0 == stat("link1a", &st));
|
||||
/* If the hardlink was successfully created and the archive
|
||||
* doesn't carry data for it, we consider it to be
|
||||
* non-authoritive for meta data as well. This is consistent
|
||||
* with GNU tar and BSD pax. */
|
||||
assertEqualInt(st.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st.st_size, sizeof(data));
|
||||
assertEqualInt(st.st_nlink, 2);
|
||||
|
||||
assert(0 == stat("link1b", &st2));
|
||||
assertEqualInt(st.st_mode, st2.st_mode);
|
||||
assertEqualInt(st.st_size, st2.st_size);
|
||||
assertEqualInt(st.st_nlink, st2.st_nlink);
|
||||
assertEqualInt(st.st_ino, st2.st_ino);
|
||||
assertEqualInt(st.st_dev, st2.st_dev);
|
||||
assertIsReg("link1a", 0755 & ~UMASK);
|
||||
assertFileSize("link1a", sizeof(data));
|
||||
assertFileNLinks("link1a", 2);
|
||||
assertIsHardlink("link1a", "link1b");
|
||||
|
||||
/* Test #2: Should produce identical results to test #1 */
|
||||
/* Note that marking a hardlink with size = 0 is treated the
|
||||
@ -200,42 +199,21 @@ DEFINE_TEST(test_write_disk_hardlink)
|
||||
* relied on size == 0) and partly to match the model used by
|
||||
* common file formats that store a size of zero for
|
||||
* hardlinks. */
|
||||
assert(0 == stat("link2a", &st));
|
||||
assertEqualInt(st.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st.st_size, sizeof(data));
|
||||
assertEqualInt(st.st_nlink, 2);
|
||||
|
||||
assert(0 == stat("link2b", &st2));
|
||||
assertEqualInt(st.st_mode, st2.st_mode);
|
||||
assertEqualInt(st.st_size, st2.st_size);
|
||||
assertEqualInt(st.st_nlink, st2.st_nlink);
|
||||
assertEqualInt(st.st_ino, st2.st_ino);
|
||||
assertEqualInt(st.st_dev, st2.st_dev);
|
||||
assertIsReg("link2a", 0755 & ~UMASK);
|
||||
assertFileSize("link2a", sizeof(data));
|
||||
assertFileNLinks("link2a", 2);
|
||||
assertIsHardlink("link2a", "link2b");
|
||||
|
||||
/* Test #3 */
|
||||
assert(0 == stat("link3a", &st));
|
||||
assertEqualInt(st.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st.st_size, sizeof(data));
|
||||
assertEqualInt(st.st_nlink, 2);
|
||||
|
||||
assert(0 == stat("link3b", &st2));
|
||||
assertEqualInt(st2.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st2.st_size, sizeof(data));
|
||||
assertEqualInt(st2.st_nlink, 2);
|
||||
assertEqualInt(st.st_ino, st2.st_ino);
|
||||
assertEqualInt(st.st_dev, st2.st_dev);
|
||||
assertIsReg("link3a", 0755 & ~UMASK);
|
||||
assertFileSize("link3a", sizeof(data));
|
||||
assertFileNLinks("link3a", 2);
|
||||
assertIsHardlink("link3a", "link3b");
|
||||
|
||||
/* Test #4 */
|
||||
assert(0 == stat("link4a", &st));
|
||||
assertEqualInt(st.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st.st_size, sizeof(data));
|
||||
assertEqualInt(st.st_nlink, 2);
|
||||
|
||||
assert(0 == stat("link4b", &st2));
|
||||
assertEqualInt(st2.st_mode & E_MASK, (S_IFREG | 0755) & ~UMASK);
|
||||
assertEqualInt(st2.st_size, sizeof(data));
|
||||
assertEqualInt(st2.st_nlink, 2);
|
||||
assertEqualInt(st.st_ino, st2.st_ino);
|
||||
assertEqualInt(st.st_dev, st2.st_dev);
|
||||
assertIsReg("link4a", 0755 & ~UMASK);
|
||||
assertFileNLinks("link4a", 2);
|
||||
assertFileSize("link4a", sizeof(data));
|
||||
assertIsHardlink("link4a", "link4b");
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -60,7 +60,7 @@ searchgid(void)
|
||||
_searched = 1;
|
||||
|
||||
/* Create a file on disk in the current default dir. */
|
||||
fd = open("test_gid", O_CREAT, 0664);
|
||||
fd = open("test_gid", O_CREAT | O_BINARY, 0664);
|
||||
failure("Couldn't create a file for gid testing.");
|
||||
assert(fd > 0);
|
||||
|
||||
@ -132,6 +132,8 @@ DEFINE_TEST(test_write_disk_perms)
|
||||
struct archive_entry *ae;
|
||||
struct stat st;
|
||||
|
||||
assertUmask(UMASK);
|
||||
|
||||
/*
|
||||
* Set ownership of the current directory to the group of this
|
||||
* process. Otherwise, the SGID tests below fail if the
|
||||
@ -182,7 +184,7 @@ DEFINE_TEST(test_write_disk_perms)
|
||||
|
||||
/* Overwrite an existing dir. */
|
||||
/* For dir, the first perms should get left. */
|
||||
assert(mkdir("dir_overwrite_0744", 0744) == 0);
|
||||
assertMakeDir("dir_overwrite_0744", 0744);
|
||||
/* Check original perms. */
|
||||
assert(0 == stat("dir_overwrite_0744", &st));
|
||||
failure("dir_overwrite_0744: st.st_mode=%o", st.st_mode);
|
||||
|
||||
@ -36,13 +36,13 @@ DEFINE_TEST(test_write_disk_secure)
|
||||
{
|
||||
#if ARCHIVE_VERSION_NUMBER < 1009000
|
||||
skipping("archive_write_disk interface");
|
||||
#else
|
||||
#elif !defined(_WIN32) || defined(__CYGWIN__)
|
||||
struct archive *a;
|
||||
struct archive_entry *ae;
|
||||
struct stat st;
|
||||
|
||||
/* Start with a known umask. */
|
||||
umask(UMASK);
|
||||
assertUmask(UMASK);
|
||||
|
||||
/* Create an archive_write_disk object. */
|
||||
assert((a = archive_write_disk_new()) != NULL);
|
||||
@ -55,7 +55,6 @@ DEFINE_TEST(test_write_disk_secure)
|
||||
archive_entry_free(ae);
|
||||
assert(0 == archive_write_finish_entry(a));
|
||||
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
/* Write a symlink to the dir above. */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "link_to_dir");
|
||||
@ -150,7 +149,6 @@ DEFINE_TEST(test_write_disk_secure)
|
||||
assertEqualInt(0, lstat("link_to_dir4", &st));
|
||||
assert(S_ISDIR(st.st_mode));
|
||||
archive_entry_free(ae);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* As above, but a link to a non-dir, so the link should get replaced.
|
||||
@ -180,14 +178,8 @@ DEFINE_TEST(test_write_disk_secure)
|
||||
assert(S_ISDIR(st.st_mode));
|
||||
archive_entry_free(ae);
|
||||
|
||||
|
||||
#if ARCHIVE_VERSION_NUMBER < 2000000
|
||||
archive_write_finish(a);
|
||||
#else
|
||||
assert(0 == archive_write_finish(a));
|
||||
#endif
|
||||
|
||||
#if !defined(_WIN32) || defined(__CYGWIN__)
|
||||
/* Test the entries on disk. */
|
||||
assert(0 == lstat("dir", &st));
|
||||
failure("dir: st.st_mode=%o", st.st_mode);
|
||||
@ -220,5 +212,4 @@ DEFINE_TEST(test_write_disk_secure)
|
||||
failure("link_to_dir2/filec: st.st_mode=%o", st.st_mode);
|
||||
assert((st.st_mode & 07777) == 0755);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -40,7 +40,7 @@ verify_write_data(struct archive *a, int sparse)
|
||||
size_t buff_size = 64 * 1024;
|
||||
char *buff, *p;
|
||||
const char *msg = sparse ? "sparse" : "non-sparse";
|
||||
int fd;
|
||||
FILE *f;
|
||||
|
||||
buff = malloc(buff_size);
|
||||
assert(buff != NULL);
|
||||
@ -78,12 +78,12 @@ verify_write_data(struct archive *a, int sparse)
|
||||
/* Test the entry on disk. */
|
||||
assert(0 == stat(archive_entry_pathname(ae), &st));
|
||||
assertEqualInt(st.st_size, 8 * buff_size);
|
||||
fd = open(archive_entry_pathname(ae), O_RDONLY);
|
||||
if (!assert(fd >= 0))
|
||||
f = fopen(archive_entry_pathname(ae), "rb");
|
||||
if (!assert(f != NULL))
|
||||
return;
|
||||
|
||||
/* Check first block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
failure("%s", msg);
|
||||
assertEqualMem(buff, data, sizeof(data));
|
||||
for (p = buff + sizeof(data); p < buff + buff_size; ++p) {
|
||||
@ -93,7 +93,7 @@ verify_write_data(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check second block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
for (p = buff; p < buff + buff_size; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
if (p == buff + buff_size / 2 - 3) {
|
||||
@ -104,7 +104,7 @@ verify_write_data(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check third block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
for (p = buff; p < buff + buff_size - sizeof(data); ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
if (!assertEqualInt(0, *p))
|
||||
@ -115,7 +115,7 @@ verify_write_data(struct archive *a, int sparse)
|
||||
|
||||
/* XXX more XXX */
|
||||
|
||||
assertEqualInt(0, close(fd));
|
||||
assertEqualInt(0, fclose(f));
|
||||
archive_entry_free(ae);
|
||||
free(buff);
|
||||
}
|
||||
@ -132,7 +132,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
size_t buff_size = 64 * 1024;
|
||||
char *buff, *p;
|
||||
const char *msg = sparse ? "sparse" : "non-sparse";
|
||||
int fd;
|
||||
FILE *f;
|
||||
|
||||
buff = malloc(buff_size);
|
||||
assert(buff != NULL);
|
||||
@ -174,12 +174,12 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
/* Test the entry on disk. */
|
||||
assert(0 == stat(archive_entry_pathname(ae), &st));
|
||||
assertEqualInt(st.st_size, 8 * buff_size);
|
||||
fd = open(archive_entry_pathname(ae), O_RDONLY);
|
||||
if (!assert(fd >= 0))
|
||||
f = fopen(archive_entry_pathname(ae), "rb");
|
||||
if (!assert(f != NULL))
|
||||
return;
|
||||
|
||||
/* Check 100-byte gap at beginning */
|
||||
assertEqualInt(100, read(fd, buff, 100));
|
||||
assertEqualInt(100, fread(buff, 1, 100, f));
|
||||
failure("%s", msg);
|
||||
for (p = buff; p < buff + 100; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
@ -188,7 +188,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check first block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
failure("%s", msg);
|
||||
assertEqualMem(buff, data, sizeof(data));
|
||||
for (p = buff + sizeof(data); p < buff + buff_size; ++p) {
|
||||
@ -198,7 +198,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check 100-byte gap */
|
||||
assertEqualInt(100, read(fd, buff, 100));
|
||||
assertEqualInt(100, fread(buff, 1, 100, f));
|
||||
failure("%s", msg);
|
||||
for (p = buff; p < buff + 100; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
@ -207,7 +207,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check second block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
for (p = buff; p < buff + buff_size; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
if (p == buff + buff_size / 2 - 3) {
|
||||
@ -218,7 +218,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check 100-byte gap */
|
||||
assertEqualInt(100, read(fd, buff, 100));
|
||||
assertEqualInt(100, fread(buff, 1, 100, f));
|
||||
failure("%s", msg);
|
||||
for (p = buff; p < buff + 100; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
@ -227,7 +227,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
}
|
||||
|
||||
/* Check third block. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
for (p = buff; p < buff + buff_size - sizeof(data); ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
if (!assertEqualInt(0, *p))
|
||||
@ -237,7 +237,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
assertEqualMem(buff + buff_size - sizeof(data), data, sizeof(data));
|
||||
|
||||
/* Check another block size beyond last we wrote. */
|
||||
assertEqualInt(buff_size, read(fd, buff, buff_size));
|
||||
assertEqualInt(buff_size, fread(buff, 1, buff_size, f));
|
||||
failure("%s", msg);
|
||||
for (p = buff; p < buff + buff_size; ++p) {
|
||||
failure("offset: %d, %s", (int)(p - buff), msg);
|
||||
@ -248,7 +248,7 @@ verify_write_data_block(struct archive *a, int sparse)
|
||||
|
||||
/* XXX more XXX */
|
||||
|
||||
assertEqualInt(0, close(fd));
|
||||
assertEqualInt(0, fclose(f));
|
||||
free(buff);
|
||||
archive_entry_free(ae);
|
||||
}
|
||||
|
||||
117
lib/libarchive/test/test_write_disk_symlink.c
Normal file
117
lib/libarchive/test/test_write_disk_symlink.c
Normal file
@ -0,0 +1,117 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2007 Tim Kientzle
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
/*
|
||||
* Exercise symlink recreation.
|
||||
*/
|
||||
DEFINE_TEST(test_write_disk_symlink)
|
||||
{
|
||||
static const char data[]="abcdefghijklmnopqrstuvwxyz";
|
||||
struct archive *ad;
|
||||
struct archive_entry *ae;
|
||||
int r;
|
||||
|
||||
if (!canSymlink()) {
|
||||
skipping("Symlinks not supported");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Write entries to disk. */
|
||||
assert((ad = archive_write_disk_new()) != NULL);
|
||||
|
||||
/*
|
||||
* First, create a regular file then a symlink to that file.
|
||||
*/
|
||||
|
||||
/* Regular file: link1a */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "link1a");
|
||||
archive_entry_set_mode(ae, AE_IFREG | 0755);
|
||||
archive_entry_set_size(ae, sizeof(data));
|
||||
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));
|
||||
archive_entry_free(ae);
|
||||
|
||||
/* Symbolic Link: link1b -> link1a */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "link1b");
|
||||
archive_entry_set_mode(ae, AE_IFLNK | 0642);
|
||||
archive_entry_set_size(ae, 0);
|
||||
archive_entry_copy_symlink(ae, "link1a");
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r >= ARCHIVE_WARN)
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
archive_entry_free(ae);
|
||||
|
||||
/*
|
||||
* We should be able to do this in the other order as well,
|
||||
* of course.
|
||||
*/
|
||||
|
||||
/* Symbolic link: link2b -> link2a */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "link2b");
|
||||
archive_entry_set_mode(ae, AE_IFLNK | 0642);
|
||||
archive_entry_unset_size(ae);
|
||||
archive_entry_copy_symlink(ae, "link2a");
|
||||
assertEqualIntA(ad, 0, r = archive_write_header(ad, ae));
|
||||
if (r >= ARCHIVE_WARN) {
|
||||
assertEqualInt(ARCHIVE_WARN,
|
||||
archive_write_data(ad, data, sizeof(data)));
|
||||
assertEqualIntA(ad, 0, archive_write_finish_entry(ad));
|
||||
}
|
||||
archive_entry_free(ae);
|
||||
|
||||
/* File: link2a */
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_copy_pathname(ae, "link2a");
|
||||
archive_entry_set_mode(ae, AE_IFREG | 0755);
|
||||
archive_entry_set_size(ae, sizeof(data));
|
||||
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));
|
||||
archive_entry_free(ae);
|
||||
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish(ad));
|
||||
|
||||
/* Test the entries on disk. */
|
||||
|
||||
/* Test #1 */
|
||||
assertIsReg("link1a", -1);
|
||||
assertFileSize("link1a", sizeof(data));
|
||||
assertFileNLinks("link1a", 1);
|
||||
assertIsSymlink("link1b", "link1a");
|
||||
|
||||
/* Test #2: Should produce identical results to test #1 */
|
||||
assertIsReg("link2a", -1);
|
||||
assertFileSize("link2a", sizeof(data));
|
||||
assertFileNLinks("link2a", 1);
|
||||
assertIsSymlink("link2b", "link2a");
|
||||
}
|
||||
@ -35,8 +35,6 @@ DEFINE_TEST(test_write_disk_times)
|
||||
{
|
||||
struct archive *a;
|
||||
struct archive_entry *ae;
|
||||
struct stat st;
|
||||
time_t now = time(NULL);
|
||||
|
||||
/* Create an archive_write_disk object. */
|
||||
assert((a = archive_write_disk_new()) != NULL);
|
||||
@ -55,9 +53,8 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify */
|
||||
assertEqualInt(0, stat("file1", &st));
|
||||
assertEqualInt(123456, st.st_atime);
|
||||
assertEqualInt(234567, st.st_mtime);
|
||||
assertFileAtime("file1", 123456, 0);
|
||||
assertFileMtime("file1", 234567, 0);
|
||||
|
||||
/*
|
||||
* mtime specified, but not atime
|
||||
@ -69,11 +66,8 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify: Current atime and mtime as specified. */
|
||||
assertEqualInt(0, stat("file2", &st));
|
||||
assertEqualInt(234567, st.st_mtime);
|
||||
failure("now: %ld st.st_atime: %ld", (long)now, (long)st.st_atime);
|
||||
assert(st.st_atime >= now && st.st_atime < now + 3);
|
||||
assertFileMtime("file2", 234567, 0);
|
||||
assertFileAtimeRecent("file2");
|
||||
|
||||
/*
|
||||
* atime specified, but not mtime
|
||||
@ -86,10 +80,8 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify: Current mtime and atime as specified. */
|
||||
assertEqualInt(0, stat("file3", &st));
|
||||
assertEqualInt(345678, st.st_atime);
|
||||
failure("now: %ld st.st_mtime: %ld", (long)now, (long)st.st_mtime);
|
||||
assert(st.st_mtime >= now && st.st_mtime < now + 3);
|
||||
assertFileAtime("file3", 345678, 0);
|
||||
assertFileMtimeRecent("file3");
|
||||
|
||||
/*
|
||||
* Neither atime nor mtime specified.
|
||||
@ -101,11 +93,8 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify: Current mtime and atime. */
|
||||
assertEqualInt(0, stat("file4", &st));
|
||||
failure("now: %ld st.st_atime: %ld", (long)now, (long)st.st_atime);
|
||||
assert(st.st_atime >= now && st.st_atime < now + 3);
|
||||
failure("now: %ld st.st_mtime: %ld", (long)now, (long)st.st_mtime);
|
||||
assert(st.st_mtime >= now && st.st_mtime < now + 3);
|
||||
assertFileAtimeRecent("file4");
|
||||
assertFileMtimeRecent("file4");
|
||||
|
||||
#if defined(__FreeBSD__)
|
||||
/*
|
||||
@ -120,12 +109,8 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify */
|
||||
/* FreeBSD can only store usec resolution, hence rounding here. */
|
||||
assertEqualInt(0, stat("file10", &st));
|
||||
assertEqualInt(1234567, st.st_atime);
|
||||
assertEqualInt(23000, st.st_atimespec.tv_nsec);
|
||||
assertEqualInt(2345678, st.st_mtime);
|
||||
assertEqualInt(4000, st.st_mtimespec.tv_nsec);
|
||||
assertFileMtime("file10", 2345678, 4567);
|
||||
assertFileAtime("file10", 1234567, 23456);
|
||||
|
||||
/*
|
||||
* Birthtime, mtime and atime on FreeBSD
|
||||
@ -141,14 +126,9 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify */
|
||||
/* FreeBSD can only store usec resolution, hence rounding here. */
|
||||
assertEqualInt(0, stat("file11", &st));
|
||||
assertEqualInt(1234567, st.st_atime);
|
||||
assertEqualInt(23000, st.st_atimespec.tv_nsec);
|
||||
assertEqualInt(3456789, st.st_birthtime);
|
||||
assertEqualInt(12000, st.st_birthtimespec.tv_nsec);
|
||||
assertEqualInt(12345678, st.st_mtime);
|
||||
assertEqualInt(4000, st.st_mtimespec.tv_nsec);
|
||||
assertFileAtime("file11", 1234567, 23456);
|
||||
assertFileBirthtime("file11", 3456789, 12345);
|
||||
assertFileMtime("file11", 12345678, 4567);
|
||||
|
||||
/*
|
||||
* Birthtime only on FreeBSD.
|
||||
@ -161,14 +141,9 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify */
|
||||
/* FreeBSD can only store usec resolution, hence rounding here. */
|
||||
assertEqualInt(0, stat("file12", &st));
|
||||
assertEqualInt(3456789, st.st_birthtime);
|
||||
assertEqualInt(12000, st.st_birthtimespec.tv_nsec);
|
||||
failure("now: %ld st.st_atime: %ld", (long)now, (long)st.st_atime);
|
||||
assert(st.st_atime >= now && st.st_atime < now + 3);
|
||||
failure("now: %ld st.st_mtime: %ld", (long)now, (long)st.st_mtime);
|
||||
assert(st.st_mtime >= now && st.st_mtime < now + 3);
|
||||
assertFileAtimeRecent("file12");
|
||||
assertFileBirthtime("file12", 3456789, 12345);
|
||||
assertFileMtimeRecent("file12");
|
||||
|
||||
/*
|
||||
* mtime only on FreeBSD.
|
||||
@ -181,14 +156,9 @@ DEFINE_TEST(test_write_disk_times)
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish_entry(a));
|
||||
archive_entry_free(ae);
|
||||
/* Verify */
|
||||
/* FreeBSD can only store usec resolution, hence rounding here. */
|
||||
assertEqualInt(0, stat("file13", &st));
|
||||
assertEqualInt(4567890, st.st_birthtime);
|
||||
assertEqualInt(23000, st.st_birthtimespec.tv_nsec);
|
||||
assertEqualInt(4567890, st.st_mtime);
|
||||
assertEqualInt(23000, st.st_mtimespec.tv_nsec);
|
||||
failure("now: %ld st.st_atime: %ld", (long)now, (long)st.st_atime);
|
||||
assert(st.st_atime >= now && st.st_atime < now + 3);
|
||||
assertFileAtimeRecent("file13");
|
||||
assertFileBirthtime("file13", 4567890, 23456);
|
||||
assertFileMtime("file13", 4567890, 23456);
|
||||
#else
|
||||
skipping("Platform-specific time restore tests");
|
||||
#endif
|
||||
|
||||
@ -71,5 +71,5 @@ DEFINE_TEST(test_write_format_cpio_empty)
|
||||
failure("Empty cpio archive should be exactly 87 bytes, was %d.", used);
|
||||
assert(used == 87);
|
||||
failure("Empty cpio archive is incorrectly formatted.");
|
||||
assert(memcmp(buff, ref, 87) == 0);
|
||||
assertEqualMem(buff, ref, 87);
|
||||
}
|
||||
|
||||
@ -52,7 +52,7 @@ DEFINE_TEST(test_write_format_cpio_newc)
|
||||
{
|
||||
struct archive *a;
|
||||
struct archive_entry *entry;
|
||||
char *buff, *e;
|
||||
char *buff, *e, *file;
|
||||
size_t buffsize = 100000;
|
||||
size_t used;
|
||||
|
||||
@ -99,7 +99,8 @@ DEFINE_TEST(test_write_format_cpio_newc)
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(entry, 3, 30);
|
||||
archive_entry_set_pathname(entry, "lnk");
|
||||
archive_entry_set_mode(entry, S_IFLNK | 0664);
|
||||
archive_entry_set_mode(entry, 0664);
|
||||
archive_entry_set_filetype(entry, AE_IFLNK);
|
||||
archive_entry_set_size(entry, 0);
|
||||
archive_entry_set_uid(entry, 83);
|
||||
archive_entry_set_gid(entry, 93);
|
||||
@ -123,9 +124,10 @@ DEFINE_TEST(test_write_format_cpio_newc)
|
||||
e = buff;
|
||||
|
||||
/* First entry is "file" */
|
||||
file = e;
|
||||
assert(is_hex(e, 110)); /* Entire header is hex digits. */
|
||||
assertEqualMem(e + 0, "070701", 6); /* Magic */
|
||||
assertEqualMem(e + 6, "00000059", 8); /* ino */
|
||||
assert(memcmp(e + 6, "00000000", 8) != 0); /* ino != 0 */
|
||||
assertEqualMem(e + 14, "000081b4", 8); /* Mode */
|
||||
assertEqualMem(e + 22, "00000050", 8); /* uid */
|
||||
assertEqualMem(e + 30, "0000005a", 8); /* gid */
|
||||
@ -166,7 +168,8 @@ DEFINE_TEST(test_write_format_cpio_newc)
|
||||
/* Third entry is "lnk" */
|
||||
assert(is_hex(e, 110)); /* Entire header is hex digits. */
|
||||
assertEqualMem(e + 0, "070701", 6); /* Magic */
|
||||
assertEqualMem(e + 6, "00000058", 8); /* ino */
|
||||
assert(memcmp(e + 6, file + 6, 8) != 0); /* ino != file ino */
|
||||
assert(memcmp(e + 6, "00000000", 8) != 0); /* ino != 0 */
|
||||
assertEqualMem(e + 14, "0000a1b4", 8); /* Mode */
|
||||
assertEqualMem(e + 22, "00000053", 8); /* uid */
|
||||
assertEqualMem(e + 30, "0000005d", 8); /* gid */
|
||||
|
||||
@ -46,7 +46,7 @@ DEFINE_TEST(test_write_format_cpio_odc)
|
||||
{
|
||||
struct archive *a;
|
||||
struct archive_entry *entry;
|
||||
char *buff, *e;
|
||||
char *buff, *e, *file;
|
||||
size_t buffsize = 100000;
|
||||
size_t used;
|
||||
|
||||
@ -109,7 +109,8 @@ DEFINE_TEST(test_write_format_cpio_odc)
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(entry, 3, 30);
|
||||
archive_entry_set_pathname(entry, "symlink");
|
||||
archive_entry_set_mode(entry, S_IFLNK | 0664);
|
||||
archive_entry_set_mode(entry, 0664);
|
||||
archive_entry_set_filetype(entry, AE_IFLNK);
|
||||
archive_entry_set_symlink(entry,"file");
|
||||
archive_entry_set_size(entry, 0);
|
||||
archive_entry_set_uid(entry, 88);
|
||||
@ -130,14 +131,29 @@ DEFINE_TEST(test_write_format_cpio_odc)
|
||||
|
||||
/*
|
||||
* Verify the archive format.
|
||||
*
|
||||
* Notes on the ino validation: cpio does not actually require
|
||||
* that the ino values written to the archive match those read
|
||||
* from disk. It really requires that:
|
||||
* * matching non-zero ino values be written as matching
|
||||
* non-zero values
|
||||
* * non-matching non-zero ino values be written as non-matching
|
||||
* non-zero values
|
||||
* Libarchive further ensures that zero ino values get written
|
||||
* as zeroes. This allows the cpio writer to generate
|
||||
* synthetic ino values for the archive that may be different
|
||||
* than those on disk in order to avoid problems due to truncation.
|
||||
* This is especially needed for odc (POSIX format) that
|
||||
* only supports 18-bit ino values.
|
||||
*/
|
||||
e = buff;
|
||||
|
||||
/* "file" */
|
||||
file = e; /* Remember where this starts... */
|
||||
assert(is_octal(e, 76)); /* Entire header is octal digits. */
|
||||
assertEqualMem(e + 0, "070707", 6); /* Magic */
|
||||
assertEqualMem(e + 6, "000014", 6); /* dev */
|
||||
assertEqualMem(e + 12, "000131", 6); /* ino */
|
||||
assert(memcmp(e + 12, "000000", 6) != 0); /* ino must be != 0 */
|
||||
assertEqualMem(e + 18, "100664", 6); /* Mode */
|
||||
assertEqualMem(e + 24, "000120", 6); /* uid */
|
||||
assertEqualMem(e + 30, "000132", 6); /* gid */
|
||||
@ -154,7 +170,7 @@ DEFINE_TEST(test_write_format_cpio_odc)
|
||||
assert(is_octal(e, 76)); /* Entire header is octal digits. */
|
||||
assertEqualMem(e + 0, "070707", 6); /* Magic */
|
||||
assertEqualMem(e + 6, "000014", 6); /* dev */
|
||||
assertEqualMem(e + 12, "000131", 6); /* ino */
|
||||
assertEqualMem(e + 12, file + 12, 6); /* ino must match above */
|
||||
assertEqualMem(e + 18, "100664", 6); /* Mode */
|
||||
assertEqualMem(e + 24, "000120", 6); /* uid */
|
||||
assertEqualMem(e + 30, "000132", 6); /* gid */
|
||||
@ -187,7 +203,8 @@ DEFINE_TEST(test_write_format_cpio_odc)
|
||||
assert(is_octal(e, 76)); /* Entire header is octal digits. */
|
||||
assertEqualMem(e + 0, "070707", 6); /* Magic */
|
||||
assertEqualMem(e + 6, "000014", 6); /* dev */
|
||||
assertEqualMem(e + 12, "000132", 6); /* ino */
|
||||
assert(memcmp(e + 12, file + 12, 6) != 0); /* ino must != file ino */
|
||||
assert(memcmp(e + 12, "000000", 6) != 0); /* ino must != 0 */
|
||||
assertEqualMem(e + 18, "120664", 6); /* Mode */
|
||||
assertEqualMem(e + 24, "000130", 6); /* uid */
|
||||
assertEqualMem(e + 30, "000142", 6); /* gid */
|
||||
|
||||
@ -133,7 +133,8 @@ DEFINE_TEST(test_write_format_tar_ustar)
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(entry, 3, 30);
|
||||
archive_entry_set_pathname(entry, "symlink");
|
||||
archive_entry_set_mode(entry, S_IFLNK | 0664);
|
||||
archive_entry_set_mode(entry, 0664);
|
||||
archive_entry_set_filetype(entry, AE_IFLNK);
|
||||
archive_entry_set_symlink(entry,"file");
|
||||
archive_entry_set_size(entry, 0);
|
||||
archive_entry_set_uid(entry, 88);
|
||||
|
||||
180
lib/libarchive/test/test_write_format_zip.c
Normal file
180
lib/libarchive/test/test_write_format_zip.c
Normal file
@ -0,0 +1,180 @@
|
||||
/*-
|
||||
* Copyright (c) 2003-2008 Tim Kientzle
|
||||
* Copyright (c) 2008 Anselm Strauss
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Development supported by Google Summer of Code 2008.
|
||||
*/
|
||||
|
||||
/* TODO: reader does not yet restore permissions. */
|
||||
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
DEFINE_TEST(test_write_format_zip)
|
||||
{
|
||||
char filedata[64];
|
||||
struct archive_entry *ae;
|
||||
struct archive *a;
|
||||
size_t used;
|
||||
size_t buffsize = 1000000;
|
||||
char *buff;
|
||||
const char *compression_type;
|
||||
|
||||
buff = malloc(buffsize);
|
||||
|
||||
/* Create a new archive in memory. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_zip(a));
|
||||
#ifdef HAVE_ZLIB_H
|
||||
compression_type = "zip:compression=deflate";
|
||||
#else
|
||||
compression_type = "zip:compression=store";
|
||||
#endif
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_write_set_format_options(a, compression_type));
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_set_compression_none(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_write_open_memory(a, buff, buffsize, &used));
|
||||
|
||||
/*
|
||||
* Write a file to it.
|
||||
*/
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(ae, 1, 10);
|
||||
assertEqualInt(1, archive_entry_mtime(ae));
|
||||
assertEqualInt(10, archive_entry_mtime_nsec(ae));
|
||||
archive_entry_copy_pathname(ae, "file");
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
|
||||
archive_entry_set_size(ae, 8);
|
||||
|
||||
assertEqualInt(0, archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
assertEqualInt(8, archive_write_data(a, "12345678", 9));
|
||||
assertEqualInt(0, archive_write_data(a, "1", 1));
|
||||
|
||||
/*
|
||||
* Write another file to it.
|
||||
*/
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(ae, 1, 10);
|
||||
assertEqualInt(1, archive_entry_mtime(ae));
|
||||
assertEqualInt(10, archive_entry_mtime_nsec(ae));
|
||||
archive_entry_copy_pathname(ae, "file2");
|
||||
assertEqualString("file2", archive_entry_pathname(ae));
|
||||
archive_entry_set_mode(ae, S_IFREG | 0755);
|
||||
assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
|
||||
archive_entry_set_size(ae, 4);
|
||||
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_header(a, ae));
|
||||
archive_entry_free(ae);
|
||||
assertEqualInt(4, archive_write_data(a, "1234", 5));
|
||||
|
||||
/*
|
||||
* Write a directory to it.
|
||||
*/
|
||||
assert((ae = archive_entry_new()) != NULL);
|
||||
archive_entry_set_mtime(ae, 11, 110);
|
||||
archive_entry_copy_pathname(ae, "dir");
|
||||
archive_entry_set_mode(ae, S_IFDIR | 0755);
|
||||
archive_entry_set_size(ae, 512);
|
||||
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
|
||||
failure("size should be zero so that applications know not to write");
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
archive_entry_free(ae);
|
||||
assertEqualIntA(a, 0, archive_write_data(a, "12345678", 9));
|
||||
|
||||
/* Close out the archive. */
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_close(a));
|
||||
assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
|
||||
|
||||
/*
|
||||
* Now, read the data back.
|
||||
*/
|
||||
ae = NULL;
|
||||
assert((a = archive_read_new()) != NULL);
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_support_compression_all(a));
|
||||
assertEqualIntA(a, ARCHIVE_OK,
|
||||
archive_read_open_memory(a, buff, used));
|
||||
|
||||
/*
|
||||
* Read and verify first file.
|
||||
*/
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualInt(1, archive_entry_mtime(ae));
|
||||
/* Zip doesn't store high-resolution mtime. */
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(0, archive_entry_atime(ae));
|
||||
assertEqualInt(0, archive_entry_ctime(ae));
|
||||
assertEqualString("file", archive_entry_pathname(ae));
|
||||
//assertEqualInt((S_IFREG | 0755), archive_entry_mode(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualIntA(a, 8,
|
||||
archive_read_data(a, filedata, sizeof(filedata)));
|
||||
assertEqualMem(filedata, "12345678", 8);
|
||||
|
||||
|
||||
/*
|
||||
* Read the second file back.
|
||||
*/
|
||||
if (!assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae))){
|
||||
free(buff);
|
||||
return;
|
||||
}
|
||||
assertEqualInt(1, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(0, archive_entry_atime(ae));
|
||||
assertEqualInt(0, archive_entry_ctime(ae));
|
||||
assertEqualString("file2", archive_entry_pathname(ae));
|
||||
//assert((S_IFREG | 0755) == archive_entry_mode(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualIntA(a, 4,
|
||||
archive_read_data(a, filedata, sizeof(filedata)));
|
||||
assertEqualMem(filedata, "1234", 4);
|
||||
|
||||
/*
|
||||
* Read the dir entry back.
|
||||
*/
|
||||
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
|
||||
assertEqualInt(11, archive_entry_mtime(ae));
|
||||
assertEqualInt(0, archive_entry_mtime_nsec(ae));
|
||||
assertEqualInt(0, archive_entry_atime(ae));
|
||||
assertEqualInt(0, archive_entry_ctime(ae));
|
||||
assertEqualString("dir/", archive_entry_pathname(ae));
|
||||
//assertEqualInt((S_IFDIR | 0755), archive_entry_mode(ae));
|
||||
assertEqualInt(0, archive_entry_size(ae));
|
||||
assertEqualIntA(a, 0, archive_read_data(a, filedata, 10));
|
||||
|
||||
/* 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));
|
||||
free(buff);
|
||||
}
|
||||
56
lib/libarchive/test/test_write_format_zip_empty.c
Normal file
56
lib/libarchive/test/test_write_format_zip_empty.c
Normal file
@ -0,0 +1,56 @@
|
||||
/*-
|
||||
* Copyright (c) 2008 Anselm Strauss
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Development supported by Google Summer of Code 2008.
|
||||
*/
|
||||
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
DEFINE_TEST(test_write_format_zip_empty)
|
||||
{
|
||||
struct archive *a;
|
||||
char buff[256];
|
||||
size_t used;
|
||||
|
||||
/* Zip format: Create a new archive in memory. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertA(0 == archive_write_set_format_zip(a));
|
||||
assertA(0 == archive_write_set_compression_none(a));
|
||||
assertA(0 == archive_write_set_bytes_per_block(a, 1));
|
||||
assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
|
||||
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
|
||||
|
||||
/* Close out the archive without writing anything. */
|
||||
assertA(0 == archive_write_close(a));
|
||||
assertA(0 == archive_write_finish(a));
|
||||
|
||||
/* Verify the correct format for an empy Zip archive. */
|
||||
assertEqualInt(used, 22);
|
||||
assertEqualMem(buff,
|
||||
"PK\005\006\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
|
||||
22);
|
||||
}
|
||||
304
lib/libarchive/test/test_write_format_zip_no_compression.c
Normal file
304
lib/libarchive/test/test_write_format_zip_no_compression.c
Normal file
@ -0,0 +1,304 @@
|
||||
/*-
|
||||
* Copyright (c) 2008 Anselm Strauss
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Development supported by Google Summer of Code 2008.
|
||||
*/
|
||||
|
||||
#include "test.h"
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
static unsigned long
|
||||
bitcrc32(unsigned long c, void *_p, size_t s)
|
||||
{
|
||||
/* This is a drop-in replacement for crc32() from zlib.
|
||||
* Libarchive should be able to correctly generate
|
||||
* uncompressed zip archives (including correct CRCs) even
|
||||
* when zlib is unavailable, and this function helps us verify
|
||||
* that. Yes, this is very, very slow and unsuitable for
|
||||
* production use, but it's correct, compact, and works well
|
||||
* enough for this particular usage. Libarchive internally
|
||||
* uses a much more efficient implementation. */
|
||||
const unsigned char *p = _p;
|
||||
int bitctr;
|
||||
|
||||
if (p == NULL)
|
||||
return (0);
|
||||
|
||||
for (; s > 0; --s) {
|
||||
c ^= *p++;
|
||||
for (bitctr = 8; bitctr > 0; --bitctr) {
|
||||
if (c & 1) c = (c >> 1);
|
||||
else c = (c >> 1) ^ 0xedb88320;
|
||||
c ^= 0x80000000;
|
||||
}
|
||||
}
|
||||
return (c);
|
||||
}
|
||||
|
||||
/* Quick and dirty: Read 2-byte and 4-byte integers from Zip file. */
|
||||
static int i2(const char *p) { return ((p[0] & 0xff) | ((p[1] & 0xff) << 8)); }
|
||||
static int i4(const char *p) { return (i2(p) | (i2(p + 2) << 16)); }
|
||||
|
||||
DEFINE_TEST(test_write_format_zip_no_compression)
|
||||
{
|
||||
/* Buffer data */
|
||||
struct archive *a;
|
||||
struct archive_entry *entry;
|
||||
char buff[100000];
|
||||
const char *buffend;
|
||||
/* p is the pointer to walk over the central directory,
|
||||
* q walks over the local headers, the data and the data descriptors. */
|
||||
const char *p, *q;
|
||||
size_t used;
|
||||
|
||||
/* File data */
|
||||
char file_name[] = "file";
|
||||
char file_data1[] = {'1', '2', '3', '4', '5'};
|
||||
char file_data2[] = {'6', '7', '8', '9', '0'};
|
||||
int file_perm = 00644;
|
||||
short file_uid = 10;
|
||||
short file_gid = 20;
|
||||
|
||||
/* Folder data */
|
||||
char folder_name[] = "folder/";
|
||||
int folder_perm = 00755;
|
||||
short folder_uid = 30;
|
||||
short folder_gid = 40;
|
||||
|
||||
/* Time data */
|
||||
time_t t = time(NULL);
|
||||
struct tm *tm = localtime(&t);
|
||||
|
||||
/* Misc variables */
|
||||
unsigned long crc;
|
||||
|
||||
/* Create new ZIP archive in memory without padding. */
|
||||
assert((a = archive_write_new()) != NULL);
|
||||
assertA(0 == archive_write_set_format_zip(a));
|
||||
assertA(0 == archive_write_set_format_options(a, "zip:compression=store"));
|
||||
assertA(0 == archive_write_set_compression_none(a));
|
||||
assertA(0 == archive_write_set_bytes_per_block(a, 1));
|
||||
assertA(0 == archive_write_set_bytes_in_last_block(a, 1));
|
||||
assertA(0 == archive_write_open_memory(a, buff, sizeof(buff), &used));
|
||||
|
||||
/* Write entries. */
|
||||
|
||||
/* Regular file */
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
archive_entry_set_pathname(entry, file_name);
|
||||
archive_entry_set_mode(entry, S_IFREG | 0644);
|
||||
archive_entry_set_size(entry, sizeof(file_data1) + sizeof(file_data2));
|
||||
archive_entry_set_uid(entry, file_uid);
|
||||
archive_entry_set_gid(entry, file_gid);
|
||||
archive_entry_set_mtime(entry, t, 0);
|
||||
archive_entry_set_atime(entry, t, 0);
|
||||
archive_entry_set_ctime(entry, t, 0);
|
||||
assertEqualIntA(a, 0, archive_write_header(a, entry));
|
||||
assertEqualIntA(a, sizeof(file_data1), archive_write_data(a, file_data1, sizeof(file_data1)));
|
||||
assertEqualIntA(a, sizeof(file_data2), archive_write_data(a, file_data2, sizeof(file_data2)));
|
||||
archive_entry_free(entry);
|
||||
|
||||
/* Folder */
|
||||
assert((entry = archive_entry_new()) != NULL);
|
||||
archive_entry_set_pathname(entry, folder_name);
|
||||
archive_entry_set_mode(entry, S_IFDIR | folder_perm);
|
||||
archive_entry_set_size(entry, 0);
|
||||
archive_entry_set_uid(entry, folder_uid);
|
||||
archive_entry_set_gid(entry, folder_gid);
|
||||
archive_entry_set_mtime(entry, t, 0);
|
||||
archive_entry_set_atime(entry, t, 0);
|
||||
archive_entry_set_ctime(entry, t, 0);
|
||||
assertEqualIntA(a, 0, archive_write_header(a, entry));
|
||||
archive_entry_free(entry);
|
||||
|
||||
/* Close the archive . */
|
||||
assertA(0 == archive_write_close(a));
|
||||
assertA(0 == archive_write_finish(a));
|
||||
|
||||
/* Remember the end of the archive in memory. */
|
||||
buffend = buff + used;
|
||||
|
||||
/* Verify "End of Central Directory" record. */
|
||||
/* Get address of end-of-central-directory record. */
|
||||
p = buffend - 22; /* Assumes there is no zip comment field. */
|
||||
failure("End-of-central-directory begins with PK\\005\\006 signature");
|
||||
assertEqualMem(p, "PK\005\006", 4);
|
||||
failure("This must be disk 0");
|
||||
assertEqualInt(i2(p + 4), 0);
|
||||
failure("Central dir must start on disk 0");
|
||||
assertEqualInt(i2(p + 6), 0);
|
||||
failure("All central dir entries are on this disk");
|
||||
assertEqualInt(i2(p + 8), i2(p + 10));
|
||||
failure("CD start (%d) + CD length (%d) should == archive size - 22",
|
||||
i4(p + 12), i4(p + 16));
|
||||
assertEqualInt(i4(p + 12) + i4(p + 16), used - 22);
|
||||
failure("no zip comment");
|
||||
assertEqualInt(i2(p + 20), 0);
|
||||
|
||||
/* Get address of first entry in central directory. */
|
||||
p = buff + i4(buffend - 6);
|
||||
failure("Central file record at offset %d should begin with"
|
||||
" PK\\001\\002 signature",
|
||||
i4(buffend - 10));
|
||||
|
||||
/* Verify file entry in central directory. */
|
||||
assertEqualMem(p, "PK\001\002", 4); /* Signature */
|
||||
assertEqualInt(i2(p + 4), 3 * 256 + 20); /* Version made by */
|
||||
assertEqualInt(i2(p + 6), 20); /* Version needed to extract */
|
||||
assertEqualInt(i2(p + 8), 8); /* Flags */
|
||||
assertEqualInt(i2(p + 10), 0); /* Compression method */
|
||||
assertEqualInt(i2(p + 12), (tm->tm_hour * 2048) + (tm->tm_min * 32) + (tm->tm_sec / 2)); /* File time */
|
||||
assertEqualInt(i2(p + 14), ((tm->tm_year - 80) * 512) + ((tm->tm_mon + 1) * 32) + tm->tm_mday); /* File date */
|
||||
crc = bitcrc32(0, file_data1, sizeof(file_data1));
|
||||
crc = bitcrc32(crc, file_data2, sizeof(file_data2));
|
||||
assertEqualInt(i4(p + 16), crc); /* CRC-32 */
|
||||
assertEqualInt(i4(p + 20), sizeof(file_data1) + sizeof(file_data2)); /* Compressed size */
|
||||
assertEqualInt(i4(p + 24), sizeof(file_data1) + sizeof(file_data2)); /* Uncompressed size */
|
||||
assertEqualInt(i2(p + 28), strlen(file_name)); /* Pathname length */
|
||||
assertEqualInt(i2(p + 30), 13); /* Extra field length */
|
||||
assertEqualInt(i2(p + 32), 0); /* File comment length */
|
||||
assertEqualInt(i2(p + 34), 0); /* Disk number start */
|
||||
assertEqualInt(i2(p + 36), 0); /* Internal file attrs */
|
||||
assertEqualInt(i4(p + 38) >> 16 & 01777, file_perm); /* External file attrs */
|
||||
assertEqualInt(i4(p + 42), 0); /* Offset of local header */
|
||||
assertEqualMem(p + 46, file_name, strlen(file_name)); /* Pathname */
|
||||
p = p + 46 + strlen(file_name);
|
||||
assertEqualInt(i2(p), 0x5455); /* 'UT' extension header */
|
||||
assertEqualInt(i2(p + 2), 5); /* 'UT' size */
|
||||
assertEqualInt(p[4], 7); /* 'UT' flags */
|
||||
assertEqualInt(i4(p + 5), t); /* 'UT' mtime */
|
||||
p = p + 9;
|
||||
assertEqualInt(i2(p), 0x7855); /* 'Ux' extension header */
|
||||
assertEqualInt(i2(p + 2), 0); /* 'Ux' size */
|
||||
p = p + 4;
|
||||
|
||||
/* Verify local header of file entry. */
|
||||
q = buff;
|
||||
assertEqualMem(q, "PK\003\004", 4); /* Signature */
|
||||
assertEqualInt(i2(q + 4), 20); /* Version needed to extract */
|
||||
assertEqualInt(i2(q + 6), 8); /* Flags */
|
||||
assertEqualInt(i2(q + 8), 0); /* Compression method */
|
||||
assertEqualInt(i2(q + 10), (tm->tm_hour * 2048) + (tm->tm_min * 32) + (tm->tm_sec / 2)); /* File time */
|
||||
assertEqualInt(i2(q + 12), ((tm->tm_year - 80) * 512) + ((tm->tm_mon + 1) * 32) + tm->tm_mday); /* File date */
|
||||
assertEqualInt(i4(q + 14), 0); /* CRC-32 */
|
||||
assertEqualInt(i4(q + 18), sizeof(file_data1) + sizeof(file_data2)); /* Compressed size */
|
||||
assertEqualInt(i4(q + 22), sizeof(file_data1) + sizeof(file_data2)); /* Uncompressed size */
|
||||
assertEqualInt(i2(q + 26), strlen(file_name)); /* Pathname length */
|
||||
assertEqualInt(i2(q + 28), 25); /* Extra field length */
|
||||
assertEqualMem(q + 30, file_name, strlen(file_name)); /* Pathname */
|
||||
q = q + 30 + strlen(file_name);
|
||||
assertEqualInt(i2(q), 0x5455); /* 'UT' extension header */
|
||||
assertEqualInt(i2(q + 2), 13); /* 'UT' size */
|
||||
assertEqualInt(q[4], 7); /* 'UT' flags */
|
||||
assertEqualInt(i4(q + 5), t); /* 'UT' mtime */
|
||||
assertEqualInt(i4(q + 9), t); /* 'UT' atime */
|
||||
assertEqualInt(i4(q + 13), t); /* 'UT' ctime */
|
||||
q = q + 17;
|
||||
assertEqualInt(i2(q), 0x7855); /* 'Ux' extension header */
|
||||
assertEqualInt(i2(q + 2), 4); /* 'Ux' size */
|
||||
assertEqualInt(i2(q + 4), file_uid); /* 'Ux' UID */
|
||||
assertEqualInt(i2(q + 6), file_gid); /* 'Ux' GID */
|
||||
q = q + 8;
|
||||
|
||||
/* Verify data of file entry. */
|
||||
assertEqualMem(q, file_data1, sizeof(file_data1));
|
||||
assertEqualMem(q + sizeof(file_data1), file_data2, sizeof(file_data2));
|
||||
q = q + sizeof(file_data1) + sizeof(file_data2);
|
||||
|
||||
/* Verify data descriptor of file entry. */
|
||||
assertEqualMem(q, "PK\007\010", 4); /* Signature */
|
||||
assertEqualInt(i4(q + 4), crc); /* CRC-32 */
|
||||
assertEqualInt(i4(q + 8), sizeof(file_data1) + sizeof(file_data2)); /* Compressed size */
|
||||
assertEqualInt(i4(q + 12), sizeof(file_data1) + sizeof(file_data2)); /* Uncompressed size */
|
||||
q = q + 16;
|
||||
|
||||
/* Verify folder entry in central directory. */
|
||||
assertEqualMem(p, "PK\001\002", 4); /* Signature */
|
||||
assertEqualInt(i2(p + 4), 3 * 256 + 20); /* Version made by */
|
||||
assertEqualInt(i2(p + 6), 20); /* Version needed to extract */
|
||||
assertEqualInt(i2(p + 8), 8); /* Flags */
|
||||
assertEqualInt(i2(p + 10), 0); /* Compression method */
|
||||
assertEqualInt(i2(p + 12), (tm->tm_hour * 2048) + (tm->tm_min * 32) + (tm->tm_sec / 2)); /* File time */
|
||||
assertEqualInt(i2(p + 14), ((tm->tm_year - 80) * 512) + ((tm->tm_mon + 1) * 32) + tm->tm_mday); /* File date */
|
||||
crc = 0;
|
||||
assertEqualInt(i4(p + 16), crc); /* CRC-32 */
|
||||
assertEqualInt(i4(p + 20), 0); /* Compressed size */
|
||||
assertEqualInt(i4(p + 24), 0); /* Uncompressed size */
|
||||
assertEqualInt(i2(p + 28), strlen(folder_name)); /* Pathname length */
|
||||
assertEqualInt(i2(p + 30), 13); /* Extra field length */
|
||||
assertEqualInt(i2(p + 32), 0); /* File comment length */
|
||||
assertEqualInt(i2(p + 34), 0); /* Disk number start */
|
||||
assertEqualInt(i2(p + 36), 0); /* Internal file attrs */
|
||||
assertEqualInt(i4(p + 38) >> 16 & 01777, folder_perm); /* External file attrs */
|
||||
assertEqualInt(i4(p + 42), q - buff); /* Offset of local header */
|
||||
assertEqualMem(p + 46, folder_name, strlen(folder_name)); /* Pathname */
|
||||
p = p + 46 + strlen(folder_name);
|
||||
assertEqualInt(i2(p), 0x5455); /* 'UT' extension header */
|
||||
assertEqualInt(i2(p + 2), 5); /* 'UT' size */
|
||||
assertEqualInt(p[4], 7); /* 'UT' flags */
|
||||
assertEqualInt(i4(p + 5), t); /* 'UT' mtime */
|
||||
p = p + 9;
|
||||
assertEqualInt(i2(p), 0x7855); /* 'Ux' extension header */
|
||||
assertEqualInt(i2(p + 2), 0); /* 'Ux' size */
|
||||
p = p + 4;
|
||||
|
||||
/* Verify local header of folder entry. */
|
||||
assertEqualMem(q, "PK\003\004", 4); /* Signature */
|
||||
assertEqualInt(i2(q + 4), 20); /* Version needed to extract */
|
||||
assertEqualInt(i2(q + 6), 8); /* Flags */
|
||||
assertEqualInt(i2(q + 8), 0); /* Compression method */
|
||||
assertEqualInt(i2(q + 10), (tm->tm_hour * 2048) + (tm->tm_min * 32) + (tm->tm_sec / 2)); /* File time */
|
||||
assertEqualInt(i2(q + 12), ((tm->tm_year - 80) * 512) + ((tm->tm_mon + 1) * 32) + tm->tm_mday); /* File date */
|
||||
assertEqualInt(i4(q + 14), 0); /* CRC-32 */
|
||||
assertEqualInt(i4(q + 18), 0); /* Compressed size */
|
||||
assertEqualInt(i4(q + 22), 0); /* Uncompressed size */
|
||||
assertEqualInt(i2(q + 26), strlen(folder_name)); /* Pathname length */
|
||||
assertEqualInt(i2(q + 28), 25); /* Extra field length */
|
||||
assertEqualMem(q + 30, folder_name, strlen(folder_name)); /* Pathname */
|
||||
q = q + 30 + strlen(folder_name);
|
||||
assertEqualInt(i2(q), 0x5455); /* 'UT' extension header */
|
||||
assertEqualInt(i2(q + 2), 13); /* 'UT' size */
|
||||
assertEqualInt(q[4], 7); /* 'UT' flags */
|
||||
assertEqualInt(i4(q + 5), t); /* 'UT' mtime */
|
||||
assertEqualInt(i4(q + 9), t); /* 'UT' atime */
|
||||
assertEqualInt(i4(q + 13), t); /* 'UT' ctime */
|
||||
q = q + 17;
|
||||
assertEqualInt(i2(q), 0x7855); /* 'Ux' extension header */
|
||||
assertEqualInt(i2(q + 2), 4); /* 'Ux' size */
|
||||
assertEqualInt(i2(q + 4), folder_uid); /* 'Ux' UID */
|
||||
assertEqualInt(i2(q + 6), folder_gid); /* 'Ux' GID */
|
||||
q = q + 8;
|
||||
|
||||
/* There should not be any data in the folder entry,
|
||||
* meaning next is the data descriptor header. */
|
||||
|
||||
/* Verify data descriptor of folder entry. */
|
||||
assertEqualMem(q, "PK\007\010", 4); /* Signature */
|
||||
assertEqualInt(i4(q + 4), crc); /* CRC-32 */
|
||||
assertEqualInt(i4(q + 8), 0); /* Compressed size */
|
||||
assertEqualInt(i4(q + 12), 0); /* Uncompressed size */
|
||||
q = q + 16;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user