GSP
Quick Navigator
Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
Archive::Libarchive::API(3) User Contributed Perl Documentation Archive::Libarchive::API(3)

Archive::Libarchive::API - Comprehensive API documentation for Archive::Libarchive

version 0.09

 use 5.020;
 use Archive::Libarchive qw( :const );
 
 my $r = Archive::Libarchive::ArchiveRead->new;
 $r->support_filter_all;
 $r->support_format_all;
 $r->open_filename("archive.tar", 10240) == ARCHIVE_OK
   or die $r->error_string;
 
 my $e = Archive::Libarchive::Entry->new;
 say $e->pathname while $r->next_header($e) == ARCHIVE_OK;

This document covers comprehensive list of methods and constants provided by Archive::Libarchive classes. The top level document Archive::Libarchive is a better place to start, along with the main documentation pages for each class, as while not comprehensive, do cover in more detail the methods and features that you are most likely to use in practice, and they include examples. This document is intended primarily for reference.

This document includes method signatures for each method provided by the API, but because of the large number of methods, the exact function of all methods is not provided. You can usually get the idea from the method names, or consult the "libarchive" documentation. A familiarity with the "libarchive" API is therefore helpful.

Because "libarchive" contains class name prefixes for its methods to provide a pseudo object oriented interface in C, and because this Perl interface is properly object oriented, the names of all methods have been changed. (Mostly by removing the class prefix, although, some have been modified beyond that because simply removing the class prefix makes some method names confusing). To help you find the equivalent "libarchive" documentation, the original "libarchive" function names are included in the method usage.

Some methods are marked as "(optional)". These methods were added to "libarchive" after the current minimum supported by Archive::Libarchive, and therefore might not be available depending on the version of "libarchive" you have installed. If you need your code to work on both old code and to take advantage of these methods on new versions you can use the "can" method to see if these methods are available.

If you need one or more of these methods and your system "libarchive" is too old, then you can force a share install of Alien::Libarchive3.

 env ALIEN_INSTALL_TYPE=share cpanm --reinstall Alien::Libarchive3


 # archive_bzlib_version
 my $string = archive_bzlib_version();

The "bzlib" version that "libarchive" was built with. This will return "undef" if the library was not found at build time.

 # archive_liblz4_version
 my $string = archive_liblz4_version();

The "liblz4" version that "libarchive" was built with. This will return "undef" if the library was not found at build time.

 # archive_liblzma_version
 my $string = archive_liblzma_version();

The "liblzma" version that "libarchive" was built with. This will return "undef" if the library was not found at build time.

 # archive_libzstd_version (optional)
 my $string = archive_libzstd_version();

The "zstd" version that "libarchive" was built with. This will return "undef" if the library was not found at build time.

 # archive_version_details
 my $string = archive_version_details();

Detailed textual name/version of the library and its dependencies. This has the form:

"libarchive x.y.z zlib/a.b.c liblzma/d.e.f ... etc ..."

the list of libraries described here will vary depending on how libarchive was compiled.

 # archive_version_number
 my $int = archive_version_number();

The "libarchive" version expressed as an integer. This will be the major, minor and patch levels each using up to three digits, so 3.5.1 will be 3005001.

 # archive_version_string
 my $string = archive_version_string();

The "libarchive" version as a string.

 # archive_zlib_version
 my $string = archive_zlib_version();

The "zlib" version that "libarchive" was built with. This will return "undef" if the library was not found at build time.

 my %versions = Archive::Libarchive->versions();

This returns a hash of "libarchive" and Archive::Libarchive versions and dependency versions. This may be useful in a test report diagnostic.

 # archive_clear_error
 $ar->clear_error;

Clear the error for the corresponding archive instance.

 # archive_copy_error
 $ar->copy_error($ar);


 # archive_entry_new2
 my $e = $ar->entry;

This method creates a new Archive::Libarchive::Entry instance, like when you create an instance with that class' new method, except this form will pull character-set conversion information from the specified archive instance.

 # archive_errno
 my $int = $ar->errno;

Returns the system "errno" code for the archive instance. For non-system level errors, this will not have a sensible value.

 # archive_error_string
 my $string = $ar->error_string;

Returns a human readable diagnostic of error for the corresponding archive instance.

 # archive_file_count
 my $int = $ar->file_count;


 # archive_filter_bytes
 my $sint64 = $ar->filter_bytes($int);


 # archive_filter_code
 my $code = $ar->filter_code($num);

This will return the filter code at position $num. For the total number of positions see the filter_count method.

The constant prefix for this method is "ARCHIVE_FILTER_". This will return a dualvar where the string is the lowercase name without the prefix and the integer is the constant value. For the full list see "CONSTANTS" in Archive::Libarchive::API.

 # archive_filter_count
 my $int = $ar->filter_count;


 # archive_filter_name
 my $string = $ar->filter_name($int);


 # archive_format
 my $code = $ar->format;

This will return the format code at position $num.

The constant prefix for this method is "ARCHIVE_FORMAT_". This will return a dualvar where the string is the lowercase name without the prefix and the integer is the constant value. For the full list see "CONSTANTS" in Archive::Libarchive::API.

 # archive_format_name
 my $string = $ar->format_name;


 # archive_seek_data
 my $sint64_1 = $ar->seek_data($sint64_2, $int);


 # archive_set_error
 $ar->set_error($errno, $string);

