Replace libzlib with libarchive for decompression

Author: timschneeb

src/src.pro

@@ -152,13 +152,13 @@ else: unix:!android: target.path = /usr/bin/
 !isEmpty(target.path): INSTALLS += target
 
 unix {
-    LIBS += -ldl -lz
-    QMAKE_LFLAGS += -ldl -lutil -lz #-fsanitize=address
+    LIBS += -ldl
+    QMAKE_LFLAGS += -ldl -lutil #-fsanitize=address
     QMAKE_CXXFLAGS += -g #-fno-omit-frame-pointer -fsanitize=address
 
     CONFIG += link_pkgconfig
 
-    PKGCONFIG += glibmm-2.4 giomm-2.4
+    PKGCONFIG += glibmm-2.4 giomm-2.4 libarchive
 
     USE_PULSEAUDIO {
         PKGCONFIG += gstreamer-1.0 gstreamer-audio-1.0

src/subprojects/AutoEqIntegration/AutoEqIntegration.pri

@@ -16,7 +16,7 @@ HEADERS += \
     $$PWD/GzipDownloader.h \
     $$PWD/GzipDownloaderDialog.h \
     $$PWD/HttpException.h \
-    $$PWD/untar.h
+    $$PWD/Untar.h
 
 SOURCES += \
     $$PWD/AeqMeasurementItem.cpp \

src/subprojects/AutoEqIntegration/GzipDownloader.cpp

@@ -1,5 +1,7 @@
 #include "GzipDownloader.h"
 
+#include "Untar.h"
+
 bool GzipDownloader::start(QNetworkReply *reply, QDir _extractionPath)
 {
     if(networkReply)
@@ -66,30 +68,17 @@ void GzipDownloader::onArchiveReady()
         {
             QDir(extractionPath).mkpath(extractionPath.path());
 
-            auto file = gzopen(downloadedFile.fileName().toStdString().c_str(), "rb");
-            auto temp = std::tmpfile();
-
-            inflate(file, temp);
-            gzclose(file);
-            std::rewind(temp);
-
-            emit unarchiveStarted();
-
-            bool bad_checksum;
-            bool short_read;
-
-            untar(temp, extractionPath.path().toStdString().c_str(), &bad_checksum, &short_read);
-            std::fclose(temp);
+            QString errorMsg;
+            int ret = Untar::extract(downloadedFile.fileName(), extractionPath.path(), errorMsg);
+            downloadedFile.remove();
 
-            if(bad_checksum)
+            if(ret > 0)
             {
-                return "Bad checksum, corrupted package. Please try again.";
+                return errorMsg;
             }
-            if(short_read)
-            {
-                return "Short read; expected 512 bytes but received less. Please try again.";
-            }
-            return "";
+
+            return QString("");
+
         })).then([this](const QString& msg)
         {
             if(msg.isEmpty())

src/subprojects/AutoEqIntegration/GzipDownloader.h

@@ -6,8 +6,6 @@
 #include <QtConcurrent/QtConcurrent>
 
 #include <QtPromise>
-#include <untar.h>
-#include <zlib.h>
 
 #define TMP_DIR "/tmp/jamesdsp/download/"
 #define CHUNK 16384
@@ -33,7 +31,6 @@ class GzipDownloader : public QObject
 signals:
     void downloadProgressUpdated(qint64 bytesReceived, qint64 bytesTotal);
     void decompressionStarted();
-    void unarchiveStarted();
     void success();
     void errorOccurred(QString errorString);
 
@@ -45,7 +42,7 @@ private slots:
     void cleanup();
 
     /* Decompress from file source to file dest until stream ends or EOF. */
-    inline void inflate(gzFile_s  *source, FILE *dest)
+    /*inline void inflate(gzFile_s  *source, FILE *dest)
     {
         unsigned char buf[CHUNK];
 
@@ -54,7 +51,7 @@ private slots:
              size > 0;
              size = gzread(source, buf, CHUNK)
              ) std::fwrite(buf, 1, CHUNK, dest);
-    }
+    }*/
 
 private:
     QDir extractionPath;

src/subprojects/AutoEqIntegration/GzipDownloaderDialog.cpp

@@ -18,7 +18,6 @@ GzipDownloaderDialog::GzipDownloaderDialog(QNetworkReply* _reply, QDir _targetDi
     connect(gzip, &GzipDownloader::errorOccurred, this, &GzipDownloaderDialog::onError);
     connect(gzip, &GzipDownloader::downloadProgressUpdated, this, &GzipDownloaderDialog::onDownloadProgressUpdated);
     connect(gzip, &GzipDownloader::decompressionStarted, this, &GzipDownloaderDialog::onDecompressionStarted);
-    connect(gzip, &GzipDownloader::unarchiveStarted, this, &GzipDownloaderDialog::onUnarchiveStarted);
 
     reply = _reply;
     targetDirectory = _targetDirectory;
@@ -47,7 +46,6 @@ void GzipDownloaderDialog::closeEvent(QCloseEvent *ev)
     disconnect(gzip, &GzipDownloader::errorOccurred, this, &GzipDownloaderDialog::onError);
     disconnect(gzip, &GzipDownloader::downloadProgressUpdated, this, &GzipDownloaderDialog::onDownloadProgressUpdated);
     disconnect(gzip, &GzipDownloader::decompressionStarted, this, &GzipDownloaderDialog::onDecompressionStarted);
-    disconnect(gzip, &GzipDownloader::unarchiveStarted, this, &GzipDownloaderDialog::onUnarchiveStarted);
     gzip->deleteLater();
 
     QDialog::closeEvent(ev);
@@ -85,9 +83,3 @@ void GzipDownloaderDialog::onDecompressionStarted()
     ui->size->setText("");
     ui->buttonBox->setEnabled(false);
 }
-
-void GzipDownloaderDialog::onUnarchiveStarted()
-{
-    ui->title->setText("Extracting package...");
-    ui->size->setText("");
-}

src/subprojects/AutoEqIntegration/GzipDownloaderDialog.h

@@ -28,7 +28,6 @@ private slots:
     void onError(const QString &msg);
     void onDownloadProgressUpdated(qint64 recv, qint64 total);
     void onDecompressionStarted();
-    void onUnarchiveStarted();
 
 private:
     Ui::FileDownloaderDialog *ui;

src/subprojects/AutoEqIntegration/Untar.h

@@ -0,0 +1,119 @@
+#ifndef UNTAR_H
+#define UNTAR_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <QDebug>
+#include <QString>
+#include <QDir>
+
+#include <archive.h>
+#include <archive_entry.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+class Untar
+{
+public:
+    static int extract(const QString& qFilename, const QDir& outputPath, QString& returnState)
+    {
+        const char* filename = qFilename.toUtf8().constData();
+
+        struct archive *a;
+        struct archive *ext;
+        struct archive_entry *entry;
+        int flags;
+        int r;
+
+        /* Select which attributes we want to restore. */
+        flags = ARCHIVE_EXTRACT_TIME;
+
+        a = archive_read_new();
+        archive_read_support_format_all(a);
+        archive_read_support_filter_all(a);
+        ext = archive_write_disk_new();
+        archive_write_disk_set_options(ext, flags);
+        archive_write_disk_set_standard_lookup(ext);
+        if ((r = archive_read_open_filename(a, filename, 10240)))
+        {
+            returnState = archive_error_string(a);
+            qWarning() << returnState << "\n";
+            return (1);
+        }
+        for (;;) {
+            r = archive_read_next_header(a, &entry);
+            if (r == ARCHIVE_EOF)
+                break;
+            if (r < ARCHIVE_OK)
+                qWarning() << archive_error_string(a);
+            if (r < ARCHIVE_WARN)
+            {
+                returnState = archive_error_string(a);
+                return 1;
+            }
+
+            const char* currentFile = archive_entry_pathname(entry);
+            const QString fullOutputPath = outputPath.path() + QDir::separator() + currentFile;
+            archive_entry_set_pathname_utf8(entry, fullOutputPath.toUtf8().constData());
+
+            r = archive_write_header(ext, entry);
+            if (r < ARCHIVE_OK)
+                qWarning() << archive_error_string(ext);
+            else if (archive_entry_size(entry) > 0) {
+                r = copy_data(a, ext);
+                if (r < ARCHIVE_OK)
+                    qWarning() << archive_error_string(ext);
+                if (r < ARCHIVE_WARN)
+                {
+                    returnState = archive_error_string(ext);
+                    return 1;
+                }
+            }
+            r = archive_write_finish_entry(ext);
+            if (r < ARCHIVE_OK)
+                qWarning() << archive_error_string(ext);
+            if (r < ARCHIVE_WARN)
+            {
+                returnState = archive_error_string(ext);
+                return 1;
+            }
+        }
+        archive_read_close(a);
+        archive_read_free(a);
+        archive_write_close(ext);
+        archive_write_free(ext);
+        return 0;
+    }
+
+private:
+    static int
+    copy_data(struct archive *ar, struct archive *aw)
+    {
+        int r;
+        const void *buff;
+        size_t size;
+        int64_t offset;
+
+        for (;;) {
+            r = archive_read_data_block(ar, &buff, &size, &offset);
+            if (r == ARCHIVE_EOF)
+                return (ARCHIVE_OK);
+            if (r < ARCHIVE_OK) {
+                qWarning() << "copyData(): " << archive_error_string(ar) << "\n";
+                return (r);
+            }
+            r = archive_write_data_block(aw, buff, size, offset);
+            if (r < ARCHIVE_OK) {
+                qWarning() << "copyData(): " << archive_error_string(ar) << "\n";
+                return (r);
+            }
+        }
+    }
+
+};
+
+#endif // UNTAR_H