#include <algorithm>

#include <chrono>

#include <deque>

#include <fnmatch.h>

#include <fstream>

#include <iostream>

#include <libgen.h>

#include <mutex>

#include <sstream>

#include <thread>

#include <unistd.h>

#include <zsclient.h>

#include <cpr/cpr.h>

#include "appimage/update.h"

#include "util.h"

typedef std::lock_guard<std::mutex> lock_guard;

namespace appimage {

namespace update {

class Updater::Private {

public:

Private() : state(INITIALIZED),

{};

~Private() {

delete zSyncClient;

}

public:

// data

std::string pathToAppImage;

// state

State state;

// ZSync client -- will be instantiated only if necessary

zsync2::ZSyncClient* zSyncClient;

// threading

std::thread* thread;

std::mutex mutex;

// status messages

std::deque<std::string> statusMessages;

// defines whether to overwrite original file

bool overwrite;

public:

enum UpdateInformationType {

};

struct AppImage {

};

typedef struct AppImage AppImage;

public:

void issueStatusMessage(const std::string& message) {

statusMessages.push_back(message);

}

const AppImage* readAppImage(const std::string& pathToAppImage) {

// error state: empty AppImage path

if (pathToAppImage.empty()) {

issueStatusMessage("Path to AppImage must not be empty.");

return nullptr;

}

// check whether file exists

std::ifstream ifs(pathToAppImage);

// if file can't be opened, it's an error

if (!ifs || !ifs.good()) {

issueStatusMessage("Failed to access AppImage file: " + pathToAppImage);

return nullptr;

}

// read magic number

ifs.seekg(8, std::ios::beg);

std::vector<char> magicByte(4, '\0');

ifs.read(magicByte.data(), 3);

// validate first two bytes are A and I

if (magicByte[0] != 'A' && magicByte[1] != 'I') {

std::ostringstream oss;

oss << "Invalid magic bytes: " << (int) magicByte[0] << (int) magicByte[1];

issueStatusMessage(oss.str());

}

int appImageType = -1;

// the third byte contains the version

switch (magicByte[2]) {

case '\x01':

appImageType = 1;

break;

case '\x02':

appImageType = 2;

break;

default:

// see fallback in the final else block in the next if construct

break;

}

// read update information in the file

std::string updateInformation;

if (appImageType == 1) {

// update information is always at the same position, and has a fixed length

static constexpr auto position = 0x8373;

static constexpr auto length = 512;

ifs.seekg(position);

std::vector<char> rawUpdateInformation(length, 0);

ifs.read(rawUpdateInformation.data(), length);

updateInformation = rawUpdateInformation.data();

} else if (appImageType == 2) {

// try to read ELF section .upd_info

updateInformation = readElfSection(pathToAppImage, ".upd_info");

} else {

// final try: type 1 AppImages do not have to set the magic bytes, although they should

// if the file is both an ELF and an ISO9660 file, we'll suspect it to be a type 1 AppImage, and

// proceed with a warning

static constexpr int elfMagicPos = 1;

static const std::string elfMagicValue = "ELF";

static constexpr int isoMagicPos = 32769;

static const std::string isoMagicValue = "CD001";

ifs.seekg(elfMagicPos);

std::vector<char> elfMagicPosData(elfMagicValue.size() + 1, '\0');

ifs.read(elfMagicPosData.data(), elfMagicValue.size());

auto elfMagicAvailable = (elfMagicPosData.data() == elfMagicValue);

ifs.seekg(isoMagicPos);

std::vector<char> isoMagicPosData(isoMagicValue.size() + 1, '\0');

ifs.read(isoMagicPosData.data(), isoMagicValue.size());

auto isoMagicAvailable = (isoMagicPosData.data() == isoMagicValue);

if (elfMagicAvailable && isoMagicAvailable) {

issueStatusMessage("Guessing AppImage type 1");

appImageType = 1;

} else {

// all possible methods attempted, ultimately fail here

issueStatusMessage("No such AppImage type: " + std::to_string(magicByte[2]));

return nullptr;

}

}

UpdateInformationType uiType = INVALID;

std::string zsyncUrl;

// parse update information

auto uiParts = split(updateInformation, '|');

// make sure uiParts isn't empty

if (!uiParts.empty()) {

// TODO: GitHub releases type should consider pre-releases when there's no other types of releases

if (uiParts[0] == "gh-releases-zsync") {

// validate update information

if (uiParts.size() != 5) {

std::ostringstream oss;

oss << "Update information has invalid parameter count. Please contact the author of "

<< "the AppImage and ask them to revise the update information. They should consult "

<< "the AppImage specification, there might have been changes to the update"

<< "information.";

issueStatusMessage(oss.str());

} else {

uiType = ZSYNC_GITHUB_RELEASES;

auto username = uiParts[1];

auto repository = uiParts[2];

auto tag = uiParts[3];

auto filename = uiParts[4];

std::stringstream url;

url << "https://api.github.com/repos/" << username << "/" << repository << "/releases/";

if (tag.find("latest") != std::string::npos) {

issueStatusMessage("Fetching latest release information from GitHub API");

url << "latest";

} else {

std::ostringstream oss;

oss << "Fetching release information for tag \"" << tag << "\" from GitHub API.";

issueStatusMessage(oss.str());

url << "tags/" << tag;

}

auto response = cpr::Get(url.str());

// counter that will be evaluated later to give some meaningful feedback why parsing API

// response might have failed

int downloadUrlLines = 0;

int matchingUrls = 0;

// continue only if HTTP status is good

if (response.status_code >= 200 && response.status_code < 300) {

// in contrary to the original implementation, instead of converting wildcards into

// all-matching regular expressions, we have the power of fnmatch() available, a real wildcard

// implementation

// unfortunately, this is still hoping for GitHub's JSON API to return a pretty printed

// response which can be parsed like this

std::stringstream responseText(response.text);

std::string currentLine;

// not ideal, but allows for returning a match for the entire line

auto pattern = "*" + filename + "*";

// iterate through all lines to find a possible download URL and compare it to the pattern

while (std::getline(responseText, currentLine)) {

if (currentLine.find("browser_download_url") != std::string::npos) {

downloadUrlLines++;

if (fnmatch(pattern.c_str(), currentLine.c_str(), 0) == 0) {

matchingUrls++;

auto parts = split(currentLine, '"');

zsyncUrl = parts.back();

break;

}

}

}

} else {

issueStatusMessage("GitHub API request failed!");

}

if (downloadUrlLines <= 0) {

std::ostringstream oss;

oss << "Could not find any artifacts in release data. "

<< "Please contact the author of the AppImage and tell them the files are missing "

<< "on the releases page.";

issueStatusMessage(oss.str());

} else if (matchingUrls <= 0) {

std::ostringstream oss;

oss << "None of the artifacts matched the pattern in the update information. "

<< "The pattern is most likely invalid, e.g., due to changes in the filenames of "

<< "the AppImages. Please contact the author of the AppImage and ask them to "

<< "revise the update information.";

issueStatusMessage(oss.str());

} else if (zsyncUrl.empty()) {

// unlike that this code will ever be reached, the other two messages should cover all

// cases in which a ZSync URL is missing

// if it does, however, it's most likely that GitHub's API didn't return a URL

issueStatusMessage("Failed to parse GitHub's response.");

}

}

} else if (uiParts[0] == "bintray-zsync") {

// TODO: better error handling

if (uiParts.size() == 5) {

uiType = ZSYNC_BINTRAY;

auto username = uiParts[1];

auto repository = uiParts[2];

auto packageName = uiParts[3];

auto filename = uiParts[4];

std::stringstream downloadUrl;

downloadUrl << "https://dl.bintray.com/" << username << "/" << repository << "/"

<< filename;

if (downloadUrl.str().find("_latestVersion") == std::string::npos) {

zsyncUrl = downloadUrl.str();

} else {

std::stringstream redirectorUrl;

redirectorUrl << "https://bintray.com/" << username << "/" << repository << "/"

<< packageName << "/_latestVersion";

auto versionResponse = cpr::Head(redirectorUrl.str());

// this request is supposed to be redirected

// due to how cpr works, we can't check for a redirection status, as we get the response for

// the redirected request

// therefore, we check for a 2xx response, and then can inspect and compare the redirected URL

if (versionResponse.status_code >= 200 && versionResponse.status_code < 400) {

auto redirectedUrl = versionResponse.url;

// if they're different, it's probably been successful

if (redirectorUrl.str() != redirectedUrl) {

// the last part will contain the current version

auto packageVersion = static_cast<std::string>(split(redirectedUrl, '/').back());

auto urlTemplate = downloadUrl.str();

// split by _latestVersion, insert correct value, compose final value

auto pos = urlTemplate.find("_latestVersion");

auto firstPart = urlTemplate.substr(0, pos);

auto secondPart = urlTemplate.substr(pos + std::string("_latestVersion").length());

zsyncUrl = firstPart + packageVersion + secondPart;

}

}

}

}

} else if (uiParts[0] == "zsync") {

// validate update information

if (uiParts.size() == 2) {

uiType = ZSYNC_GENERIC;

zsyncUrl = uiParts.back();

} else {

std::ostringstream oss;

oss << "Update information has invalid parameter count. Please contact the author of "

<< "the AppImage and ask them to revise the update information. They should consult "

<< "the AppImage specification, there might have been changes to the update"

<< "information.";

issueStatusMessage(oss.str());

}

} else {

// unknown type

}

}

auto* appImage = new AppImage();

appImage->filename = pathToAppImage;

appImage->appImageVersion = appImageType;

appImage->rawUpdateInformation = updateInformation;

appImage->updateInformationType = uiType;

appImage->zsyncUrl = zsyncUrl;

return appImage;

}

bool validateAppImage(AppImage const* appImage) {

}

// thread runner

void runUpdate() {

}

bool checkForChanges(bool& updateAvailable, const unsigned int method = 0) {

}

};

Updater::Updater(const std::string& pathToAppImage, bool overwrite) {

}

Updater::~Updater() {

delete d;

}

void Updater::runUpdate() {

// alias for private function

return d->runUpdate();

}

bool Updater::start() {

}

bool Updater::isDone() {

}

bool Updater::hasError() {

}

bool Updater::progress(double& progress) {

}

bool Updater::stop() {

throw std::runtime_error("not implemented");

}

bool Updater::nextStatusMessage(std::string& message) {

}

Updater::State Updater::state() {

return d->state;

}

bool Updater::checkForChanges(bool &updateAvailable, const unsigned int method) {

return d->checkForChanges(updateAvailable, method);

}

bool Updater::describeAppImage(std::string& description) const {

}

bool Updater::pathToNewFile(std::string& path) const {

}

bool Updater::remoteFileSize(off_t& fileSize) const {

}

}

}