This will set the "errno" code and human readable diagnostic for the archive instance. Not all errors have a corresponding "errno" code, so you can set that to zero (0) in that case.

 # archive_read_add_passphrase
 my $int = $r->add_passphrase($string);


 # archive_read_append_filter
 my $int = $r->append_filter($code);

Append filter to manually specify the order in which filters will be applied. This will accept either a string representation of the filter code, or the constant. The constant prefix is "ARCHIVE_FILTER_". So for a gzipped file this would be either 'gzip' or "ARCHIVE_FILTER_GZIP". For the full list see "CONSTANTS" in Archive::Libarchive::API.

 # archive_read_append_filter_program
 my $int = $r->append_filter_program($string);


 # archive_read_append_filter_program_signature
 my $int = $r->append_filter_program_signature($string, $opaque, $size_t);


 # archive_read_close
 my $int = $r->close;


 # archive_read_extract
 my $int1 = $r->extract($e, $int2);


 # archive_read_extract2
 my $int = $r->extract2($e, $ar);


 # archive_read_extract_set_skip_file
 $r->extract_set_skip_file($sint64_1, $sint64_2);


 # archive_read_format_capabilities
 my $int = $r->format_capabilities;


 # archive_read_has_encrypted_entries
 my $int = $r->has_encrypted_entries;


 # archive_read_header_position
 my $sint64 = $r->header_position;


 # archive_read_new
 my $r = Archive::Libarchive::ArchiveRead->new;

Create a new archive read object.

 # archive_read_next_header
 my $code = $r->next_header($e);

Returns the next Archive::Libarchive::Entry object.

 # archive_read_open1
 # archive_read_set_callback_data
 # archive_read_set_close_callback
 # archive_read_set_open_callback
 # archive_read_set_read_callback
 # archive_read_set_seek_callback
 # archive_read_set_skip_callback
 $r->open(%callbacks);

This is a basic open method, which relies on callbacks for its implementation. The only callback that is required is the "read" callback. The "open" and "close" callbacks are made available mostly for the benefit of the caller. The "skip" and "seek" callbacks are used if available for some formats like "zip" to improve performance. All callbacks should return a normal status code, which is "ARCHIVE_OK" on success.

Unlike the "libarchive" C-API, this interface doesn't provide a facility for passing in "client" data. In Perl this is implemented using a closure, which should allow you to pass in arbitrary variables via proper scoping.

 $r->open(open => sub ($r) {
   ...
 });

Called immediately when the archive is "opened";

 $r->open(read => sub ($r, $ref) {
   $$ref = ...;
   ...
   return $size.
 });

Called when new data is required. What is passed in is a scalar reference. You should set this scalar to the next block of data. On success you should return the size of the data in bytes, and on failure return a normal status code.

 $r->open(seek => sub ($r, $offset, $whence) {
   ...
 });

Called to seek to the new location. The $offset and $whence arguments work exactly like the "libc" "fseek" function.

 $r->open(skip => sub ($r, $request) {
   ...
 });

Called to skip the next $request bytes. Should return the actual number of bytes skipped on success (which can be less than or equal to $request), and on failure return a normal status code.

 $r->open(close => sub ($r) {
   ...
 });

This is called when the archive instance is closed.

 $r->open_FILE($file_pointer);

This takes either a FFI::C::File, or an opaque pointer to a libc file pointer.

 # archive_read_open_fd
 my $int1 = $r->open_fd($int2, $size_t);


 # archive_read_open_filename
 my $int = $r->open_filename($string, $size_t);

Open a single-file archive. The $size_t argument is the block size.

 # archive_read_open_filename
 my $int = $r->open_filename($string, $size_t);


 # archive_read_open_filename_w
 my $int = $r->open_filename_w($wstring, $size_t);


 # archive_read_open_filenames
 my $int = $r->open_filenames(\@filenames, $size_t);

Open a multi-file archive (typically for RAR format). The $size_t argument is the block size.

 # archive_write_open_memory
 my $code = $r->open_memory(\$buffer);

Open's the in-memory archive.

 $r->open_perlfile(*FILE);

This takes a perl file handle and reads the archive from there.

 # archive_read_data
 my $size_or_code = $r->read_data(\$buffer, $size);
 my $size_or_code = $r->read_data(\$buffer);

Read in data from the content section of the archive entry. The output is written into $buffer. Up to $size bytes will be read. This will return the number of bytes read on success, zero (0) on EOF and a normal status code on error.

 # archive_read_data_block
 my $int = $r->read_data_block(\$buffer, \$offset);

A zero-copy version of archive_read_data that also exposes the file offset of each returned block. Note that the client has no way to specify the desired size of the block. The API does guarantee that offsets will be strictly increasing and that returned blocks will not overlap.

Gotcha with this method is that it returns "ARCHIVE_EOF" when there is no more data to read instead of the number of bytes. The size can be determined from the length of the newly resized $buffer.

 # archive_read_data_into_fd
 my $int1 = $r->read_data_into_fd($int2);


 # archive_read_data_skip
 my $int = $r->read_data_skip;


 # archive_read_set_filter_option
 my $int = $r->set_filter_option($string1, $string2, $string3);


 # archive_read_set_format
 my $int = $r->set_format($code);

