vapi/libarchive.vapi

   1 /* libarchive.vapi - Bindings for libarchive(3) (version 2).
   2  *
   3  * Copyright (C) 2009 Julian Andres Klode <jak@jak-linux.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Julian Andres Klode <jak@jak-linux.org>
  21  *
  22  */
  23
  24
  25 [CCode (cprefix="ARCHIVE_", lower_case_cprefix="archive_", cheader_filename = "archive.h")]
  26 namespace Archive {
  27         public const int VERSION_NUMBER;
  28         public const string VERSION_STRING;
  29         public int version_number ();
  30         public unowned string version_string ();
  31
  32         [CCode (instance_pos = 1.9, cname="archive_read_callback")]
  33         public delegate ssize_t ReadCallback (Archive archive, out void* buffer);
  34         [CCode (instance_pos = 1.9, cname="archive_skip_callback")]
  35         public delegate Posix.off_t SkipCallback (Archive archive, Posix.off_t request);
  36         [CCode (instance_pos = 1.9, cname="archive_write_callback")]
  37         public delegate ssize_t WriteCallback (Archive archive, void* buffer, size_t length);
  38         [CCode (instance_pos = 1.9, cname="archive_open_callback")]
  39         public delegate int OpenCallback (Archive archive);
  40
  41         [CCode (cname="archive_close_callback")]
  42         public delegate int CloseCallback (Archive archive);
  43
  44         // In reality a "void (*_progress_func)(void *)" parameter without name.
  45         public delegate void ExtractProgressCallback ();
  46
  47         [CCode (cprefix="ARCHIVE_", cname="int", has_type_id = false)]
  48         public enum Result {
  49                 EOF,
  50                 OK,
  51                 RETRY,
  52                 WARN,
  53                 FAILED
  54         }
  55
  56         // see libarchive/archive.h, l. 218 ff.
  57         [CCode (cname="int", has_type_id = false)]
  58         public enum Filter {
  59                 NONE,
  60                 GZIP,
  61                 BZIP2,
  62                 COMPRESS,
  63                 PROGRAM,
  64                 LZMA,
  65                 XZ,
  66                 UU,
  67                 RPM,
  68                 LZIP,
  69                 LRZIP,
  70                 LZOP,
  71                 GRZIP
  72         }
  73
  74         [CCode (cname="int", has_type_id = false)]
  75         [Version (deprecated_since="3.0", replacement="Filter")]
  76         public enum Compression {
  77                 NONE,
  78                 GZIP,
  79                 BZIP2,
  80                 COMPRESS,
  81                 PROGRAM,
  82                 LZMA,
  83                 XZ,
  84                 UU,
  85                 RPM,
  86                 LZIP,
  87                 LRZIP
  88         }
  89
  90         [CCode (cname="int", has_type_id = false)]
  91         public enum Format {
  92                 BASE_MASK,
  93                 CPIO,
  94                 CPIO_POSIX,
  95                 CPIO_BIN_LE,
  96                 CPIO_BIN_BE,
  97                 CPIO_SVR4_NOCRC,
  98                 CPIO_SVR4_CRC,
  99                 SHAR,
 100                 SHAR_BASE,
 101                 SHAR_DUMP,
 102                 TAR,
 103                 TAR_USTAR,
 104                 TAR_PAX_INTERCHANGE,
 105                 TAR_PAX_RESTRICTED,
 106                 TAR_GNUTAR,
 107                 ISO9660,
 108                 ISO9660_ROCKRIDGE,
 109                 ZIP,
 110                 EMPTY,
 111                 AR,
 112                 AR_GNU,
 113                 AR_BSD,
 114                 MTREE
 115         }
 116
 117         [CCode (cprefix="ARCHIVE_EXTRACT_", cname="int", has_type_id = false)]
 118         public enum ExtractFlags {
 119                 OWNER,
 120                 PERM,
 121                 TIME,
 122                 NO_OVERWRITE,
 123                 UNLINK,
 124                 ACL,
 125                 FFLAGS,
 126                 XATTR,
 127                 SECURE_SYMLINKS,
 128                 SECURE_NODOTDOT,
 129                 NO_AUTODIR,
 130                 NO_OVERWRITE_NEWER,
 131                 SPARSE
 132         }
 133
 134         [Compact]
 135         [CCode (cname="struct archive", cprefix="archive_")]
 136         public class Archive {
 137                 public int64 position_compressed ();
 138                 public int64 position_uncompressed ();
 139
 140                 [Version (deprecated_since="3.0", replacement="Archive.filter_code (0)")]
 141                 public Compression compression ();
 142                 public Format format ();
 143                 // Filter #0 is the one closest to the format, -1 is a synonym
 144                 // for the last filter, which is always the pseudo-filter that
 145                 // wraps the client callbacks. (libarchive/archive.h, l. 955)
 146                 public Filter filter_code (int filter_no);
 147
 148                 public unowned string compression_name ();
 149                 public unowned string format_name ();
 150                 public unowned string filter_name (int filter_no);
 151
 152                 public int filter_count ();
 153                 public int file_count ();
 154
 155                 public int errno ();
 156                 public unowned string error_string ();
 157                 public void clear_error ();
 158                 public void set_error (int err, string fmt, ...);
 159                 public void copy_error (Archive src);
 160         }
 161
 162
 163         [Compact]
 164         [CCode (cname="struct archive", free_function="archive_read_finish")]
 165         public class Read : Archive {
 166                 public Read ();
 167                 // see https://github.com/libarchive/libarchive/wiki/Libarchive3#functions-that-are-being-renamed
 168                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_all ()")]
 169                 public Result support_compression_all ();
 170                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_bzip2 ()")]
 171                 public Result support_compression_bzip2 ();
 172                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_compress ()")]
 173                 public Result support_compression_compress ();
 174                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_gzip ()")]
 175                 public Result support_compression_gzip ();
 176                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_lzma ()")]
 177                 public Result support_compression_lzma ();
 178                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_none ()")]
 179                 public Result support_compression_none ();
 180                 [Version (deprecated_since="3.0", replacement="Archive.Read.support_filter_program (string command)")]
 181                 public Result support_compression_program (string command);
 182                 public Result support_filter_all ();
 183                 public Result support_filter_bzip2 ();
 184                 public Result support_filter_compress ();
 185                 public Result support_filter_gzip ();
 186                 public Result support_filter_grzip ();
 187                 public Result support_filter_lrzip ();
 188                 public Result support_filter_lzip ();
 189                 public Result support_filter_lzma ();
 190                 public Result support_filter_lzop ();
 191                 public Result support_filter_none ();
 192                 public Result support_filter_program (string command);
 193                 // TODO support_filter_program_signature (string, const void *, size_t)
 194                 public Result support_filter_rpm ();
 195                 public Result support_filter_uu ();
 196                 public Result support_filter_xz ();
 197                 public Result support_format_7zip ();
 198                 public Result support_format_all ();
 199                 public Result support_format_ar ();
 200                 public Result support_format_by_code (Format format_code);
 201                 public Result support_format_cab ();
 202                 public Result support_format_cpio ();
 203                 public Result support_format_empty ();
 204                 public Result support_format_gnutar ();
 205                 public Result support_format_iso9660 ();
 206                 public Result support_format_lha ();
 207                 public Result support_format_mtree ();
 208                 public Result support_format_rar ();
 209                 public Result support_format_raw ();
 210                 public Result support_format_tar ();
 211                 public Result support_format_xar ();
 212                 public Result support_format_zip ();
 213                 public Result support_format_zip_streamable ();
 214                 public Result support_format_zip_seekable ();
 215
 216                 public Result set_format (Format format_code);
 217                 public Result append_filter (Filter filter_code);
 218                 public Result append_filter_program (string cmd);
 219                 // TODO append_filter_program_signature (string, const void *, size_t);
 220
 221                 public Result open (
 222                         [CCode (delegate_target_pos = 0.9)] OpenCallback ocb,
 223                         [CCode (delegate_target_pos = 0.9)] ReadCallback rcb,
 224                         [CCode (delegate_target_pos = 0.9)] CloseCallback ccb
 225                 );
 226
 227                 public Result open2 (
 228                         [CCode (delegate_target_pos = 0.9)] OpenCallback ocb,
 229                         [CCode (delegate_target_pos = 0.9)] ReadCallback rcb,
 230                         [CCode (delegate_target_pos = 0.9)] SkipCallback scb,
 231                         [CCode (delegate_target_pos = 0.9)] CloseCallback ccb
 232                 );
 233
 234                 public Result open_filename (string filename, size_t _block_size);
 235                 public Result open_memory (void* buff, size_t size);
 236                 public Result open_fd (int fd, size_t block_size);
 237                 public Result open_FILE (GLib.FileStream file);
 238                 public Result next_header (out unowned Entry entry);
 239                 public int64 header_position ();
 240
 241                 [CCode (cname="archive_read_data")]
 242                 public ssize_t read_data (void* buffer, size_t size);
 243                 [CCode (cname="archive_read_data_block")]
 244                 public Result read_data_block (out void* buff, out size_t size, out Posix.off_t offset);
 245                 [CCode (cname="archive_read_data_skip")]
 246                 public Result read_data_skip ();
 247                 [CCode (cname="archive_read_data_into_buffer")]
 248                 public Result read_data_into_buffer (void* buffer, ssize_t len);
 249                 [CCode (cname="archive_read_data_into_fd")]
 250                 public Result read_data_into_fd (int fd);
 251
 252                 public Result extract (Entry entry, ExtractFlags? flags=0);
 253                 public Result extract2 (Entry entry, Write dest);
 254                 public void extract_set_progress_callback (ExtractProgressCallback cb);
 255                 public void extract_set_skip_file (Posix.dev_t dev, Posix.ino_t ino);
 256                 public Result close ();
 257         }
 258
 259         [Compact]
 260         [CCode (cname = "struct archive", free_function="archive_read_finish")]
 261         public class ReadDisk : Read {
 262                 public ReadDisk ();
 263                 public Result set_symlink_logical ();
 264                 public Result set_symlink_physical ();
 265                 public Result set_symlink_hybrid ();
 266                 public Result entry_from_file (Entry entry, int fd, Posix.Stat stat);
 267                 public unowned string gname (Posix.gid_t gid);
 268                 public unowned string uname (Posix.uid_t uid);
 269                 public Result set_standard_lookup ();
 270
 271                 // HACK, they have no name in C. May not work correctly.
 272                 [CCode (instance_pos = 0, cname="void")]
 273                 public delegate unowned string GNameLookup (Posix.gid_t gid);
 274                 [CCode (instance_pos = 0, cname="void")]
 275                 public delegate unowned string UNameLookup (Posix.uid_t uid);
 276                 [CCode (instance_pos = 0, cname="void")]
 277                 public delegate void Cleanup ();
 278
 279                 public Result set_gname_lookup (
 280                         GNameLookup lookup,
 281                         Cleanup? cleanup = null
 282                 );
 283
 284                 public Result set_uname_lookup (
 285                         UNameLookup lookup,
 286                         Cleanup? cleanup = null
 287                 );
 288         }
 289
 290         [CCode (cname = "struct archive", free_function="archive_write_finish")]
 291         public class Write : Archive {
 292                 public Write ();
 293                 // see https://github.com/libarchive/libarchive/wiki/Libarchive3#functions-that-are-being-renamed
 294                 [Version (deprecated_since="3.0", replacement="Archive.Write.add_filter_bzip2 ()")]
 295                 public Result set_compression_bzip2 ();
 296                 [Version (deprecated_since="3.0", replacement="Archive.Write.add_filter_compress ()")]
 297                 public Result set_compression_compress ();
 298                 [Version (deprecated_since="3.0", replacement="Archive.Write.add_filter_gzip ()")]
 299                 public Result set_compression_gzip ();
 300                 [Version (deprecated_since="3.0", replacement="Archive.Write.add_filter_lzma ()")]
 301                 public Result set_compression_lzma ();
 302                 [Version (deprecated_since="3.0", replacement="Archive.Write.add_filter_none ()")]
 303                 public Result set_compression_none ();
 304                 public Result set_compression_program (string cmd);
 305                 public Result add_filter (Filter filter_code);
 306                 public Result add_filter_by_name (string name);
 307                 public Result add_filter_b64encode ();
 308                 public Result add_filter_bzip2 ();
 309                 public Result add_filter_compress ();
 310                 public Result add_filter_grzip ();
 311                 public Result add_filter_gzip ();
 312                 public Result add_filter_lrzip ();
 313                 public Result add_filter_lzip ();
 314                 public Result add_filter_lzma ();
 315                 public Result add_filter_lzop ();
 316                 public Result add_filter_none ();
 317                 public Result add_filter_program (string cmd);
 318                 public Result add_filter_uuencode ();
 319                 public Result add_filter_xz ();
 320                 public Result set_format (Format format);
 321                 public Result set_format_by_name (string name);
 322                 public Result set_format_7zip ();
 323                 public Result set_format_ar_bsd ();
 324                 public Result set_format_ar_svr4 ();
 325                 public Result set_format_cpio ();
 326                 public Result set_format_cpio_newc ();
 327                 public Result set_format_gnutar ();
 328                 public Result set_format_iso9660 ();
 329                 public Result set_format_mtree ();
 330                 public Result set_format_mtree_classic ();
 331                 public Result set_format_pax ();
 332                 public Result set_format_pax_restricted ();
 333                 public Result set_format_raw ();
 334                 public Result set_format_shar ();
 335                 public Result set_format_shar_dump ();
 336                 public Result set_format_ustar ();
 337                 public Result set_format_v7tar ();
 338                 public Result set_format_xar ();
 339                 public Result set_format_zip ();
 340
 341                 public Result set_bytes_per_block (int bytes_per_block);
 342                 public int get_bytes_per_block ();
 343                 public Result set_bytes_in_last_block (int bytes_in_last_block);
 344                 public int get_bytes_in_last_block ();
 345                 public Result set_skip_file (Posix.dev_t dev, Posix.ino_t ino);
 346
 347                 public Result open (
 348                         [CCode (delegate_target_pos = 0.9)] OpenCallback ocb,
 349                         [CCode (delegate_target_pos = 0.9)] WriteCallback rcb,
 350                         [CCode (delegate_target_pos = 0.9)] CloseCallback ccb
 351                 );
 352                 public Result open_fd (int fd);
 353                 public Result open_filename (string filename);
 354                 public Result open_FILE (GLib.FileStream file);
 355                 public Result open_memory (void* buffer, size_t buff_size, out size_t used);
 356
 357                 [CCode (cname="archive_write_header")]
 358                 public Result write_header (Entry entry);
 359                 [CCode (cname="archive_write_data")]
 360                 public ssize_t write_data (void* data, size_t size);
 361                 [CCode (cname="archive_write_data_block")]
 362                 public ssize_t write_data_block (void* data, size_t size, Posix.off_t offset);
 363
 364                 public Result finish_entry ();
 365                 public Result close ();
 366         }
 367
 368         [Compact]
 369         [CCode (cname = "struct archive", free_function="archive_write_finish")]
 370         public class WriteDisk : Write {
 371                 public WriteDisk ();
 372
 373                 public Result set_skip_file (Posix.dev_t dev, Posix.ino_t ino);
 374                 public Result set_options (ExtractFlags flags);
 375                 public Result set_standard_lookup ();
 376
 377                 // HACK, they have no name in C. May not work correctly.
 378                 [CCode (instance_pos = 0, cname="gid_t")]
 379                 public delegate Posix.gid_t GroupLookup (string group, Posix.gid_t gid);
 380                 [CCode (instance_pos = 0, cname="uid_t")]
 381                 public delegate Posix.uid_t UserLookup (string user, Posix.uid_t uid);
 382                 [CCode (instance_pos = 0, cname="void")]
 383                 public delegate void Cleanup ();
 384
 385                 public Result set_group_lookup (
 386                         [CCode (delegate_target_pos = 0.9) ] GroupLookup lookup,
 387                         [CCode (delegate_target_pos = 0.9) ] Cleanup? cleanup = null
 388                 );
 389
 390                 public Result set_user_lookup (
 391                         [CCode (delegate_target_pos = 0.9) ] UserLookup lookup,
 392                         [CCode (delegate_target_pos = 0.9) ] Cleanup? cleanup = null
 393                 );
 394         }
 395
 396         [Compact]
 397         [CCode (cname = "struct archive_entry", cheader_filename = "archive_entry.h")]
 398         public class Entry {
 399                 public Entry ();
 400                 public time_t atime ();
 401                 public long atime_nsec ();
 402                 public bool atime_is_set ();
 403                 public time_t birthtime ();
 404                 public long birthtime_nsec ();
 405                 public bool birthtime_is_set ();
 406                 public time_t ctime ();
 407                 public long ctime_nsec ();
 408                 public bool ctime_is_set ();
 409                 public Posix.dev_t dev ();
 410                 public Posix.dev_t devmajor ();
 411                 public Posix.dev_t devminor ();
 412                 public Posix.mode_t filetype ();
 413                 public unowned string fflags_text ();
 414                 public Posix.gid_t gid ();
 415                 public unowned string gname ();
 416                 public unowned string hardlink ();
 417                 public Posix.ino_t ino ();
 418                 public Posix.mode_t mode ();
 419                 public time_t mtime ();
 420                 public long mtime_nsec ();
 421                 public bool mtime_is_set ();
 422                 public uint nlink ();
 423                 public unowned string pathname ();
 424                 public Posix.dev_t rdev ();
 425                 public Posix.dev_t rdevmajor ();
 426                 public Posix.dev_t rdevminor ();
 427                 public unowned string sourcepath ();
 428                 public int64 size ();
 429                 public bool size_is_set ();
 430                 public unowned string strmode ();
 431                 public unowned string symlink ();
 432                 public Posix.uid_t uid ();
 433                 public unowned string uname ();
 434                 public void set_atime (time_t atime, long blah);
 435                 public void unset_atime ();
 436                 public void set_birthtime (time_t birthtime, long blah);
 437                 public void unset_birthtime ();
 438                 public void set_ctime (time_t atime, long blah);
 439                 public void unset_ctime ();
 440                 public void set_dev (Posix.dev_t dev);
 441                 public void set_devmajor (Posix.dev_t major);
 442                 public void set_devminor (Posix.dev_t major);
 443                 public void set_filetype (uint filetype);
 444                 public void set_fflags (ulong set, ulong clear);
 445                 public unowned string copy_fflags_text (string text);
 446                 public void set_gid (Posix.gid_t gid);
 447                 public void set_gname (string gname);
 448                 public Result update_gname_utf8 (string gname);
 449                 public void set_hardlink (string link);
 450                 public void set_ino (ulong ino);
 451                 public void set_link (string link);
 452                 public Result update_link_utf8 (string link);
 453                 public void set_mode (Posix.mode_t mode);
 454                 public void set_mtime (time_t mtime, long blah);
 455                 public void unset_mtime ();
 456                 public void set_nlink (uint nlink);
 457                 public void set_pathname (string pathname);
 458                 public Result  update_pathname_utf8 (string pathname);
 459                 public void set_perm (Posix.mode_t mode);
 460                 public void set_rdev (Posix.dev_t dev);
 461                 public void set_rdevmajor (Posix.dev_t devmajor);
 462                 public void set_rdevminor (Posix.dev_t devminor);
 463                 public void set_size (int64 size);
 464                 public void unset_size ();
 465                 public void copy_sourcepath (string sourcepath);
 466                 public void set_symlink (string symlink);
 467                 public void set_uid (Posix.uid_t uid);
 468                 public void set_uname (string uname);
 469                 public Result update_uname_utf8 (string uname);
 470
 471                 public unowned Posix.Stat stat ();
 472                 public void copy_stat (Posix.Stat stat);
 473
 474                 public unowned Entry clear ();
 475                 public Entry clone ();
 476
 477                 public void xattr_clear();
 478                 public void xattr_add_entry(string name, void* value, size_t size);
 479                 public int xattr_count();
 480                 public Result xattr_reset();
 481                 public Result xattr_next(out unowned string name, out void* value, out size_t size);
 482
 483                 [Compact]
 484                 public class LinkResolver {
 485                         public LinkResolver ();
 486                         public void set_strategy (Format format_code);
 487                         public void linkify (Entry a, Entry b);
 488                 }
 489         }
 490 }