hex_erl_tar (hex_core v0.17.0)

-type add_opt() ::
          dereference | verbose |
          {chunks, pos_integer()} |
          {atime, non_neg_integer()} |
          {mtime, non_neg_integer()} |
          {ctime, non_neg_integer()} |
          {mode, non_neg_integer()} |
          {uid, non_neg_integer()} |
          {gid, non_neg_integer()}.

create_opt/0

-type create_opt() :: compressed | cooked | dereference | verbose.

descriptor_type/0

-type descriptor_type() :: tar_descriptor() | reg_file_reader() | sparse_file_reader().

extract_opt/0

-type extract_opt() ::
          {cwd, string()} |
          {files, [name_in_archive()]} |
          {chunks, pos_integer()} |
          {max_size, pos_integer() | infinity} |
          compressed | cooked | memory | keep_old_files | verbose.

file_op/0

-type file_op() ::
          fun((write | close | read2 | position,
               {user_data(), iodata()} |
               user_data() |
               {user_data(), non_neg_integer()} |
               {user_data(), non_neg_integer()}) ->
                  ok | eof | {ok, string() | binary()} | {ok, non_neg_integer()} | {error, term()}).

filelist/0

-type filelist() :: [file:filename() | {name_in_archive(), file:filename_all()}].

gid/0

-type gid() :: non_neg_integer().

header_gnu/0

-type header_gnu() ::
          #header_gnu{header_v7 :: header_v7(),
                      magic :: binary(),
                      version :: binary(),
                      uname :: binary(),
                      gname :: binary(),
                      devmajor :: binary(),
                      devminor :: binary(),
                      atime :: binary(),
                      ctime :: binary(),
                      sparse :: sparse_array(),
                      real_size :: binary()}.

header_v7/0

-type header_v7() ::
          #header_v7{name :: binary(),
                     mode :: binary(),
                     uid :: binary(),
                     gid :: binary(),
                     size :: binary(),
                     mtime :: binary(),
                     checksum :: binary(),
                     typeflag :: byte(),
                     linkname :: binary()}.

mode/0

-type mode() :: non_neg_integer().

name_in_archive/0

-type name_in_archive() :: string().

open_type/0

-type open_type() :: file:filename_all() | {binary, binary()} | {file, file:io_device()}.

reg_file_reader/0

-type reg_file_reader() ::
          #reg_file_reader{handle :: tar_descriptor(),
                           num_bytes :: term(),
                           pos :: term(),
                           size :: term()}.

sparse_array/0

-type sparse_array() ::
          #sparse_array{entries :: [sparse_entry()],
                        is_extended :: boolean(),
                        max_entries :: non_neg_integer()}.

sparse_entry/0

-type sparse_entry() :: #sparse_entry{offset :: non_neg_integer(), num_bytes :: non_neg_integer()}.

sparse_file_reader/0

-type sparse_file_reader() ::
          #sparse_file_reader{handle :: tar_descriptor(),
                              num_bytes :: term(),
                              pos :: term(),
                              size :: term(),
                              sparse_map :: term()}.

tar_descriptor/0

-opaque tar_descriptor()

tar_entry/0

-type tar_entry() ::
          {Name :: name_in_archive(),
           Type :: typeflag(),
           Size :: non_neg_integer(),
           MTime :: tar_time(),
           Mode :: mode(),
           Uid :: uid(),
           Gid :: gid()}.

tar_header/0

-type tar_header() ::
          #tar_header{name :: name_in_archive(),
                      mode :: non_neg_integer(),
                      uid :: non_neg_integer(),
                      gid :: non_neg_integer(),
                      size :: non_neg_integer(),
                      mtime :: tar_time(),
                      typeflag :: char(),
                      linkname :: name_in_archive(),
                      uname :: string(),
                      gname :: string(),
                      devmajor :: non_neg_integer(),
                      devminor :: non_neg_integer(),
                      atime :: tar_time(),
                      ctime :: tar_time()}.

tar_time/0

-type tar_time() :: non_neg_integer().

typeflag/0

-type typeflag() :: regular | link | symlink | char | block | directory | fifo | reserved | unknown.

uid/0

-type uid() :: non_neg_integer().

user_data/0

-type user_data() :: term().

Functions

add(TarDescriptor, Name, Options)

-spec add(TarDescriptor, Name, Options) -> ok | {error, term()}
             when
                 TarDescriptor :: tar_descriptor(),
                 Name :: name_in_archive() | {name_in_archive(), file:filename_all()},
                 Options :: [add_opt()].

add(TarDescriptor, Filename, NameInArchive, Options)

-spec add(TarDescriptor, Filename, NameInArchive, Options) -> ok | {error, term()}
             when
                 TarDescriptor :: tar_descriptor(),
                 Filename :: file:filename_all(),
                 NameInArchive :: name_in_archive(),
                 Options :: [add_opt()].

close(TarDescriptor)

-spec close(TarDescriptor :: tar_descriptor()) -> ok | {error, term()}.

create(Name, FileList)

-spec create(file:filename_all(), filelist()) -> ok | {error, {string(), term()}}.

create(Name, FileList, Options)

-spec create(file:filename_all(), filelist(), [create_opt()]) ->
                ok | {error, term()} | {error, {string(), term()}}.

extract(Open)

-spec extract(Open :: open_type()) -> ok | {error, term()}.

extract(Open, Opts)

-spec extract(Open :: open_type(), []) -> ok | {error, term()};
             (Open :: open_type(), [extract_opt(), ...]) ->
                 ok | {ok, [{string(), binary()}]} | {error, term()}.

-spec format_error(term()) -> string().

init(UserData, AccessMode, Fun)

-spec init(UserData :: user_data(), write | read, file_op()) -> {ok, tar_descriptor()} | {error, badarg}.

open(Open, Mode)

-spec open(Open :: open_type(), [write | compressed | cooked]) ->
              {ok, tar_descriptor()} | {error, term()}.

t(Name)

-spec t(file:filename()) -> ok | {error, term()}.

table(Open)

-spec table(Open :: open_type()) -> {ok, [name_in_archive()]} | {error, term()}.

table(Open, Opts)

-spec table(Open :: open_type(), [compressed | verbose | cooked]) ->
               {ok, [name_in_archive() | tar_entry()]} | {error, term()}.

tt(Name)

-spec tt(open_type()) -> ok | {error, term()}.