Set the format manually. This will accept either a string representation of the format, or the constant. The constant prefix is "ARCHIVE_FORMAT_". So for a tar file this would be either 'tar' or "ARCHIVE_FORMAT_TAR".

 # archive_read_set_format_option
 my $int = $r->set_format_option($string1, $string2, $string3);


 # archive_read_set_option
 my $int = $r->set_option($string1, $string2, $string3);


 # archive_read_set_options
 my $int = $r->set_options($string);


 # archive_read_set_passphrase_callback
 my $int = $r->set_passphrase_callback(sub ($r) {
   ...
   return $passphrase;
 });

Set a callback that will be called when a passphrase is required, for example with a .zip file with encrypted entries.

 # archive_read_support_filter_all
 my $int = $r->support_filter_all;


 # archive_read_support_filter_by_code (optional)
 my $int1 = $r->support_filter_by_code($int2);


 # archive_read_support_filter_bzip2
 my $int = $r->support_filter_bzip2;


 # archive_read_support_filter_compress
 my $int = $r->support_filter_compress;


 # archive_read_support_filter_grzip
 my $int = $r->support_filter_grzip;


 # archive_read_support_filter_gzip
 my $int = $r->support_filter_gzip;


 # archive_read_support_filter_lrzip
 my $int = $r->support_filter_lrzip;


 # archive_read_support_filter_lz4
 my $int = $r->support_filter_lz4;


 # archive_read_support_filter_lzip
 my $int = $r->support_filter_lzip;


 # archive_read_support_filter_lzma
 my $int = $r->support_filter_lzma;


 # archive_read_support_filter_lzop
 my $int = $r->support_filter_lzop;


 # archive_read_support_filter_none
 my $int = $r->support_filter_none;


 # archive_read_support_filter_program
 my $int = $r->support_filter_program($string);


 # archive_read_support_filter_program_signature
 my $int = $r->support_filter_program_signature($string, $opaque, $size_t);


 # archive_read_support_filter_rpm
 my $int = $r->support_filter_rpm;


 # archive_read_support_filter_uu
 my $int = $r->support_filter_uu;


 # archive_read_support_filter_xz
 my $int = $r->support_filter_xz;


 # archive_read_support_filter_zstd (optional)
 my $int = $r->support_filter_zstd;


 # archive_read_support_format_7zip
 my $int = $r->support_format_7zip;


 # archive_read_support_format_all
 my $int = $r->support_format_all;


 # archive_read_support_format_ar
 my $int = $r->support_format_ar;


 # archive_read_support_format_by_code
 my $int1 = $r->support_format_by_code($int2);


 # archive_read_support_format_cab
 my $int = $r->support_format_cab;


 # archive_read_support_format_cpio
 my $int = $r->support_format_cpio;


 # archive_read_support_format_empty
 my $int = $r->support_format_empty;


 # archive_read_support_format_gnutar
 my $int = $r->support_format_gnutar;


 # archive_read_support_format_iso9660
 my $int = $r->support_format_iso9660;


 # archive_read_support_format_lha
 my $int = $r->support_format_lha;


 # archive_read_support_format_mtree
 my $int = $r->support_format_mtree;


 # archive_read_support_format_rar
 my $int = $r->support_format_rar;


 # archive_read_support_format_rar5 (optional)
 my $int = $r->support_format_rar5;


 # archive_read_support_format_raw
 my $int = $r->support_format_raw;


 # archive_read_support_format_tar
 my $int = $r->support_format_tar;


 # archive_read_support_format_warc
 my $int = $r->support_format_warc;


 # archive_read_support_format_xar
 my $int = $r->support_format_xar;


 # archive_read_support_format_zip
 my $int = $r->support_format_zip;


 # archive_read_support_format_zip_seekable
 my $int = $r->support_format_zip_seekable;


 # archive_read_support_format_zip_streamable
 my $int = $r->support_format_zip_streamable;


 # archive_write_add_filter
 my $int = $w->add_filter($code);

Add filter to be applied when writing the archive. This will accept either a string representation of the filter code, or the constant. The constant prefix is "ARCHIVE_FILTER_". So for a gzipped file this would be either 'gzip' or "ARCHIVE_FILTER_GZIP". For the full list see "CONSTANTS" in Archive::Libarchive::API.

 # archive_write_add_filter_b64encode
 my $int = $w->add_filter_b64encode;


 # archive_write_add_filter_by_name
 my $int = $w->add_filter_by_name($string);


 # archive_write_add_filter_bzip2
 my $int = $w->add_filter_bzip2;


 # archive_write_add_filter_compress
 my $int = $w->add_filter_compress;


 # archive_write_add_filter_grzip
 my $int = $w->add_filter_grzip;


 # archive_write_add_filter_gzip
 my $int = $w->add_filter_gzip;


 # archive_write_add_filter_lrzip
 my $int = $w->add_filter_lrzip;


 # archive_write_add_filter_lz4
 my $int = $w->add_filter_lz4;


 # archive_write_add_filter_lzip
 my $int = $w->add_filter_lzip;


 # archive_write_add_filter_lzma
 my $int = $w->add_filter_lzma;


 # archive_write_add_filter_lzop
 my $int = $w->add_filter_lzop;


 # archive_write_add_filter_none
 my $int = $w->add_filter_none;


 # archive_write_add_filter_program
 my $int = $w->add_filter_program($string);


 # archive_write_add_filter_uuencode
 my $int = $w->add_filter_uuencode;


 # archive_write_add_filter_xz
 my $int = $w->add_filter_xz;


 # archive_write_add_filter_zstd (optional)
 my $int = $w->add_filter_zstd;


 # archive_write_close
 my $int = $w->close;


 # archive_write_fail
 my $int = $w->fail;


 # archive_write_finish_entry
 my $int = $w->finish_entry;


 # archive_write_get_bytes_in_last_block
 my $int = $w->get_bytes_in_last_block;


 # archive_write_get_bytes_per_block
 my $int = $w->get_bytes_per_block;


 # archive_write_new
 my $w = Archive::Libarchive::ArchiveWrite->new;

