added a part of the example code

oss-internship-2020/sapi_libarchive/CMakeLists.txt

@@ -22,6 +22,33 @@ set(CMAKE_CXX_STANDARD_REQUIRED 17)
 # Build SAPI library
 set(SAPI_ROOT "/usr/local/google/home/amedar/internship/sandboxed-api" CACHE PATH "Path to the Sandboxed API source tree")
 
+file(MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/patches")
+
+#add_custom_command(
+#    OUTPUT "${PROJECT_BINARY_DIR}/patches/archive.h"
+#    COMMENT "Applying patches."
+#    COMMAND cp "${PROJECT_SOURCE_DIR}/patches/header.patch" "${PROJECT_BINARY_DIR}/patches/"
+#    COMMAND cp "${PROJECT_SOURCE_DIR}/libarchive/libarchive/archive.h" "${PROJECT_BINARY_DIR}/patches/"
+#    COMMAND cd "${PROJECT_BINARY_DIR}/patches" && patch < header.patch
+#    COMMAND cp "${PROJECT_BINARY_DIR}/patches/archive.h" "${PROJECT_SOURCE_DIR}/libarchive/libarchive/"
+#)
+#
+#set_property(
+#    SOURCE
+#    "${PROJECT_SOURCE_DIR}/libarchive/libarchive/archive.h"
+#    APPEND PROPERTY OBJECT_DEPENDS
+#    "${PROJECT_BINARY_DIR}/patches/archive.h"
+#)
+
+
+add_subdirectory(libarchive)
+
+#set_property(SOURCE
+#    "${PROJECT_SOURCE_DIR}/libarchive/libarchive/archive.h"
+#    APPEND PROPERTY OBJECT_DEPENDS
+#    "${PROJECT_SOURCE_DIR}/patches/archive.h"
+#)
+
 add_subdirectory("${SAPI_ROOT}"
   "${CMAKE_BINARY_DIR}/sandboxed-api-build"
   EXCLUDE_FROM_ALL
@@ -34,7 +61,10 @@ add_sapi_library(
 
   FUNCTIONS ${FUNCTIONS_LIST}
 
-  INPUTS libarchive/libarchive/archive.h
+  INPUTS
+    libarchive/libarchive/archive.h
+    libarchive/libarchive/archive_entry.h
+
   LIBRARY archive
   LIBRARY_NAME Libarchive
   NAMESPACE ""
@@ -45,5 +75,4 @@ target_include_directories(libarchive_sapi INTERFACE
 )
 
 
-add_subdirectory(libarchive)
 add_subdirectory(examples)

oss-internship-2020/sapi_libarchive/examples/CMakeLists.txt

@@ -22,16 +22,9 @@ target_link_libraries(helpers PUBLIC
     sapi::sapi
     sandbox2::fileops
     sandbox2::util
-)
-
-# small example - todo delete later
-add_executable(small_example
-    small_example.cc
-)
-
-target_link_libraries(small_example PRIVATE
-    archive
-    helpers
+    sandbox2::file_base
+    glog::glog
+    libarchive_sapi
 )
 
 add_executable(sapi_example
@@ -44,6 +37,17 @@ target_link_libraries(sapi_example PRIVATE
     glog::glog
 )
 
+add_executable(sapi_minitar
+    sapi_minitar.cc
+)
+
+target_link_libraries(sapi_minitar PRIVATE
+    helpers
+    libarchive_sapi
+    sapi::sapi
+    #glog::glog
+)
+
 #add_executable(untar
 #    untar.cc
 #)
@@ -68,7 +72,7 @@ target_link_libraries(sapi_example PRIVATE
 
 
 add_executable(minitar
-    minitar.cc
+    orig/minitar.cc
 )
 
 target_link_libraries(minitar PRIVATE

oss-internship-2020/sapi_libarchive/examples/helpers.cc

@@ -1,13 +1,43 @@
 
 #include "helpers.h"
 
-std::vector<std::string> MakeAbsolutePaths(char *argv[]) {
+std::string MakeAbsolutePathAtCWD(std::string path) {
+    std::string result =  sandbox2::file_util::fileops::MakeAbsolute(path, sandbox2::file_util::fileops::GetCWD());
+    CHECK(result != "") << "Could not create absolute path for: " << path;
+    return sandbox2::file::CleanPath(result);
+}
+
+std::vector<std::string> MakeAbsolutePathsVec(char *argv[]) {
   std::vector<std::string> arr;
   sandbox2::util::CharPtrArrToVecString(argv, &arr);
-    // std::transform(arr.begin(), arr.end(), arr.begin(), [](std::string s) -> std::string {
-    //     return sandbox2::file_util::fileops::MakeAbsolute(s, sandbox2::file_util::fileops::GetCWD());
-    // });
-    auto f = std::bind(sandbox2::file_util::fileops::MakeAbsolute, std::placeholders::_1, sandbox2::file_util::fileops::GetCWD());
-    std::transform(arr.begin(), arr.end(), arr.begin(), f);
+  std::transform(arr.begin(), arr.end(), arr.begin(), MakeAbsolutePathAtCWD);
   return arr;
 }
+
+// std::string GetErrorString(sapi::v::Ptr *archive, LibarchiveSandbox &sandbox, LibarchiveApi &api) {
+//     sapi::StatusOr<char *> ret = api.archive_error_string(archive);
+//     CHECK(ret.ok() && ret) << "Could not get error message";
+
+//     sapi::StatusOr<std::string> ret2 = sandbox.GetCString(sapi::v::RemotePtr(ret.value()));
+//     CHECK(ret.ok()) << "Could not transfer error message";
+//     return ret2.value();
+// }
+
+
+std::string CheckStatusAndGetString(const sapi::StatusOr<char *> &status, LibarchiveSandbox &sandbox) {
+    CHECK(status.ok() && status.value()) << "Could not get error message";
+
+    sapi::StatusOr<std::string> ret = sandbox.GetCString(sapi::v::RemotePtr(status.value()));
+    CHECK(ret.ok()) << "Could not transfer error message";
+    return ret.value();
+}
+
+// std::string CallFunctionAndGetString(sapi::v::Ptr *archive, LibarchiveSandbox &sandbox,
+// LibarchiveApi *api, sapi::StatusOr<char *> (LibarchiveApi::*func)(sapi::v::Ptr *)) {
+//     sapi::StatusOr<char *> ret = (api->*func)(archive);
+//     CHECK(ret.ok() && ret) << "Could not get error message";
+
+//     sapi::StatusOr<std::string> ret2 = sandbox.GetCString(sapi::v::RemotePtr(ret.value()));
+//     CHECK(ret.ok()) << "Could not transfer error message";
+//     return ret2.value();
+// }

oss-internship-2020/sapi_libarchive/examples/helpers.h

@@ -1,13 +1,31 @@
 #ifndef SAPI_LIBARCHIVE_HELPERS_H
 #define SAPI_LIBARCHIVE_HELPERS_H
 
-#include "sandboxed_api/sandbox2/util/fileops.h"
+#include <glog/logging.h>
 #include "sandboxed_api/sandbox2/util.h"
+#include "sandboxed_api/sandbox2/util/fileops.h"
+#include "sandboxed_api/sandbox2/util/path.h"
+#include "libarchive_sapi.sapi.h"
 
 
 // Used to convert the paths provided as arguments for the program
 // (the paths used) to an array of absolute paths. This allows the user
 // to use either relative or absolute paths
-std::vector<std::string> MakeAbsolutePaths(char *argv[]);
+std::vector<std::string> MakeAbsolutePathsVec(char *argv[]);
+
+
+// Converts only one string to an absolute path by prepending the current working
+// directory to the relative path
+std::string MakeAbsolutePathAtCWD(std::string path);
+
+// Calls the archive_error_string and returns the mesage after it was transferred
+// to the client process.
+// std::string GetErrorString(sapi::v::Ptr *archive, LibarchiveSandbox &sandbox, LibarchiveApi &api);
+
+
+std::string CheckStatusAndGetString(const sapi::StatusOr<char *> &status, LibarchiveSandbox &sandbox);
+
+// std::string CallFunctionAndGetString(sapi::v::Ptr *archive, LibarchiveSandbox &sandbox,
+// LibarchiveApi *api, sapi::StatusOr<char *> (LibarchiveApi::*func)(sapi::v::Ptr *));
 
 #endif  // SAPI_LIBARCHIVE_HELPERS_H

oss-internship-2020/sapi_libarchive/examples/sandbox.h

@@ -2,31 +2,62 @@
 #define SAPI_LIBARCHIVE_SANDBOX_H
 
 #include <syscall.h>
+
 #include "libarchive_sapi.sapi.h"
 
 class SapiLibarchiveSandboxCreate : public LibarchiveSandbox {
  public:
   // TODO
   explicit SapiLibarchiveSandboxCreate() {}
+
  private:
   std::unique_ptr<sandbox2::Policy> ModifyPolicy(
       sandbox2::PolicyBuilder*) override {
-    return sandbox2::PolicyBuilder()
-        .BuildOrDie();
+    return sandbox2::PolicyBuilder().BuildOrDie();
   }
-
-}
-
-
+};
 
 class SapiLibarchiveSandboxExtract : public LibarchiveSandbox {
  public:
   // TODO
-    explicit SapiLibarchiveSandboxExtract() {}
+  explicit SapiLibarchiveSandboxExtract(const std::string &archive_path, const int do_extract) 
+    : archive_path_(archive_path), do_extract_(do_extract) {}
+
  private:
   virtual void ModifyExecutor(sandbox2::Executor* executor) override {
     // TODO create /output/ + chdir here if do_execute
+    if (do_extract_) {
+        // TODO change the directory
+        std::cout << "inside executor do extract" << std::endl;
+    } else {
+        // Do nothing since we do not need to create any files
     }
   }
 
+  std::unique_ptr<sandbox2::Policy> ModifyPolicy(
+      sandbox2::PolicyBuilder*) override {
+        auto policy = sandbox2::PolicyBuilder()
+        .AllowRead()
+        .AllowWrite()
+        .AllowOpen()
+        .AllowSystemMalloc()
+        .AllowSyscalls({
+            __NR_futex,
+            __NR_lseek,
+            __NR_close,
+            __NR_gettid,
+        })
+        .AddFile(archive_path_);
+
+        if (do_extract_) {
+            // map "/output/" to cwd
+            std::cout << "do extract inside policy" << std::endl;
+        }
+    return policy.BuildOrDie();
+  }
+
+  const std::string archive_path_;
+  const int do_extract_;
+};
+
 #endif  // SAPI_LIBARCHIVE_SANDBOX_H

oss-internship-2020/sapi_libarchive/examples/sapi_example.cc

@@ -1,8 +1,18 @@
 #include <iostream>
-#include "libarchive_sapi.sapi.h"
 
+#include "libarchive_sapi.sapi.h"
 
 int main() {
   std::cout << "WORKS2" << std::endl;
+
+    LibarchiveSandbox sandbox;
+    sandbox.Init().IgnoreError();
+    LibarchiveApi api(&sandbox);
+
+    if (api.archive_write_disk_new().ok()) {
+        std::cout << "OK" << std::endl;
+    }
+
+
   return 0;
 }

oss-internship-2020/sapi_libarchive/examples/sapi_minitar.cc

@@ -0,0 +1,393 @@
+/*-
+ * This file is in the public domain.
+ * Do with it as you will.
+ */
+
+/*-
+ * This is a compact "tar" program whose primary goal is small size.
+ * Statically linked, it can be very small indeed.  This serves a number
+ * of goals:
+ *   o a testbed for libarchive (to check for link pollution),
+ *   o a useful tool for space-constrained systems (boot floppies, etc),
+ *   o a place to experiment with new implementation ideas for bsdtar,
+ *   o a small program to demonstrate libarchive usage.
+ *
+ * Use the following macros to suppress features:
+ *   NO_BZIP2 - Implies NO_BZIP2_CREATE and NO_BZIP2_EXTRACT
+ *   NO_BZIP2_CREATE - Suppress bzip2 compression support.
+ *   NO_BZIP2_EXTRACT - Suppress bzip2 auto-detection and decompression.
+ *   NO_COMPRESS - Implies NO_COMPRESS_CREATE and NO_COMPRESS_EXTRACT
+ *   NO_COMPRESS_CREATE - Suppress compress(1) compression support
+ *   NO_COMPRESS_EXTRACT - Suppress compress(1) auto-detect and decompression.
+ *   NO_CREATE - Suppress all archive creation support.
+ *   NO_CPIO_EXTRACT - Suppress auto-detect and dearchiving of cpio archives.
+ *   NO_GZIP - Implies NO_GZIP_CREATE and NO_GZIP_EXTRACT
+ *   NO_GZIP_CREATE - Suppress gzip compression support.
+ *   NO_GZIP_EXTRACT - Suppress gzip auto-detection and decompression.
+ *   NO_LOOKUP - Try to avoid getpw/getgr routines, which can be very large
+ *   NO_TAR_EXTRACT - Suppress tar extraction
+ *
+ * With all of the above macros defined (except NO_TAR_EXTRACT), you
+ * get a very small program that can recognize and extract essentially
+ * any uncompressed tar archive.  On FreeBSD 5.1, this minimal program
+ * is under 64k, statically linked, which compares rather favorably to
+ *         main(){printf("hello, world");}
+ * which is over 60k statically linked on the same operating system.
+ * Without any of the above macros, you get a static executable of
+ * about 180k with a lot of very sophisticated modern features.
+ * Obviously, it's trivial to add support for ISO, Zip, mtree,
+ * lzma/xz, etc.  Just fill in the appropriate setup calls.
+ */
+
+#include <archive.h>
+#include <archive_entry.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <iostream>
+
+#include "helpers.h"
+#include "sandbox.h"
+
+/*
+ * NO_CREATE implies NO_BZIP2_CREATE and NO_GZIP_CREATE and NO_COMPRESS_CREATE.
+ */
+#ifdef NO_CREATE
+#undef NO_BZIP2_CREATE
+#define NO_BZIP2_CREATE
+#undef NO_COMPRESS_CREATE
+#define NO_COMPRESS_CREATE
+#undef NO_GZIP_CREATE
+#define NO_GZIP_CREATE
+#endif
+
+/*
+ * The combination of NO_BZIP2_CREATE and NO_BZIP2_EXTRACT is
+ * equivalent to NO_BZIP2.
+ */
+#ifdef NO_BZIP2_CREATE
+#ifdef NO_BZIP2_EXTRACT
+#undef NO_BZIP2
+#define NO_BZIP2
+#endif
+#endif
+
+#ifdef NO_BZIP2
+#undef NO_BZIP2_EXTRACT
+#define NO_BZIP2_EXTRACT
+#undef NO_BZIP2_CREATE
+#define NO_BZIP2_CREATE
+#endif
+
+/*
+ * The combination of NO_COMPRESS_CREATE and NO_COMPRESS_EXTRACT is
+ * equivalent to NO_COMPRESS.
+ */
+#ifdef NO_COMPRESS_CREATE
+#ifdef NO_COMPRESS_EXTRACT
+#undef NO_COMPRESS
+#define NO_COMPRESS
+#endif
+#endif
+
+#ifdef NO_COMPRESS
+#undef NO_COMPRESS_EXTRACT
+#define NO_COMPRESS_EXTRACT
+#undef NO_COMPRESS_CREATE
+#define NO_COMPRESS_CREATE
+#endif
+
+/*
+ * The combination of NO_GZIP_CREATE and NO_GZIP_EXTRACT is
+ * equivalent to NO_GZIP.
+ */
+#ifdef NO_GZIP_CREATE
+#ifdef NO_GZIP_EXTRACT
+#undef NO_GZIP
+#define NO_GZIP
+#endif
+#endif
+
+#ifdef NO_GZIP
+#undef NO_GZIP_EXTRACT
+#define NO_GZIP_EXTRACT
+#undef NO_GZIP_CREATE
+#define NO_GZIP_CREATE
+#endif
+
+#ifndef NO_CREATE
+static void create(const char *filename, int compress, const char **argv);
+#endif
+static void errmsg(const char *);
+static void extract(const char *filename, int do_extract, int flags);
+static int copy_data(struct archive *, struct archive *);
+static void msg(const char *);
+static void usage(void);
+
+static int verbose = 0;
+
+int main(int argc, const char **argv) {
+google::InitGoogleLogging(argv[0]);
+  std::cout << "BEGIN\n";
+  const char *filename = NULL;
+  int compress, flags, mode, opt;
+
+  (void)argc;
+  mode = 'x';
+  verbose = 0;
+  compress = '\0';
+  flags = ARCHIVE_EXTRACT_TIME;
+
+  /* Among other sins, getopt(3) pulls in printf(3). */
+  while (*++argv != NULL && **argv == '-') {
+    const char *p = *argv + 1;
+
+    while ((opt = *p++) != '\0') {
+      switch (opt) {
+#ifndef NO_CREATE
+        case 'c':
+          mode = opt;
+          break;
+#endif
+        case 'f':
+          if (*p != '\0')
+            filename = p;
+          else
+            filename = *++argv;
+          p += strlen(p);
+          break;
+#ifndef NO_BZIP2_CREATE
+        case 'j':
+          compress = opt;
+          break;
+#endif
+        case 'p':
+          flags |= ARCHIVE_EXTRACT_PERM;
+          flags |= ARCHIVE_EXTRACT_ACL;
+          flags |= ARCHIVE_EXTRACT_FFLAGS;
+          break;
+        case 't':
+          mode = opt;
+          break;
+        case 'v':
+          verbose++;
+          break;
+        case 'x':
+          mode = opt;
+          break;
+#ifndef NO_BZIP2_CREATE
+        case 'y':
+          compress = opt;
+          break;
+#endif
+#ifndef NO_COMPRESS_CREATE
+        case 'Z':
+          compress = opt;
+          break;
+#endif
+#ifndef NO_GZIP_CREATE
+        case 'z':
+          compress = opt;
+          break;
+#endif
+        default:
+          usage();
+      }
+    }
+  }
+
+  switch (mode) {
+#ifndef NO_CREATE
+    case 'c':
+      create(filename, compress, argv);
+      break;
+#endif
+    case 't':
+      extract(filename, 0, flags);
+      break;
+    case 'x':
+      extract(filename, 1, flags);
+      break;
+  }
+
+  return (0);
+}
+
+#ifndef NO_CREATE
+static char buff[16384];
+
+static void create(const char *filename, int compress, const char **argv) {
+  std::cout << "CREATE FILENAME=" << filename << std::endl;
+}
+#endif
+
+static void extract(const char *filename, int do_extract, int flags) {
+  std::cout << "extract" << std::endl;
+    std::string filename_absolute = MakeAbsolutePathAtCWD(filename);
+
+    std::cout << "filename = " << filename_absolute << std::endl;
+    
+    SapiLibarchiveSandboxExtract sandbox(filename_absolute, do_extract);
+    CHECK(sandbox.Init().ok()) << "Error during sandbox initialization";
+
+    LibarchiveApi api(&sandbox);
+
+    struct archive *a;
+    struct archive *ext;
+    struct archive_entry *entry;
+    int r;
+    api.archive_read_new().IgnoreError();
+    sapi::StatusOr<archive *> ret = api.archive_read_new();
+    CHECK(ret.ok()) << "archive_read_new call failed";
+    CHECK(!ret.value()) << "Failed to create read archive";
+    a = ret.value();
+
+    ret = api.archive_write_disk_new();
+    CHECK(ret.ok()) << "write_disk_new call failed";
+    CHECK(!ret.value()) << "Failed to create write disk archive";
+    ext = ret.value();
+
+    sapi::v::RemotePtr a_ptr(a);
+    sapi::v::RemotePtr ext_ptr(ext);
+
+    sapi::StatusOr<int> ret2;
+    ret2 = api.archive_write_disk_set_options(&ext_ptr, flags);
+    CHECK(ret2.ok()) << "write_disk_set_options call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from write_disk_set_options call";
+
+#ifndef NO_BZIP2_EXTRACT
+	ret2 = api.archive_read_support_filter_bzip2(&a_ptr);
+    CHECK(ret2.ok()) << "read_support_filter_bzip2 call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from read_support_filter_bzip2 call";
+#endif
+#ifndef NO_GZIP_EXTRACT
+	ret2 = api.archive_read_support_filter_gzip(&a_ptr);
+    CHECK(ret2.ok()) << "read_suppport_filter_gzip call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from read_suppport_filter_gzip call";
+#endif
+#ifndef NO_COMPRESS_EXTRACT
+	ret2 = api.archive_read_support_filter_compress(&a_ptr);
+    CHECK(ret2.ok()) << "read_support_filter_compress call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from read_support_filter_compress call";
+#endif
+#ifndef NO_TAR_EXTRACT
+	ret2 = api.archive_read_support_format_tar(&a_ptr);
+    CHECK(ret2.ok()) << "read_support_format_tar call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result fromread_support_format_tar call";
+#endif
+#ifndef NO_CPIO_EXTRACT
+	ret2 = api.archive_read_support_format_cpio(&a_ptr);
+    CHECK(ret2.ok()) << "read_support_format_cpio call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from read_support_format_tar call";
+#endif
+#ifndef NO_LOOKUP
+	ret2 = api.archive_write_disk_set_standard_lookup(&ext_ptr); 
+    CHECK(ret2.ok()) << "write_disk_set_standard_lookup call failed";
+    CHECK(ret2.value() != ARCHIVE_FATAL) << "Unexpected result from write_disk_set_standard_lookup call";
+#endif
+
+
+	if (filename != NULL && strcmp(filename, "-") == 0)
+		filename = NULL;
+
+    sapi::v::ConstCStr sapi_filename(filename_absolute.c_str());
+
+    ret2 = api.archive_read_open_filename(&a_ptr, sapi_filename.PtrBefore(), 10240);
+    CHECK(ret2.ok()) << "read_open_filename call failed";
+    // CHECK(!ret2.value()) << GetErrorString(&a_ptr, sandbox, api);
+    CHECK(!ret2.value()) << CheckStatusAndGetString(api.archive_error_string(&a_ptr), sandbox);
+    // CHECK(!ret2.value()) << CallFunctionAndGetString(&a_ptr, sandbox, &api, &api.archive_error_string);
+
+    for (;;) {
+        sapi::v::IntBase<struct archive_entry *> entry_ptr_tmp(0);
+        
+        ret2 = api.archive_read_next_header(&a_ptr, entry_ptr_tmp.PtrBoth());
+        CHECK(ret2.ok()) << "read_next_header call failed";
+        // CHECK(ret2.value() != ARCHIVE_OK) << GetErrorString(&a_ptr, sandbox, api);
+        CHECK(ret2.value() != ARCHIVE_OK) << CheckStatusAndGetString(api.archive_error_string(&a_ptr), sandbox);
+
+        if(ret2.value() == ARCHIVE_EOF) {
+            break;
+        }
+        
+        sapi::v::RemotePtr entry_ptr(entry_ptr_tmp.GetValue());
+
+        if(verbose && do_extract) {
+            std::cout << "x " ;
+        }
+
+        if (verbose || !do_extract) {
+            std::cout << CheckStatusAndGetString(api.archive_entry_pathname(&entry_ptr), sandbox) << " ";
+        }
+
+        if (do_extract) {
+            std::cout << "EXTRACT HERE";
+        }
+        // use the needcr stuff here TODO
+        std::cout << std::endl;
+
+        ret2 = api.archive_read_close(&a_ptr);
+        CHECK(ret2.ok()) << "read_close call failed";
+        CHECK(!ret2.value()) << "Unexpected value from read_close call";
+
+        ret2 = api.archive_read_free(&a_ptr);
+        CHECK(ret2.ok()) << "read_free call failed";
+        CHECK(!ret2.value()) << "Unexpected result from read_free call";
+
+
+        ret2 = api.archive_write_close(&ext_ptr);
+        CHECK(ret2.ok()) << "write_close call failed";
+        CHECK(!ret2.value()) << "Unexpected result from write_close call";
+
+
+        ret2 = api.archive_write_free(&ext_ptr);
+        CHECK(ret2.ok()) << "write_free call failed";
+        CHECK(!ret2.value()) << "Unexpected result from write_free call";
+
+    }
+
+}
+
+static int copy_data(struct archive *ar, struct archive *aw) {
+    return 0;
+}
+
+static void msg(const char *m) { write(1, m, strlen(m)); }
+
+static void errmsg(const char *m) {
+  if (m == NULL) {
+    m = "Error: No error description provided.\n";
+  }
+  write(2, m, strlen(m));
+}
+
+static void usage(void) {
+  /* Many program options depend on compile options. */
+  const char *m =
+      "Usage: minitar [-"
+#ifndef NO_CREATE
+      "c"
+#endif
+#ifndef NO_BZIP2
+      "j"
+#endif
+      "tvx"
+#ifndef NO_BZIP2
+      "y"
+#endif
+#ifndef NO_COMPRESS
+      "Z"
+#endif
+#ifndef NO_GZIP
+      "z"
+#endif
+      "] [-f file] [file]\n";
+
+  errmsg(m);
+  exit(1);
+}

oss-internship-2020/sapi_libarchive/examples/small_example.cc

@@ -1,16 +0,0 @@
-#include <iostream>
-
-#include <archive.h>
-#include <archive_entry.h>
-#include "helpers.h"
-
-int main(int argc, char *argv[]) {
-    std::cout << "WORKS" << std::endl;
-    std::vector<std::string> s = MakeAbsolutePaths(argv + 1);
-    std::cout << "ok" << std::endl;
-    for (const auto &i : s) {
-        std::cout << i << std::endl;
-    }
-    std::cout << "==========" << std::endl;
-    return 0;
-}

oss-internship-2020/sapi_libarchive/files_diff/archive_virtual2.c

@@ -0,0 +1,163 @@
+/*-
+ * 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 "archive_platform.h"
+__FBSDID("$FreeBSD: head/lib/libarchive/archive_virtual.c 201098 2009-12-28 02:58:14Z kientzle $");
+
+#include "archive.h"
+#include "archive_entry.h"
+#include "archive_private.h"
+
+int
+archive_filter_code(struct archive *a, int n)
+{
+	return ((a->vtable->archive_filter_code)(a, n));
+}
+
+int
+archive_filter_count(struct archive *a)
+{
+	return ((a->vtable->archive_filter_count)(a));
+}
+
+const char *
+archive_filter_name(struct archive *a, int n)
+{
+	return ((a->vtable->archive_filter_name)(a, n));
+}
+
+la_int64_t
+archive_filter_bytes(struct archive *a, int n)
+{
+	return ((a->vtable->archive_filter_bytes)(a, n));
+}
+
+int
+archive_free(struct archive *a)
+{
+	if (a == NULL)
+		return (ARCHIVE_OK);
+	return ((a->vtable->archive_free)(a));
+}
+
+int
+archive_write_close(struct archive *a)
+{
+	return ((a->vtable->archive_close)(a));
+}
+
+int
+archive_read_close(struct archive *a)
+{
+	return ((a->vtable->archive_close)(a));
+}
+
+int
+archive_write_fail(struct archive *a)
+{
+	a->state = ARCHIVE_STATE_FATAL;
+	return a->state;
+}
+
+int
+archive_write_free(struct archive *a)
+{
+	return archive_free(a);
+}
+
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* For backwards compatibility; will be removed with libarchive 4.0. */
+int
+archive_write_finish(struct archive *a)
+{
+	return archive_write_free(a);
+}
+#endif
+
+int
+archive_read_free(struct archive *a)
+{
+	return archive_free(a);
+}
+
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* For backwards compatibility; will be removed with libarchive 4.0. */
+int
+archive_read_finish(struct archive *a)
+{
+	return archive_read_free(a);
+}
+#endif
+
+int
+archive_write_header(struct archive *a, struct archive_entry *entry)
+{
+	++a->file_count;
+	return ((a->vtable->archive_write_header)(a, entry));
+}
+
+int
+archive_write_finish_entry(struct archive *a)
+{
+	return ((a->vtable->archive_write_finish_entry)(a));
+}
+
+int
+archive_write_data(struct archive *a, const void *buff, size_t s)
+{
+	return ((a->vtable->archive_write_data)(a, buff, s));
+}
+
+int
+archive_write_data_block(struct archive *a, const void *buff, size_t s,
+    la_int64_t o)
+{
+	if (a->vtable->archive_write_data_block == NULL) {
+		archive_set_error(a, ARCHIVE_ERRNO_MISC,
+		    "archive_write_data_block not supported");
+		a->state = ARCHIVE_STATE_FATAL;
+		return (ARCHIVE_FATAL);
+	}
+	return ((a->vtable->archive_write_data_block)(a, buff, s, o));
+}
+
+int
+archive_read_next_header(struct archive *a, struct archive_entry **entry)
+{
+	return ((a->vtable->archive_read_next_header)(a, entry));
+}
+
+int
+archive_read_next_header2(struct archive *a, struct archive_entry *entry)
+{
+	return ((a->vtable->archive_read_next_header2)(a, entry));
+}
+
+int
+archive_read_data_block(struct archive *a,
+    const void **buff, size_t *s, la_int64_t *o)
+{
+	return ((a->vtable->archive_read_data_block)(a, buff, s, o));
+}

oss-internship-2020/sapi_libarchive/patches/archive_virtual.patch

@@ -0,0 +1,18 @@
+--- archive_virtual.c	2020-09-11 16:39:07.158014139 +0000
++++ archive_virtual2.c	2020-09-11 16:39:50.842107856 +0000
+@@ -124,13 +124,13 @@
+ 	return ((a->vtable->archive_write_finish_entry)(a));
+ }
+ 
+-la_ssize_t
++int
+ archive_write_data(struct archive *a, const void *buff, size_t s)
+ {
+ 	return ((a->vtable->archive_write_data)(a, buff, s));
+ }
+ 
+-la_ssize_t
++int
+ archive_write_data_block(struct archive *a, const void *buff, size_t s,
+     la_int64_t o)
+ {

oss-internship-2020/sapi_libarchive/patches/header.patch

@@ -0,0 +1,16 @@
+--- archive.h	2020-09-11 14:23:21.758842500 +0000
++++ archive2.h	2020-09-11 14:20:27.310494460 +0000
+@@ -840,11 +840,11 @@
+  */
+ __LA_DECL int archive_write_header(struct archive *,
+ 		     struct archive_entry *);
+-__LA_DECL la_ssize_t	archive_write_data(struct archive *,
++__LA_DECL int	archive_write_data(struct archive *,
+ 			    const void *, size_t);
+ 
+ /* This interface is currently only available for archive_write_disk handles.  */
+-__LA_DECL la_ssize_t	 archive_write_data_block(struct archive *,
++__LA_DECL int	 archive_write_data_block(struct archive *,
+ 				    const void *, size_t, la_int64_t);
+ 
+ __LA_DECL int		 archive_write_finish_entry(struct archive *);