1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

#include <archive.h>
#include <archive_entry.h>
#include <kj/async.h>

#include "async-io.hh"
#include "file-descriptor.hh"
#include "lix/libutil/c-calls.hh"
#include "lix/libutil/charptr-cast.hh"
#include "lix/libutil/file-system.hh"
#include "lix/libutil/logging.hh"
#include "lix/libutil/serialise.hh"
#include "result.hh"
#include "lix/libutil/tarfile.hh"

namespace nix {

static int callback_open(struct archive *, void * self)
{
    return ARCHIVE_OK;
}

static ssize_t callback_read(struct archive * archive, void * _self, const void ** buffer)
{
    auto self = static_cast<TarArchive *>(_self);
    *buffer = self->buffer.data();

    try {
        return self->source->read(charptr_cast<char *>(self->buffer.data()), self->buffer.size());
    } catch (EndOfFile &) {
        return 0;
    } catch (std::exception & err) { // NOLINT(lix-foreign-exceptions)
        // NOLINTNEXTLINE(lix-unsafe-c-calls): what() is a c string
        archive_set_error(archive, EIO, "Source threw exception: %s", err.what());
        return -1;
    }
}

static int callback_close(struct archive *, void * self)
{
    return ARCHIVE_OK;
}

void TarArchive::check(int err, const std::string & reason)
{
    if (err == ARCHIVE_EOF) {
        throw EndOfFile("reached end of archive");
    } else if (err != ARCHIVE_OK) {
        throw ArchiveError(reason, archive_error_string(this->archive.get()));
    }
}

TarArchive::TarArchive(Source & source, bool raw)
    : archive{archive_read_new()}
    , source(&source)
    , buffer(65536)
{
    if (!raw) {
        archive_read_support_filter_all(archive.get());
        archive_read_support_format_all(archive.get());
    } else {
        archive_read_support_filter_all(archive.get());
        archive_read_support_format_raw(archive.get());
        archive_read_support_format_empty(archive.get());
    }
    archive_read_set_option(archive.get(), nullptr, "mac-ext", nullptr);
    check(
        archive_read_open(
            archive.get(), (void *) this, callback_open, callback_read, callback_close
        ),
        "Failed to open archive (%s)"
    );
}

TarArchive::TarArchive(const Path & path) : archive{archive_read_new()}
{
    archive_read_support_filter_all(archive.get());
    archive_read_support_format_all(archive.get());
    archive_read_set_option(archive.get(), nullptr, "mac-ext", nullptr);
    check(
        archive_read_open_filename(archive.get(), requireCString(path), 16384),
        "failed to open archive: %s"
    );
}

void TarArchive::close()
{
    check(archive_read_close(this->archive.get()), "Failed to close archive (%s)");
}

static void extract_archive(TarArchive & archive, const Path & destDir)
{
    requireCString(destDir);

    int flags =
        ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_SECURE_SYMLINKS | ARCHIVE_EXTRACT_SECURE_NODOTDOT;

    for (;;) {
        struct archive_entry * entry;
        int r = archive_read_next_header(archive.archive.get(), &entry);
        if (r == ARCHIVE_EOF) {
            break;
        }
        auto name = archive_entry_pathname(entry);
        if (!name) {
            throw Error(
                "cannot get archive member name: %s", archive_error_string(archive.archive.get())
            );
        }
        if (r == ARCHIVE_WARN) {
            printTaggedWarning("%1%", Uncolored(archive_error_string(archive.archive.get())));
        } else {
            archive.check(r);
        }

        // NOLINTNEXTLINE(lix-unsafe-c-calls): destDir is checked, name is a c string
        archive_entry_copy_pathname(entry, (destDir + "/" + name).c_str());

        // sources can and do contain dirs with no rx bits
        if (archive_entry_filetype(entry) == AE_IFDIR && (archive_entry_mode(entry) & 0500) != 0500)
        {
            archive_entry_set_mode(entry, archive_entry_mode(entry) | 0500);
        }

        // Patch hardlink path
        const char * original_hardlink = archive_entry_hardlink(entry);
        if (original_hardlink) {
            // NOLINTNEXTLINE(lix-unsafe-c-calls): destDir is checked, name is a c string
            archive_entry_copy_hardlink(entry, (destDir + "/" + original_hardlink).c_str());
        }

        archive.check(archive_read_extract(archive.archive.get(), entry, flags));
    }

    archive.close();
}

kj::Promise<Result<void>> unpackTarfile(AsyncInputStream & source, const Path & destDir)
try {
    Pipe pipe;
    pipe.create();

    auto thr = std::async(
        std::launch::async,
        [&](AutoCloseFD fd) {
            FdSource source(fd.get());
            auto archive = TarArchive(source);

            createDirs(destDir);
            extract_archive(archive, destDir);
        },
        std::move(pipe.readSide)
    );

    AsyncFdIoStream sink{std::move(pipe.writeSide)};
    TRY_AWAIT(source.drainInto(sink));
    thr.get();
    co_return result::success();
} catch (...) {
    co_return result::current_exception();
}

void unpackTarfile(const Path & tarFile, const Path & destDir)
{
    auto archive = TarArchive(tarFile);

    createDirs(destDir);
    extract_archive(archive, destDir);
}

}