Create a new archive write object.

 # archive_write_open
 $w->open(%callbacks);

This is a basic open method, which relies on callbacks for its implementation. The only callback that is required is the "write" callback. The "open" and "close" callbacks are made available mostly for the benefit of the caller. All callbacks should return a normal status code, which is "ARCHIVE_OK" on success.

Unlike the "libarchive" C-API, this interface doesn't provide a facility for passing in "client" data. In Perl this is implemented using a closure, which should allow you to pass in arbitrary variables via proper scoping.

 $w->open(open => sub ($w) {
   ...
 });

Called immediately when the archive is "opened";

 $w->open(write => sub ($w, $ref) {
   ... = $$ref;
   return $size;
 });

This callback is called when data needs to be written to the archive. It is passed in as a reference to a scalar that contains the raw data. On success you should return the actual size of the data written in bytes, and on failure return a normal status code.

 $w->open(open => sub ($w) {
   ...
 });

This is called when the archive instance is closed.

 # archive_write_open_FILE
 $w->open_FILE($file_pointer);

This takes either a FFI::C::File, or an opaque pointer to a libc file pointer.

 # archive_write_open_fd
 my $int1 = $w->open_fd($int2);


 # archive_write_open_filename
 my $int = $w->open_filename($string);


 # archive_write_open_filename_w
 my $int = $w->open_filename_w($wstring);


 # archive_write_open_memory
 $w->open_memory(\$buffer);

This takes a reference to scalar and stores the archive in memory there.

 $w->open_perlfile(*FILE);

This takes a perl file handle and stores the archive there.

 # archive_write_set_bytes_in_last_block
 my $int1 = $w->set_bytes_in_last_block($int2);


 # archive_write_set_bytes_per_block
 my $int1 = $w->set_bytes_per_block($int2);


 # archive_write_set_filter_option
 my $int = $w->set_filter_option($string1, $string2, $string3);


 # archive_write_set_format
 my $int = $w->set_format($code);

Set the output format. This will accept either a string representation of the format, or the constant. The constant prefix is "ARCHIVE_FORMAT_". So for a tar file this would be either 'tar' or "ARCHIVE_FORMAT_TAR".

 # archive_write_set_format_7zip
 my $int = $w->set_format_7zip;


 # archive_write_set_format_ar_bsd
 my $int = $w->set_format_ar_bsd;


 # archive_write_set_format_ar_svr4
 my $int = $w->set_format_ar_svr4;


 # archive_write_set_format_by_name
 my $int = $w->set_format_by_name($string);


 # archive_write_set_format_cpio
 my $int = $w->set_format_cpio;


 # archive_write_set_format_cpio_bin (optional)
 my $int = $w->set_format_cpio_bin;


 # archive_write_set_format_cpio_newc
 my $int = $w->set_format_cpio_newc;


 # archive_write_set_format_cpio_odc (optional)
 my $int = $w->set_format_cpio_odc;


 # archive_write_set_format_cpio_pwb (optional)
 my $int = $w->set_format_cpio_pwb;


 # archive_write_set_format_filter_by_ext
 my $int = $w->set_format_filter_by_ext($string);


 # archive_write_set_format_filter_by_ext_def
 my $int = $w->set_format_filter_by_ext_def($string1, $string2);


 # archive_write_set_format_gnutar
 my $int = $w->set_format_gnutar;


 # archive_write_set_format_iso9660
 my $int = $w->set_format_iso9660;


 # archive_write_set_format_mtree
 my $int = $w->set_format_mtree;


 # archive_write_set_format_mtree_classic
 my $int = $w->set_format_mtree_classic;


 # archive_write_set_format_option
 my $int = $w->set_format_option($string1, $string2, $string3);


 # archive_write_set_format_pax
 my $int = $w->set_format_pax;


 # archive_write_set_format_pax_restricted
 my $int = $w->set_format_pax_restricted;


 # archive_write_set_format_raw
 my $int = $w->set_format_raw;


 # archive_write_set_format_shar
 my $int = $w->set_format_shar;


 # archive_write_set_format_shar_dump
 my $int = $w->set_format_shar_dump;


 # archive_write_set_format_ustar
 my $int = $w->set_format_ustar;


 # archive_write_set_format_v7tar
 my $int = $w->set_format_v7tar;


 # archive_write_set_format_warc
 my $int = $w->set_format_warc;


 # archive_write_set_format_xar
 my $int = $w->set_format_xar;


 # archive_write_set_format_zip
 my $int = $w->set_format_zip;


 # archive_write_set_option
 my $int = $w->set_option($string1, $string2, $string3);


 # archive_write_set_options
 my $int = $w->set_options($string);


 # archive_write_set_passphrase
 my $int = $w->set_passphrase($string);


 # archive_write_set_passphrase_callback
 my $int = $w->set_passphrase_callback(sub ($w) {
   ...
   return $passphrase;
 });

Set a callback that will be called when a passphrase is required, for example with a .zip file with encrypted entries.

 # archive_write_set_skip_file
 my $int = $w->set_skip_file($sint64_1, $sint64_2);


 # archive_write_data
 my $size_or_code = $w->write_data(\$buffer);

Write the entry content data to the archive. This takes a reference to the buffer. Returns the number of bytes written on success, and a normal status code on error.

 # archive_write_header
 my $int = $w->write_header($e);


 # archive_write_zip_set_compression_deflate
 my $int = $w->zip_set_compression_deflate;


 # archive_write_zip_set_compression_store
 my $int = $w->zip_set_compression_store;


 # archive_read_disk_can_descend
 my $int = $dr->disk_can_descend;


 # archive_read_disk_current_filesystem
 my $int = $dr->disk_current_filesystem;


 # archive_read_disk_current_filesystem_is_remote
 my $int = $dr->disk_current_filesystem_is_remote;


 # archive_read_disk_current_filesystem_is_synthetic
 my $int = $dr->disk_current_filesystem_is_synthetic;


 # archive_read_disk_descend
 my $int = $dr->disk_descend;


 # archive_read_disk_gname
 my $string = $dr->disk_gname($sint64);


 # archive_read_disk_open
 my $int = $dr->disk_open($string);


 # archive_read_disk_open_w
 my $int = $dr->disk_open_w($wstring);


 # archive_read_disk_set_atime_restored
 my $int = $dr->disk_set_atime_restored;


 # archive_read_disk_set_behavior
 my $int1 = $dr->disk_set_behavior($int2);


 # archive_read_disk_set_standard_lookup
 my $int = $dr->disk_set_standard_lookup;

 # archive_read_disk_set_symlink_hybrid
 my $int = $dr->disk_set_symlink_hybrid;

 # archive_read_disk_set_symlink_logical
 my $int = $dr->disk_set_symlink_logical;

 # archive_read_disk_set_symlink_physical
 my $int = $dr->disk_set_symlink_physical;


 # archive_read_disk_uname
 my $string = $dr->disk_uname($sint64);


 my $dr = Archive::Libarchive::DiskRead->new;

Create a new disk read object.

 # archive_write_disk_gid
 my $sint64_1 = $dw->disk_gid($string, $sint64_2);


 # archive_write_disk_set_options
 my $int1 = $dw->disk_set_options($int2);


 # archive_write_disk_set_skip_file
 my $int = $dw->disk_set_skip_file($sint64_1, $sint64_2);


 # archive_write_disk_set_standard_lookup
 my $int = $dw->disk_set_standard_lookup;


 # archive_write_disk_uid
 my $sint64_1 = $dw->disk_uid($string, $sint64_2);


 # archive_write_disk_new
 my $dw = Archive::Libarchive::DiskWrite->new;

Create a new disk write object.

 # archive_write_data_block
 my $ssize_t = $dw->write_data_block(\$buffer, $offset);

Write the entry content data to the disk. This is intended to be used with "read_data_block" in Archive::Libarchive::ArchiveRead.

 # archive_entry_acl_add_entry
 my $int1 = $e->acl_add_entry($int2, $int3, $int4, $int5, $string);


 # archive_entry_acl_add_entry_w
 my $int1 = $e->acl_add_entry_w($int2, $int3, $int4, $int5, $wstring);


 # archive_entry_acl_clear
 $e->acl_clear;


 # archive_entry_acl_count
 my $int1 = $e->acl_count($int2);


 # archive_entry_acl_from_text (optional)
 my $int1 = $e->acl_from_text($string, $int2);


 # archive_entry_acl_from_text_w (optional)
 my $int1 = $e->acl_from_text_w($wstring, $int2);


 # archive_entry_acl_next
 my $int1 = $e->acl_next($int2, $int*1, $int*2, $int*3, $int*4, \$string);


 # archive_entry_acl_reset
 my $int1 = $e->acl_reset($int2);


 # archive_entry_acl_to_text (optional)
 my $string = $e->acl_to_text(\$ssize_t, $int);


 # archive_entry_acl_to_text_w (optional)
 my $wstring = $e->acl_to_text_w(\$ssize_t, $int);


 # archive_entry_acl_types (optional)
 my $int = $e->acl_types;


 # archive_entry_atime
 my $time_t = $e->atime;


 # archive_entry_atime_is_set
 my $int = $e->atime_is_set;


 # archive_entry_atime_nsec
 my $long = $e->atime_nsec;


 # archive_entry_birthtime
 my $time_t = $e->birthtime;


 # archive_entry_birthtime_is_set
 my $int = $e->birthtime_is_set;


 # archive_entry_birthtime_nsec
 my $long = $e->birthtime_nsec;


 # archive_entry_clear
 $e->clear;


 # archive_entry_clone
 my $e2 = $e->clone;

Clone the entry instance.

 # archive_entry_copy_fflags_text
 my $string1 = $e->copy_fflags_text($string2);


 # archive_entry_copy_fflags_text_w
 my $wstring1 = $e->copy_fflags_text_w($wstring2);


 # archive_entry_copy_gname
 $e->copy_gname($string);


 # archive_entry_copy_gname_w
 $e->copy_gname_w($wstring);

 # archive_entry_copy_hardlink
 $e->copy_hardlink($string);

 # archive_entry_copy_hardlink_w
 $e->copy_hardlink_w($wstring);

 # archive_entry_copy_link
 $e->copy_link($string);

 # archive_entry_copy_link_w
 $e->copy_link_w($wstring);


 # archive_entry_copy_mac_metadata
 $e->copy_mac_metadata($meta);

Sets the mac metadata to $meta.

 # archive_entry_copy_pathname
 $e->copy_pathname($string);


 # archive_entry_copy_pathname_w
 $e->copy_pathname_w($wstring);


 # archive_entry_copy_sourcepath
 $e->copy_sourcepath($string);


 # archive_entry_copy_sourcepath_w
 $e->copy_sourcepath_w($wstring);


 # archive_entry_copy_stat
 $e->copy_stat($stat);

Copies the values from a FFI::C::Stat instance.

Not currently implemented on Windows.

 # archive_entry_copy_symlink
 $e->copy_symlink($string);

 # archive_entry_copy_symlink_w
 $e->copy_symlink_w($wstring);


 # archive_entry_copy_uname
 $e->copy_uname($string);


 # archive_entry_copy_uname_w
 $e->copy_uname_w($wstring);


 # archive_entry_ctime
 my $time_t = $e->ctime;


 # archive_entry_ctime_is_set
 my $int = $e->ctime_is_set;


 # archive_entry_ctime_nsec
 my $long = $e->ctime_nsec;


 # archive_entry_dev
 my $dev_t = $e->dev;


 # archive_entry_dev_is_set
 my $int = $e->dev_is_set;


 # archive_entry_devmajor
 my $dev_t = $e->devmajor;


 # archive_entry_devminor
 my $dev_t = $e->devminor;


 # archive_entry_digest
 my $string = $e->digest($type);

This is used to query the raw hex digest for the given entry. The type of digest is provided as an argument. The type may be passed in as either a string or an integer constant. The constant prefix is "ARCHIVE_ENTRY_DIGEST_". So for an MD5 digest you could pass in either 'md5' or "ARCHIVE_ENTRY_DIGEST_MD5".

 # archive_entry_fflags
 $e->fflags($ulong*1, $ulong*2);


 # archive_entry_fflags_text
 my $string = $e->fflags_text;


 # archive_entry_filetype
 my $code = $e->filetype;

This returns the type of file for the entry. This will be a dualvar where the string is one of "mt", "reg", "lnx", "sock", "chr", "blk", "dir" or "ifo", and integer values will match the corresponding "AE_IF" prefixed constant. See "CONSTANTS" in Archive::Libarchive::API for the full list.

 # archive_entry_filetype_is_set (optional)
 my $int = $e->filetype_is_set;


 # archive_entry_gid
 my $sint64 = $e->gid;


 # archive_entry_gid_is_set (optional)
 my $int = $e->gid_is_set;


 # archive_entry_gname
 my $string = $e->gname;


 # archive_entry_gname_utf8
 my $string_utf8 = $e->gname_utf8;

 # archive_entry_hardlink
 my $string = $e->hardlink;

 # archive_entry_hardlink_utf8
 my $string_utf8 = $e->hardlink_utf8;


 # archive_entry_ino
 my $sint64 = $e->ino;


 # archive_entry_ino64
 my $sint64 = $e->ino64;


 # archive_entry_ino_is_set
 my $int = $e->ino_is_set;


 # archive_entry_is_data_encrypted
 my $int = $e->is_data_encrypted;


 # archive_entry_is_encrypted
 my $int = $e->is_encrypted;


 # archive_entry_is_metadata_encrypted
 my $int = $e->is_metadata_encrypted;


 # archive_entry_mac_metadata
 my $meta = $e->mac_metadata;

Get the mac metadata from the entry.

 # archive_entry_mode
 my $mode_t = $e->mode;


 # archive_entry_mtime
 my $time_t = $e->mtime;


 # archive_entry_mtime_is_set
 my $int = $e->mtime_is_set;


 # archive_entry_mtime_nsec
 my $long = $e->mtime_nsec;


 my $e = Archive::Libarchive::Entry->new;

Create a new Entry object.

 # archive_entry_nlink
 my $uint = $e->nlink;


 # archive_entry_pathname
 my $string = $e->pathname;


 # archive_entry_pathname_utf8
 my $string_utf8 = $e->pathname_utf8;


 # archive_entry_perm
 my $mode_t = $e->perm;


 # archive_entry_perm_is_set (optional)
 my $int = $e->perm_is_set;


 # archive_entry_rdev
 my $dev_t = $e->rdev;


 # archive_entry_rdevmajor
 my $dev_t = $e->rdevmajor;


 # archive_entry_rdevminor
 my $dev_t = $e->rdevminor;


 # archive_entry_set_atime
 $e->set_atime($time_t, $long);


 # archive_entry_set_birthtime
 $e->set_birthtime($time_t, $long);


 # archive_entry_set_ctime
 $e->set_ctime($time_t, $long);


 # archive_entry_set_dev
 $e->set_dev($dev_t);


 # archive_entry_set_devmajor
 $e->set_devmajor($dev_t);


 # archive_entry_set_devminor
 $e->set_devminor($dev_t);


 # archive_entry_set_fflags
 $e->set_fflags($ulong1, $ulong2);


 # archive_entry_set_filetype
 $e->set_filetype($code);

This sets the type of the file for the entry. This will accept either a string value which is one of "mt", "reg", "lnx", "sock", "chr", "blk", "dir" or "ifo", or an integer constant value with the "AE_IF" prefix. See "CONSTANTS" in Archive::Libarchive::API for the full list.

 # archive_entry_set_gid
 $e->set_gid($sint64);


 # archive_entry_set_gname
 $e->set_gname($string);


 # archive_entry_set_gname_utf8
 $e->set_gname_utf8($string);

 # archive_entry_set_hardlink
 $e->set_hardlink($string);

 # archive_entry_set_hardlink_utf8
 $e->set_hardlink_utf8($string);


 # archive_entry_set_ino
 $e->set_ino($sint64);


 # archive_entry_set_ino64
 $e->set_ino64($sint64);


 # archive_entry_set_is_data_encrypted
 $e->set_is_data_encrypted($char);


 # archive_entry_set_is_metadata_encrypted
 $e->set_is_metadata_encrypted($char);

 # archive_entry_set_link
 $e->set_link($string);

 # archive_entry_set_link_utf8
 $e->set_link_utf8($string);


 # archive_entry_set_mode
 $e->set_mode($mode_t);


 # archive_entry_set_mtime
 $e->set_mtime($time_t, $long);

 # archive_entry_set_nlink
 $e->set_nlink($uint);


 # archive_entry_set_pathname
 $e->set_pathname($string);


 # archive_entry_set_pathname_utf8
 $e->set_pathname_utf8($string);


 # archive_entry_set_perm
 $e->set_perm($mode_t);


 # archive_entry_set_rdev
 $e->set_rdev($dev_t);


 # archive_entry_set_rdevmajor
 $e->set_rdevmajor($dev_t);


 # archive_entry_set_rdevminor
 $e->set_rdevminor($dev_t);


 # archive_entry_set_size
 $e->set_size($sint64);

 # archive_entry_set_symlink
 $e->set_symlink($string);

 # archive_entry_set_symlink_type (optional)
 $e->set_symlink_type($int);

 # archive_entry_set_symlink_utf8
 $e->set_symlink_utf8($string);


 # archive_entry_set_uid
 $e->set_uid($sint64);


 # archive_entry_set_uname
 $e->set_uname($string);


 # archive_entry_set_uname_utf8
 $e->set_uname_utf8($string);


 # archive_entry_size
 my $sint64 = $e->size;


 # archive_entry_size_is_set
 my $int = $e->size_is_set;


 # archive_entry_sourcepath
 my $string = $e->sourcepath;


 # archive_entry_sourcepath_w
 my $wstring = $e->sourcepath_w;


 # archive_entry_sparse_add_entry
 $e->sparse_add_entry($sint64_1, $sint64_2);


 # archive_entry_sparse_clear
 $e->sparse_clear;


 # archive_entry_sparse_count
 my $int = $e->sparse_count;


 # archive_entry_sparse_next
 my $int = $e->sparse_next($sint64*1, $sint64*2);


 # archive_entry_sparse_reset
 my $int = $e->sparse_reset;


 # archive_entry_stat
 my $stat = $e->stat;

Returns a FFI::C::Stat instance filled out from the entry metadata.

Not currently implemented on Windows.

 # archive_entry_strmode
 my $string = $e->strmode;

 # archive_entry_symlink
 my $string = $e->symlink;

 # archive_entry_symlink_type (optional)
 my $int = $e->symlink_type;

 # archive_entry_symlink_utf8
 my $string_utf8 = $e->symlink_utf8;


 # archive_entry_uid
 my $sint64 = $e->uid;


 # archive_entry_uid_is_set (optional)
 my $int = $e->uid_is_set;


 # archive_entry_uname
 my $string = $e->uname;


 # archive_entry_uname_utf8
 my $string_utf8 = $e->uname_utf8;


 # archive_entry_unset_atime
 $e->unset_atime;


 # archive_entry_unset_birthtime
 $e->unset_birthtime;


 # archive_entry_unset_ctime
 $e->unset_ctime;


 # archive_entry_unset_mtime
 $e->unset_mtime;


 # archive_entry_unset_size
 $e->unset_size;


 # archive_entry_update_gname_utf8
 my $int = $e->update_gname_utf8($string);

 # archive_entry_update_hardlink_utf8
 my $int = $e->update_hardlink_utf8($string);

 # archive_entry_update_link_utf8
 my $int = $e->update_link_utf8($string);


 # archive_entry_update_pathname_utf8
 my $int = $e->update_pathname_utf8($string);

 # archive_entry_update_symlink_utf8
 my $int = $e->update_symlink_utf8($string);


 # archive_entry_update_uname_utf8
 my $int = $e->update_uname_utf8($string);


 # archive_entry_xattr_add_entry
 my $int = $e->xattr_add_entry($name, $value);

Adds an xattr name/value pair.

 # archive_entry_xattr_clear
 $e->xattr_clear;


 # archive_entry_xattr_count
 my $int = $e->xattr_count;


 # archive_entry_xattr_next
 my $int = $e->xattr_next(\$name, $value);

Fetches the next xattr name/value pair.

 # archive_entry_xattr_reset
 my $int = $e->xattr_reset;


 my $r = Archive::Libarchive::EntryLinkResolver->new;

Create a new entry link resolver object.

 # archive_entry_linkresolver_set_strategy
 $lr->set_strategy($int);


 # archive_match_exclude_entry
 my $int1 = $m->exclude_entry($int2, $e);


 # archive_match_exclude_pattern
 my $int = $m->exclude_pattern($string);


 # archive_match_exclude_pattern_from_file
 my $int1 = $m->exclude_pattern_from_file($string, $int2);


 # archive_match_exclude_pattern_from_file_w
 my $int1 = $m->exclude_pattern_from_file_w($wstring, $int2);


 # archive_match_exclude_pattern_w
 my $int = $m->exclude_pattern_w($wstring);


 # archive_match_excluded
 my $int = $m->excluded($e);


 # archive_match_include_date
 my $int1 = $m->include_date($int2, $string);


 # archive_match_include_date_w
 my $int1 = $m->include_date_w($int2, $wstring);


 # archive_match_include_file_time
 my $int1 = $m->include_file_time($int2, $string);


 # archive_match_include_file_time_w
 my $int1 = $m->include_file_time_w($int2, $wstring);


 # archive_match_include_gid
 my $int = $m->include_gid($sint64);


 # archive_match_include_gname
 my $int = $m->include_gname($string);


 # archive_match_include_gname_w
 my $int = $m->include_gname_w($wstring);


 # archive_match_include_pattern
 my $int = $m->include_pattern($string);


 # archive_match_include_pattern_from_file
 my $int1 = $m->include_pattern_from_file($string, $int2);


 # archive_match_include_pattern_from_file_w
 my $int1 = $m->include_pattern_from_file_w($wstring, $int2);


 # archive_match_include_pattern_w
 my $int = $m->include_pattern_w($wstring);


 # archive_match_include_time
 my $int1 = $m->include_time($int2, $time_t, $long);


 # archive_match_include_uid
 my $int = $m->include_uid($sint64);


 # archive_match_include_uname
 my $int = $m->include_uname($string);


 # archive_match_include_uname_w
 my $int = $m->include_uname_w($wstring);


 my $r = Archive::Libarchive::Match->new;

Create a new archive match object.

 # archive_match_owner_excluded
 my $int = $m->owner_excluded($e);


 # archive_match_path_excluded
 my $int = $m->path_excluded($e);


 # archive_match_path_unmatched_inclusions
 my $int = $m->path_unmatched_inclusions;


 # archive_match_path_unmatched_inclusions_next
 my $int = $m->path_unmatched_inclusions_next(\$string);


 # archive_match_set_inclusion_recursion (optional)
 my $int1 = $m->set_inclusion_recursion($int2);


 # archive_match_time_excluded
 my $int = $m->time_excluded($e);

The status code constants are documented in the main documentation page Archive::Libarchive.

These constants can be imported individually from Archive::Libarchive using the normal Exporter interface, or all of them can be imported with the ":const" export tag or along with functions with the ":all" tag.

For the rest please consult the "libarchive" documentation.

The following methods are not currently implemented. The reason for this is usually for one of 1) the method doesn't make sense in the context of Perl 2) the methods have been renamed, and this is the old name kept for compatibility in "libarchive" 3) the methods have deprecated and will be removed in a future version of "libarchive" 4) we haven't gotten around to writing bindings for them.

Provides an interface for listing and retrieving entries from an archive without extracting them to the local filesystem.
Provides an interface for extracting arbitrary archives of any format/filter supported by "libarchive".
Decompresses / unwraps files that have been compressed or wrapped in any of the filter formats supported by "libarchive"
This is the main top-level module for using "libarchive" from Perl. It is the best place to start reading the documentation. It pulls in the other classes and "libarchive" constants so that you only need one "use" statement to effectively use "libarchive".
The base class of all archive classes. This includes some common error reporting functionality among other things.
This class is used for reading from archives.
This class is for creating new archives.
This class is for reading Archive::Libarchive::Entry objects from disk so that they can be written to Archive::Libarchive::ArchiveWrite objects.
This class is for writing Archive::Libarchive::Entry objects to disk that have been written from Archive::Libarchive::ArchiveRead objects.
This class represents a file in an archive, or on disk.
This class exposes the "libarchive" link resolver API.
This class exposes the "libarchive" match API.
Build Dist::Zilla based dist tarballs with libarchive instead of the built in Archive::Tar.
If a suitable system "libarchive" can't be found, then this Alien will be installed to provide it.
The "libarchive" project home page.
<https://github.com/libarchive/libarchive/wiki>
The "libarchive" project wiki.
<https://github.com/libarchive/libarchive/wiki/ManualPages>
Some of the "libarchive" man pages are listed here.

Graham Ollis <plicease@cpan.org>

This software is copyright (c) 2021,2022 by Graham Ollis.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

2024-05-17 perl v5.40.2
Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.