Rename Core to Base (Closes #3733).

src/base/utils/fs.cpp

@@ -0,0 +1,531 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2012  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QSettings>
+#include <QDirIterator>
+#include <QCoreApplication>
+
+#ifdef Q_OS_MAC
+#include <CoreServices/CoreServices.h>
+#include <Carbon/Carbon.h>
+#endif
+
+#ifndef Q_OS_WIN
+#if defined(Q_OS_MAC) || defined(Q_OS_FREEBSD)
+#include <sys/param.h>
+#include <sys/mount.h>
+#elif defined(Q_OS_HAIKU)
+#include <kernel/fs_info.h>
+#else
+#include <sys/vfs.h>
+#endif
+#else
+#include <shlobj.h>
+#include <winbase.h>
+#endif
+
+#ifndef QBT_USES_QT5
+
+#ifndef DISABLE_GUI
+#include <QDesktopServices>
+#endif
+
+#else
+#include <QStandardPaths>
+#endif
+
+
+#include "misc.h"
+#include "fs.h"
+
+/**
+ * Converts a path to a string suitable for display.
+ * This function makes sure the directory separator used is consistent
+ * with the OS being run.
+ */
+QString Utils::Fs::toNativePath(const QString& path)
+{
+    return QDir::toNativeSeparators(path);
+}
+
+QString Utils::Fs::fromNativePath(const QString &path)
+{
+    return QDir::fromNativeSeparators(path);
+}
+
+/**
+ * Returns the file extension part of a file name.
+ */
+QString Utils::Fs::fileExtension(const QString &filename)
+{
+    QString ext = QString(filename).remove(".!qB");
+    const int point_index = ext.lastIndexOf(".");
+    return (point_index >= 0) ? ext.mid(point_index + 1) : QString();
+}
+
+QString Utils::Fs::fileName(const QString& file_path)
+{
+    QString path = fromNativePath(file_path);
+    const int slash_index = path.lastIndexOf("/");
+    if (slash_index == -1)
+        return path;
+    return path.mid(slash_index + 1);
+}
+
+QString Utils::Fs::folderName(const QString& file_path)
+{
+    QString path = fromNativePath(file_path);
+    const int slash_index = path.lastIndexOf("/");
+    if (slash_index == -1)
+        return path;
+    return path.left(slash_index);
+}
+
+/**
+ * This function will first remove system cache files, e.g. `Thumbs.db`,
+ * `.DS_Store`. Then will try to remove the whole tree if the tree consist
+ * only of folders
+ */
+bool Utils::Fs::smartRemoveEmptyFolderTree(const QString& path)
+{
+    if (!QDir(path).exists())
+        return false;
+
+    static const QStringList deleteFilesList = {
+        // Windows
+        "Thumbs.db",
+        "desktop.ini",
+        // Linux
+        ".directory",
+        // Mac OS
+        ".DS_Store"
+    };
+
+    // travel from the deepest folder and remove anything unwanted on the way out.
+    QStringList dirList(path + "/");  // get all sub directories paths
+    QDirIterator iter(path, (QDir::AllDirs | QDir::NoDotAndDotDot), QDirIterator::Subdirectories);
+    while (iter.hasNext())
+        dirList << iter.next() + "/";
+    std::sort(dirList.begin(), dirList.end(), [](const QString &l, const QString &r) { return l.count("/") > r.count("/"); });  // sort descending by directory depth
+
+    for (const QString &p : dirList) {
+        // remove unwanted files
+        for (const QString &f : deleteFilesList) {
+            forceRemove(p + f);
+        }
+
+        // remove temp files on linux (file ends with '~'), e.g. `filename~`
+        QDir dir(p);
+        QStringList tmpFileList = dir.entryList(QDir::Files);
+        for (const QString &f : tmpFileList) {
+            if (f.endsWith("~"))
+                forceRemove(p + f);
+        }
+
+        // remove directory if empty
+        dir.rmdir(p);
+    }
+
+    return QDir(path).exists();
+}
+
+/**
+ * Removes the file with the given file_path.
+ *
+ * This function will try to fix the file permissions before removing it.
+ */
+bool Utils::Fs::forceRemove(const QString& file_path)
+{
+    QFile f(file_path);
+    if (!f.exists())
+        return true;
+    // Make sure we have read/write permissions
+    f.setPermissions(f.permissions() | QFile::ReadOwner | QFile::WriteOwner | QFile::ReadUser | QFile::WriteUser);
+    // Remove the file
+    return f.remove();
+}
+
+/**
+ * Removes directory and its content recursively.
+ *
+ */
+void Utils::Fs::removeDirRecursive(const QString& dirName)
+{
+#ifdef QBT_USES_QT5
+    QDir(dirName).removeRecursively();
+#else
+    QDir dir(dirName);
+
+    if (!dir.exists()) return;
+
+    Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot |
+                                                QDir::System |
+                                                QDir::Hidden |
+                                                QDir::AllDirs |
+                                                QDir::Files, QDir::DirsFirst)) {
+        if (info.isDir()) removeDirRecursive(info.absoluteFilePath());
+        else forceRemove(info.absoluteFilePath());
+    }
+
+    dir.rmdir(dirName);
+#endif
+}
+
+/**
+ * Returns the size of a file.
+ * If the file is a folder, it will compute its size based on its content.
+ *
+ * Returns -1 in case of error.
+ */
+qint64 Utils::Fs::computePathSize(const QString& path)
+{
+    // Check if it is a file
+    QFileInfo fi(path);
+    if (!fi.exists()) return -1;
+    if (fi.isFile()) return fi.size();
+    // Compute folder size based on its content
+    qint64 size = 0;
+    foreach (const QFileInfo &subfi, QDir(path).entryInfoList(QDir::Dirs|QDir::Files)) {
+        if (subfi.fileName().startsWith(".")) continue;
+        if (subfi.isDir())
+            size += computePathSize(subfi.absoluteFilePath());
+        else
+            size += subfi.size();
+    }
+    return size;
+}
+
+/**
+ * Makes deep comparison of two files to make sure they are identical.
+ */
+bool Utils::Fs::sameFiles(const QString& path1, const QString& path2)
+{
+    QFile f1(path1), f2(path2);
+    if (!f1.exists() || !f2.exists()) return false;
+    if (f1.size() != f2.size()) return false;
+    if (!f1.open(QIODevice::ReadOnly)) return false;
+    if (!f2.open(QIODevice::ReadOnly)) {
+        f1.close();
+        return false;
+    }
+    bool same = true;
+    while(!f1.atEnd() && !f2.atEnd()) {
+        if (f1.read(1024) != f2.read(1024)) {
+            same = false;
+            break;
+        }
+    }
+    f1.close(); f2.close();
+    return same;
+}
+
+QString Utils::Fs::toValidFileSystemName(const QString &filename)
+{
+    static const QRegExp regex("[\\\\/:?\"*<>|]");
+
+    QString validName = filename.trimmed();
+    validName.replace(regex, " ");
+    qDebug() << "toValidFileSystemName:" << filename << "=>" << validName;
+
+    return validName;
+}
+
+bool Utils::Fs::isValidFileSystemName(const QString& filename)
+{
+    if (filename.isEmpty()) return false;
+    const QRegExp regex("[\\\\/:?\"*<>|]");
+    return !filename.contains(regex);
+}
+
+qlonglong Utils::Fs::freeDiskSpaceOnPath(QString path)
+{
+    if (path.isEmpty()) return -1;
+    QDir dir_path(path);
+    if (!dir_path.exists()) {
+        QStringList parts = path.split("/");
+        while (parts.size() > 1 && !QDir(parts.join("/")).exists()) {
+            parts.removeLast();
+        }
+        dir_path = QDir(parts.join("/"));
+        if (!dir_path.exists()) return -1;
+    }
+    Q_ASSERT(dir_path.exists());
+
+#ifndef Q_OS_WIN
+    unsigned long long available;
+#ifdef Q_OS_HAIKU
+    const QString statfs_path = dir_path.path() + "/.";
+    dev_t device = dev_for_path (qPrintable(statfs_path));
+    if (device >= 0) {
+        fs_info info;
+        if (fs_stat_dev(device, &info) == B_OK) {
+            available = ((unsigned long long)(info.free_blocks * info.block_size));
+            return available;
+        }
+    }
+    return -1;
+#else
+    struct statfs stats;
+    const QString statfs_path = dir_path.path() + "/.";
+    const int ret = statfs(qPrintable(statfs_path), &stats);
+    if (ret == 0) {
+        available = ((unsigned long long)stats.f_bavail)
+                * ((unsigned long long)stats.f_bsize);
+        return available;
+    }
+    else {
+        return -1;
+    }
+#endif
+#else
+    typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER);
+    GetDiskFreeSpaceEx_t pGetDiskFreeSpaceEx =
+            (GetDiskFreeSpaceEx_t)::GetProcAddress(::GetModuleHandleW(L"kernel32.dll"), "GetDiskFreeSpaceExW");
+    if (pGetDiskFreeSpaceEx) {
+        ULARGE_INTEGER bytesFree, bytesTotal;
+        unsigned long long *ret;
+        if (pGetDiskFreeSpaceEx((LPCTSTR)(toNativePath(dir_path.path())).utf16(), &bytesFree, &bytesTotal, NULL)) {
+            ret = (unsigned long long*)&bytesFree;
+            return *ret;
+        }
+        else {
+            return -1;
+        }
+    }
+    else {
+        return -1;
+    }
+#endif
+}
+
+QString Utils::Fs::branchPath(const QString& file_path, QString* removed)
+{
+    QString ret = fromNativePath(file_path);
+    if (ret.endsWith("/"))
+        ret.chop(1);
+    const int slashIndex = ret.lastIndexOf("/");
+    if (slashIndex >= 0) {
+        if (removed)
+            *removed = ret.mid(slashIndex + 1);
+        ret = ret.left(slashIndex);
+    }
+    return ret;
+}
+
+bool Utils::Fs::sameFileNames(const QString &first, const QString &second)
+{
+#if defined(Q_OS_UNIX) || defined(Q_WS_QWS)
+    return QString::compare(first, second, Qt::CaseSensitive) == 0;
+#else
+    return QString::compare(first, second, Qt::CaseInsensitive) == 0;
+#endif
+}
+
+QString Utils::Fs::expandPath(const QString &path)
+{
+    QString ret = fromNativePath(path.trimmed());
+    if (ret.isEmpty())
+        return ret;
+
+    return QDir::cleanPath(ret);
+}
+
+QString Utils::Fs::expandPathAbs(const QString& path)
+{
+    QString ret = expandPath(path);
+
+    if (!QDir::isAbsolutePath(ret))
+        ret = QDir(ret).absolutePath();
+
+    return ret;
+}
+
+QString Utils::Fs::QDesktopServicesDataLocation()
+{
+    QString result;
+#ifdef Q_OS_WIN
+    LPWSTR path=new WCHAR[256];
+    if (SHGetSpecialFolderPath(0, path, CSIDL_LOCAL_APPDATA, FALSE))
+        result = fromNativePath(QString::fromWCharArray(path));
+    if (!QCoreApplication::applicationName().isEmpty())
+        result += QLatin1String("/") + qApp->applicationName();
+#else
+#ifdef Q_OS_MAC
+    FSRef ref;
+    OSErr err = FSFindFolder(kUserDomain, kApplicationSupportFolderType, false, &ref);
+    if (err)
+        return QString();
+    QString path;
+    QByteArray ba(2048, 0);
+    if (FSRefMakePath(&ref, reinterpret_cast<UInt8 *>(ba.data()), ba.size()) == noErr)
+        result = QString::fromUtf8(ba).normalized(QString::NormalizationForm_C);
+    result += QLatin1Char('/') + qApp->applicationName();
+#else
+    QString xdgDataHome = QLatin1String(qgetenv("XDG_DATA_HOME"));
+    if (xdgDataHome.isEmpty())
+        xdgDataHome = QDir::homePath() + QLatin1String("/.local/share");
+    xdgDataHome += QLatin1String("/data/")
+            + qApp->applicationName();
+    result = xdgDataHome;
+#endif
+#endif
+    if (!result.endsWith("/"))
+        result += "/";
+    return result;
+}
+
+QString Utils::Fs::QDesktopServicesCacheLocation()
+{
+    QString result;
+#if defined(Q_OS_WIN) || defined(Q_OS_OS2)
+    result = QDesktopServicesDataLocation() + QLatin1String("cache");
+#else
+#ifdef Q_OS_MAC
+    // http://developer.apple.com/documentation/Carbon/Reference/Folder_Manager/Reference/reference.html
+    FSRef ref;
+    OSErr err = FSFindFolder(kUserDomain, kCachedDataFolderType, false, &ref);
+    if (err)
+        return QString();
+    QByteArray ba(2048, 0);
+    if (FSRefMakePath(&ref, reinterpret_cast<UInt8 *>(ba.data()), ba.size()) == noErr)
+        result = QString::fromUtf8(ba).normalized(QString::NormalizationForm_C);
+    result += QLatin1Char('/') + qApp->applicationName();
+#else
+    QString xdgCacheHome = QLatin1String(qgetenv("XDG_CACHE_HOME"));
+    if (xdgCacheHome.isEmpty())
+        xdgCacheHome = QDir::homePath() + QLatin1String("/.cache");
+    xdgCacheHome += QLatin1Char('/') + QCoreApplication::applicationName();
+    result = xdgCacheHome;
+#endif
+#endif
+    if (!result.endsWith("/"))
+        result += "/";
+    return result;
+}
+
+QString Utils::Fs::QDesktopServicesDownloadLocation()
+{
+#ifdef QBT_USES_QT5
+#if defined(Q_OS_WIN)
+    if (QSysInfo::windowsVersion() <= QSysInfo::WV_XP)  // Windows XP
+        return QDir(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)).absoluteFilePath(
+                    QCoreApplication::translate("fsutils", "Downloads"));
+#endif
+    return QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
+#else
+
+#if defined(Q_OS_OS2)
+    return QDir(QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation)).absoluteFilePath(
+                QCoreApplication::translate("fsutils", "Downloads"));
+#endif
+
+#if defined(Q_OS_WIN)
+    // as long as it stays WinXP like we do the same on OS/2
+    // TODO: Use IKnownFolderManager to get path of FOLDERID_Downloads
+    // instead of hardcoding "Downloads"
+    // Unfortunately, this would break compatibility with WinXP
+    if (QSysInfo::windowsVersion() <= QSysInfo::WV_XP)  // Windows XP
+        return QDir(QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation)).absoluteFilePath(
+                    QCoreApplication::translate("fsutils", "Downloads"));
+    else
+        return QDir(QDesktopServices::storageLocation(QDesktopServices::HomeLocation)).absoluteFilePath("Downloads");
+#endif
+
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC))
+    QString save_path;
+    // Default save path on Linux
+    QString config_path = QString::fromLocal8Bit(qgetenv("XDG_CONFIG_HOME").constData());
+    if (config_path.isEmpty())
+        config_path = QDir::home().absoluteFilePath(".config");
+
+    QString user_dirs_file = config_path + "/user-dirs.dirs";
+    if (QFile::exists(user_dirs_file)) {
+        QSettings settings(user_dirs_file, QSettings::IniFormat);
+        // We need to force UTF-8 encoding here since this is not
+        // the default for Ini files.
+        settings.setIniCodec("UTF-8");
+        QString xdg_download_dir = settings.value("XDG_DOWNLOAD_DIR").toString();
+        if (!xdg_download_dir.isEmpty()) {
+            // Resolve $HOME environment variables
+            xdg_download_dir.replace("$HOME", QDir::homePath());
+            save_path = xdg_download_dir;
+            qDebug() << Q_FUNC_INFO << "SUCCESS: Using XDG path for downloads: " << save_path;
+        }
+    }
+
+    // Fallback
+    if (!save_path.isEmpty() && !QFile::exists(save_path)) {
+        QDir().mkpath(save_path);
+    }
+
+    if (save_path.isEmpty() || !QFile::exists(save_path)) {
+        save_path = QDir::home().absoluteFilePath(QCoreApplication::translate("fsutils", "Downloads"));
+        qDebug() << Q_FUNC_INFO << "using" << save_path << "as fallback since the XDG detection did not work";
+    }
+
+    return save_path;
+#endif
+
+#if defined(Q_OS_MAC)
+    // TODO: How to support this on Mac OS?
+#endif
+
+    // Fallback
+    return QDir::home().absoluteFilePath(QCoreApplication::translate("fsutils", "Downloads"));
+#endif
+}
+
+QString Utils::Fs::searchEngineLocation()
+{
+    QString folder = "nova";
+    if (Utils::Misc::pythonVersion() >= 3)
+        folder = "nova3";
+    const QString location = expandPathAbs(QDesktopServicesDataLocation() + folder);
+    QDir locationDir(location);
+    if (!locationDir.exists())
+        locationDir.mkpath(locationDir.absolutePath());
+    return location;
+}
+
+QString Utils::Fs::cacheLocation()
+{
+    QString location = expandPathAbs(QDesktopServicesCacheLocation());
+    QDir locationDir(location);
+    if (!locationDir.exists())
+        locationDir.mkpath(locationDir.absolutePath());
+    return location;
+}

src/base/utils/fs.h

@@ -0,0 +1,73 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2012  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#ifndef UTILS_FS_H
+#define UTILS_FS_H
+
+/**
+ * Utility functions related to file system.
+ */
+
+#include <QString>
+
+namespace Utils
+{
+    namespace Fs
+    {
+        QString toNativePath(const QString& path);
+        QString fromNativePath(const QString& path);
+        QString fileExtension(const QString& filename);
+        QString fileName(const QString& file_path);
+        QString folderName(const QString& file_path);
+        qint64 computePathSize(const QString& path);
+        bool sameFiles(const QString& path1, const QString& path2);
+        QString toValidFileSystemName(const QString &filename);
+        bool isValidFileSystemName(const QString& filename);
+        qlonglong freeDiskSpaceOnPath(QString path);
+        QString branchPath(const QString& file_path, QString* removed = 0);
+        bool sameFileNames(const QString& first, const QString& second);
+        QString expandPath(const QString& path);
+        QString expandPathAbs(const QString& path);
+
+        bool smartRemoveEmptyFolderTree(const QString& path);
+        bool forceRemove(const QString& file_path);
+        void removeDirRecursive(const QString& dirName);
+
+        /* Ported from Qt4 to drop dependency on QtGui */
+        QString QDesktopServicesDataLocation();
+        QString QDesktopServicesCacheLocation();
+        QString QDesktopServicesDownloadLocation();
+        /* End of Qt4 code */
+        QString searchEngineLocation();
+        QString cacheLocation();
+    }
+}
+
+#endif // UTILS_FS_H

src/base/utils/gzip.cpp

@@ -0,0 +1,142 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#include <QByteArray>
+#include <zlib.h>
+
+#include "gzip.h"
+
+bool Utils::Gzip::compress(QByteArray src, QByteArray &dest)
+{
+    static const int BUFSIZE = 128 * 1024;
+    char tmpBuf[BUFSIZE];
+    int ret;
+
+    dest.clear();
+
+    z_stream strm;
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.next_in = reinterpret_cast<uchar *>(src.data());
+    strm.avail_in = src.length();
+    strm.next_out = reinterpret_cast<uchar *>(tmpBuf);
+    strm.avail_out = BUFSIZE;
+
+    // windowBits = 15 + 16 to enable gzip
+    // From the zlib manual: windowBits can also be greater than 15 for optional gzip encoding. Add 16 to windowBits
+    // to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper.
+    ret = deflateInit2(&strm, Z_BEST_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY);
+
+    if (ret != Z_OK)
+        return false;
+
+    while (strm.avail_in != 0) {
+        ret = deflate(&strm, Z_NO_FLUSH);
+        if (ret != Z_OK)
+            return false;
+
+        if (strm.avail_out == 0) {
+            dest.append(tmpBuf, BUFSIZE);
+            strm.next_out = reinterpret_cast<uchar *>(tmpBuf);
+            strm.avail_out = BUFSIZE;
+        }
+    }
+
+    int deflateRes = Z_OK;
+    while (deflateRes == Z_OK) {
+        if (strm.avail_out == 0) {
+            dest.append(tmpBuf, BUFSIZE);
+            strm.next_out = reinterpret_cast<uchar *>(tmpBuf);
+            strm.avail_out = BUFSIZE;
+        }
+
+        deflateRes = deflate(&strm, Z_FINISH);
+    }
+
+    if (deflateRes != Z_STREAM_END)
+        return false;
+
+    dest.append(tmpBuf, BUFSIZE - strm.avail_out);
+    deflateEnd(&strm);
+
+    return true;
+}
+
+bool Utils::Gzip::uncompress(QByteArray src, QByteArray &dest)
+{
+    dest.clear();
+
+    if (src.size() <= 4) {
+        qWarning("uncompress: Input data is truncated");
+        return false;
+    }
+
+    z_stream strm;
+    static const int CHUNK_SIZE = 1024;
+    char out[CHUNK_SIZE];
+
+    /* allocate inflate state */
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.avail_in = static_cast<uint>(src.size());
+    strm.next_in = reinterpret_cast<uchar *>(src.data());
+
+    const int windowBits = 15;
+    const int ENABLE_ZLIB_GZIP = 32;
+
+    int ret = inflateInit2(&strm, windowBits | ENABLE_ZLIB_GZIP); // gzip decoding
+    if (ret != Z_OK)
+        return false;
+
+    // run inflate()
+    do {
+        strm.avail_out = CHUNK_SIZE;
+        strm.next_out = reinterpret_cast<uchar *>(out);
+
+        ret = inflate(&strm, Z_NO_FLUSH);
+        Q_ASSERT(ret != Z_STREAM_ERROR); // state not clobbered
+
+        switch (ret) {
+        case Z_NEED_DICT:
+        case Z_DATA_ERROR:
+        case Z_MEM_ERROR:
+            inflateEnd(&strm);
+            return false;
+        }
+
+        dest.append(out, CHUNK_SIZE - strm.avail_out);
+    }
+    while (!strm.avail_out);
+
+    // clean up and return
+    inflateEnd(&strm);
+    return true;
+}

src/base/utils/gzip.h

@@ -0,0 +1,44 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#ifndef UTILS_GZIP_H
+#define UTILS_GZIP_H
+
+class QByteArray;
+
+namespace Utils
+{
+    namespace Gzip
+    {
+        bool compress(QByteArray src, QByteArray &dest);
+        bool uncompress(QByteArray src, QByteArray &dest);
+    }
+}
+
+#endif // UTILS_GZIP_H

src/base/utils/misc.cpp

@@ -0,0 +1,651 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include <QUrl>
+#include <QDir>
+#include <QFileInfo>
+#include <QDateTime>
+#include <QByteArray>
+#include <QDebug>
+#include <QProcess>
+#include <QSettings>
+#include <QThread>
+
+#ifdef DISABLE_GUI
+#include <QCoreApplication>
+#else
+#include <QApplication>
+#include <QDesktopWidget>
+#include <QStyle>
+#endif
+
+#ifdef Q_OS_WIN
+#include <windows.h>
+#include <PowrProf.h>
+const int UNLEN = 256;
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#endif
+
+#ifdef Q_OS_MAC
+#include <CoreServices/CoreServices.h>
+#include <Carbon/Carbon.h>
+#endif
+
+#ifndef DISABLE_GUI
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC)) && defined(QT_DBUS_LIB)
+#include <QDBusInterface>
+#include <QDBusMessage>
+#endif
+#endif // DISABLE_GUI
+
+#ifndef DISABLE_GUI
+#include <QDesktopServices>
+#include <QProcess>
+#endif
+
+#include "base/utils/string.h"
+#include "base/unicodestrings.h"
+#include "base/logger.h"
+#include "misc.h"
+#include "fs.h"
+
+static struct { const char *source; const char *comment; } units[] = {
+    QT_TRANSLATE_NOOP3("misc", "B", "bytes"),
+    QT_TRANSLATE_NOOP3("misc", "KiB", "kibibytes (1024 bytes)"),
+    QT_TRANSLATE_NOOP3("misc", "MiB", "mebibytes (1024 kibibytes)"),
+    QT_TRANSLATE_NOOP3("misc", "GiB", "gibibytes (1024 mibibytes)"),
+    QT_TRANSLATE_NOOP3("misc", "TiB", "tebibytes (1024 gibibytes)")
+};
+
+#ifndef DISABLE_GUI
+void Utils::Misc::shutdownComputer(ShutdownAction action)
+{
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC)) && defined(QT_DBUS_LIB)
+    // Use dbus to power off / suspend the system
+    if (action != ShutdownAction::Shutdown) {
+        // Some recent systems use systemd's logind
+        QDBusInterface login1Iface("org.freedesktop.login1", "/org/freedesktop/login1",
+                                   "org.freedesktop.login1.Manager", QDBusConnection::systemBus());
+        if (login1Iface.isValid()) {
+            if (action == ShutdownAction::Suspend)
+                login1Iface.call("Suspend", false);
+            else
+                login1Iface.call("Hibernate", false);
+            return;
+        }
+        // Else, other recent systems use UPower
+        QDBusInterface upowerIface("org.freedesktop.UPower", "/org/freedesktop/UPower",
+                                   "org.freedesktop.UPower", QDBusConnection::systemBus());
+        if (upowerIface.isValid()) {
+            if (action == ShutdownAction::Suspend)
+                upowerIface.call("Suspend");
+            else
+                upowerIface.call("Hibernate");
+            return;
+        }
+        // HAL (older systems)
+        QDBusInterface halIface("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer",
+                                "org.freedesktop.Hal.Device.SystemPowerManagement",
+                                QDBusConnection::systemBus());
+        if (action == ShutdownAction::Suspend)
+            halIface.call("Suspend", 5);
+        else
+            halIface.call("Hibernate");
+    }
+    else {
+        // Some recent systems use systemd's logind
+        QDBusInterface login1Iface("org.freedesktop.login1", "/org/freedesktop/login1",
+                                   "org.freedesktop.login1.Manager", QDBusConnection::systemBus());
+        if (login1Iface.isValid()) {
+            login1Iface.call("PowerOff", false);
+            return;
+        }
+        // Else, other recent systems use ConsoleKit
+        QDBusInterface consolekitIface("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager",
+                                       "org.freedesktop.ConsoleKit.Manager", QDBusConnection::systemBus());
+        if (consolekitIface.isValid()) {
+            consolekitIface.call("Stop");
+            return;
+        }
+        // HAL (older systems)
+        QDBusInterface halIface("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer",
+                                "org.freedesktop.Hal.Device.SystemPowerManagement",
+                                QDBusConnection::systemBus());
+        halIface.call("Shutdown");
+    }
+#endif
+#ifdef Q_OS_MAC
+    AEEventID EventToSend;
+    if (action != ShutdownAction::Shutdown)
+        EventToSend = kAESleep;
+    else
+        EventToSend = kAEShutDown;
+    AEAddressDesc targetDesc;
+    static const ProcessSerialNumber kPSNOfSystemProcess = { 0, kSystemProcess };
+    AppleEvent eventReply = {typeNull, NULL};
+    AppleEvent appleEventToSend = {typeNull, NULL};
+
+    OSStatus error = AECreateDesc(typeProcessSerialNumber, &kPSNOfSystemProcess,
+                         sizeof(kPSNOfSystemProcess), &targetDesc);
+
+    if (error != noErr)
+        return;
+
+    error = AECreateAppleEvent(kCoreEventClass, EventToSend, &targetDesc,
+                               kAutoGenerateReturnID, kAnyTransactionID, &appleEventToSend);
+
+    AEDisposeDesc(&targetDesc);
+    if (error != noErr)
+        return;
+
+    error = AESend(&appleEventToSend, &eventReply, kAENoReply,
+                   kAENormalPriority, kAEDefaultTimeout, NULL, NULL);
+
+    AEDisposeDesc(&appleEventToSend);
+    if (error != noErr)
+        return;
+
+    AEDisposeDesc(&eventReply);
+#endif
+#ifdef Q_OS_WIN
+    HANDLE hToken;            // handle to process token
+    TOKEN_PRIVILEGES tkp;     // pointer to token structure
+    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
+        return;
+    // Get the LUID for shutdown privilege.
+    LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
+                         &tkp.Privileges[0].Luid);
+
+    tkp.PrivilegeCount = 1; // one privilege to set
+    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+    // Get shutdown privilege for this process.
+
+    AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
+                          (PTOKEN_PRIVILEGES) NULL, 0);
+
+    // Cannot test the return value of AdjustTokenPrivileges.
+
+    if (GetLastError() != ERROR_SUCCESS)
+        return;
+
+    if (action == ShutdownAction::Suspend)
+        SetSuspendState(false, false, false);
+    else if (action == ShutdownAction::Hibernate)
+        SetSuspendState(true, false, false);
+    else
+        InitiateSystemShutdownA(0, QCoreApplication::translate("misc", "qBittorrent will shutdown the computer now because all downloads are complete.").toLocal8Bit().data(), 10, true, false);
+
+    // Disable shutdown privilege.
+    tkp.Privileges[0].Attributes = 0;
+    AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
+                          (PTOKEN_PRIVILEGES) NULL, 0);
+#endif
+}
+#endif // DISABLE_GUI
+
+#ifndef DISABLE_GUI
+// Get screen center
+QPoint Utils::Misc::screenCenter(QWidget *win)
+{
+    int scrn = 0;
+    const QWidget *w = win->window();
+
+    if (w)
+        scrn = QApplication::desktop()->screenNumber(w);
+    else if (QApplication::desktop()->isVirtualDesktop())
+        scrn = QApplication::desktop()->screenNumber(QCursor::pos());
+    else
+        scrn = QApplication::desktop()->screenNumber(win);
+
+    QRect desk(QApplication::desktop()->availableGeometry(scrn));
+    return QPoint((desk.width() - win->frameGeometry().width()) / 2, (desk.height() - win->frameGeometry().height()) / 2);
+}
+#endif
+
+/**
+ * Detects the python version.
+ */
+int Utils::Misc::pythonVersion()
+{
+    static int version = -1;
+    if (version < 0) {
+        QString versionComplete = pythonVersionComplete().trimmed();
+        QStringList splitted = versionComplete.split('.');
+        if (splitted.size() > 1) {
+            int highVer = splitted.at(0).toInt();
+            if ((highVer == 2) || (highVer == 3))
+                version = highVer;
+        }
+    }
+    return version;
+}
+
+/**
+ * Detects the python executable by calling "python --version".
+ */
+QString Utils::Misc::pythonExecutable()
+{
+    static QString executable;
+    if (executable.isEmpty()) {
+        QProcess pythonProc;
+#if defined(Q_OS_UNIX)
+        /*
+         * On Unix-Like Systems python2 and python3 should always exist
+         * http://legacy.python.org/dev/peps/pep-0394/
+         */
+        pythonProc.start("python3", QStringList() << "--version", QIODevice::ReadOnly);
+        if (pythonProc.waitForFinished() && pythonProc.exitCode() == 0) {
+            executable = "python3";
+            return executable;
+        }
+        pythonProc.start("python2", QStringList() << "--version", QIODevice::ReadOnly);
+        if (pythonProc.waitForFinished() && pythonProc.exitCode() == 0) {
+            executable = "python2";
+            return executable;
+        }
+#endif
+        // Look for "python" in Windows and in UNIX if "python2" and "python3" are
+        // not detected.
+        pythonProc.start("python", QStringList() << "--version", QIODevice::ReadOnly);
+        if (pythonProc.waitForFinished() && pythonProc.exitCode() == 0)
+            executable = "python";
+        else
+            Logger::instance()->addMessage(QCoreApplication::translate("misc", "Python not detected"), Log::INFO);
+    }
+    return executable;
+}
+
+/**
+ * Returns the complete python version
+ * eg 2.7.9
+ * Make sure to have setup python first
+ */
+QString Utils::Misc::pythonVersionComplete() {
+    static QString version;
+    if (version.isEmpty()) {
+        if (pythonExecutable().isEmpty())
+            return version;
+        QProcess pythonProc;
+        pythonProc.start(pythonExecutable(), QStringList() << "--version", QIODevice::ReadOnly);
+        if (pythonProc.waitForFinished() && pythonProc.exitCode() == 0) {
+            QByteArray output = pythonProc.readAllStandardOutput();
+            if (output.isEmpty())
+                output = pythonProc.readAllStandardError();
+
+            // Software 'Anaconda' installs its own python interpreter
+            // and `python --version` returns a string like this:
+            // `Python 3.4.3 :: Anaconda 2.3.0 (64-bit)`
+            const QList<QByteArray> verSplit = output.split(' ');
+            if (verSplit.size() > 1) {
+                version = verSplit.at(1).trimmed();
+                Logger::instance()->addMessage(QCoreApplication::translate("misc", "Python version: %1").arg(version), Log::INFO);
+            }
+        }
+    }
+    return version;
+}
+
+// return best userfriendly storage unit (B, KiB, MiB, GiB, TiB)
+// use Binary prefix standards from IEC 60027-2
+// see http://en.wikipedia.org/wiki/Kilobyte
+// value must be given in bytes
+// to send numbers instead of strings with suffixes
+QString Utils::Misc::friendlyUnit(qreal val, bool is_speed)
+{
+    if (val < 0)
+        return QCoreApplication::translate("misc", "Unknown", "Unknown (size)");
+    int i = 0;
+    while(val >= 1024. && i < 4) {
+        val /= 1024.;
+        ++i;
+    }
+    QString ret;
+    if (i == 0)
+        ret = QString::number((long)val) + " " + QCoreApplication::translate("misc", units[0].source, units[0].comment);
+    else
+        ret = Utils::String::fromDouble(val, 1) + " " + QCoreApplication::translate("misc", units[i].source, units[i].comment);
+    if (is_speed)
+        ret += QCoreApplication::translate("misc", "/s", "per second");
+    return ret;
+}
+
+bool Utils::Misc::isPreviewable(const QString& extension)
+{
+    static QSet<QString> multimedia_extensions;
+    if (multimedia_extensions.empty()) {
+        multimedia_extensions.insert("3GP");
+        multimedia_extensions.insert("AAC");
+        multimedia_extensions.insert("AC3");
+        multimedia_extensions.insert("AIF");
+        multimedia_extensions.insert("AIFC");
+        multimedia_extensions.insert("AIFF");
+        multimedia_extensions.insert("ASF");
+        multimedia_extensions.insert("AU");
+        multimedia_extensions.insert("AVI");
+        multimedia_extensions.insert("FLAC");
+        multimedia_extensions.insert("FLV");
+        multimedia_extensions.insert("M3U");
+        multimedia_extensions.insert("M4A");
+        multimedia_extensions.insert("M4P");
+        multimedia_extensions.insert("M4V");
+        multimedia_extensions.insert("MID");
+        multimedia_extensions.insert("MKV");
+        multimedia_extensions.insert("MOV");
+        multimedia_extensions.insert("MP2");
+        multimedia_extensions.insert("MP3");
+        multimedia_extensions.insert("MP4");
+        multimedia_extensions.insert("MPC");
+        multimedia_extensions.insert("MPE");
+        multimedia_extensions.insert("MPEG");
+        multimedia_extensions.insert("MPG");
+        multimedia_extensions.insert("MPP");
+        multimedia_extensions.insert("OGG");
+        multimedia_extensions.insert("OGM");
+        multimedia_extensions.insert("OGV");
+        multimedia_extensions.insert("QT");
+        multimedia_extensions.insert("RA");
+        multimedia_extensions.insert("RAM");
+        multimedia_extensions.insert("RM");
+        multimedia_extensions.insert("RMV");
+        multimedia_extensions.insert("RMVB");
+        multimedia_extensions.insert("SWA");
+        multimedia_extensions.insert("SWF");
+        multimedia_extensions.insert("VOB");
+        multimedia_extensions.insert("WAV");
+        multimedia_extensions.insert("WMA");
+        multimedia_extensions.insert("WMV");
+    }
+
+    if (extension.isEmpty())
+        return false;
+
+    return multimedia_extensions.contains(extension.toUpper());
+}
+
+QString Utils::Misc::bcLinkToMagnet(QString bc_link)
+{
+    QByteArray raw_bc = bc_link.toUtf8();
+    raw_bc = raw_bc.mid(8); // skip bc://bt/
+    raw_bc = QByteArray::fromBase64(raw_bc); // Decode base64
+    // Format is now AA/url_encoded_filename/size_bytes/info_hash/ZZ
+    QStringList parts = QString(raw_bc).split("/");
+    if (parts.size() != 5) return QString::null;
+    QString filename = parts.at(1);
+    QString hash = parts.at(3);
+    QString magnet = "magnet:?xt=urn:btih:" + hash;
+    magnet += "&dn=" + filename;
+    return magnet;
+}
+
+// Take a number of seconds and return an user-friendly
+// time duration like "1d 2h 10m".
+QString Utils::Misc::userFriendlyDuration(qlonglong seconds)
+{
+    if (seconds < 0 || seconds >= MAX_ETA)
+        return QString::fromUtf8(C_INFINITY);
+    if (seconds == 0)
+        return "0";
+    if (seconds < 60)
+        return QCoreApplication::translate("misc", "< 1m", "< 1 minute");
+    int minutes = seconds / 60;
+    if (minutes < 60)
+        return QCoreApplication::translate("misc", "%1m","e.g: 10minutes").arg(QString::number(minutes));
+    int hours = minutes / 60;
+    minutes = minutes - hours * 60;
+    if (hours < 24)
+        return QCoreApplication::translate("misc", "%1h %2m", "e.g: 3hours 5minutes").arg(QString::number(hours)).arg(QString::number(minutes));
+    int days = hours / 24;
+    hours = hours - days * 24;
+    if (days < 100)
+        return QCoreApplication::translate("misc", "%1d %2h", "e.g: 2days 10hours").arg(QString::number(days)).arg(QString::number(hours));
+    return QString::fromUtf8(C_INFINITY);
+}
+
+QString Utils::Misc::getUserIDString()
+{
+    QString uid = "0";
+#ifdef Q_OS_WIN
+    WCHAR buffer[UNLEN + 1] = {0};
+    DWORD buffer_len = sizeof(buffer)/sizeof(*buffer);
+    if (GetUserNameW(buffer, &buffer_len))
+        uid = QString::fromWCharArray(buffer);
+#else
+    uid = QString::number(getuid());
+#endif
+    return uid;
+}
+
+QStringList Utils::Misc::toStringList(const QList<bool> &l)
+{
+    QStringList ret;
+    foreach (const bool &b, l)
+        ret << (b ? "1" : "0");
+    return ret;
+}
+
+QList<int> Utils::Misc::intListfromStringList(const QStringList &l)
+{
+    QList<int> ret;
+    foreach (const QString &s, l)
+        ret << s.toInt();
+    return ret;
+}
+
+QList<bool> Utils::Misc::boolListfromStringList(const QStringList &l)
+{
+    QList<bool> ret;
+    foreach (const QString &s, l)
+        ret << (s == "1");
+    return ret;
+}
+
+bool Utils::Misc::isUrl(const QString &s)
+{
+    const QString scheme = QUrl(s).scheme();
+    QRegExp is_url("http[s]?|ftp", Qt::CaseInsensitive);
+    return is_url.exactMatch(scheme);
+}
+
+QString Utils::Misc::parseHtmlLinks(const QString &raw_text)
+{
+    QString result = raw_text;
+    static QRegExp reURL(
+        "(\\s|^)"                                             //start with whitespace or beginning of line
+        "("
+        "("                                              //case 1 -- URL with scheme
+        "(http(s?))\\://"                            //start with scheme
+        "([a-zA-Z0-9_-]+\\.)+"                       //  domainpart.  at least one of these must exist
+        "([a-zA-Z0-9\\?%=&/_\\.:#;-]+)"              //  everything to 1st non-URI char, must be at least one char after the previous dot (cannot use ".*" because it can be too greedy)
+        ")"
+        "|"
+        "("                                             //case 2a -- no scheme, contains common TLD  example.com
+        "([a-zA-Z0-9_-]+\\.)+"                      //  domainpart.  at least one of these must exist
+        "(?="                                       //  must be followed by TLD
+        "AERO|aero|"                          //N.B. assertions are non-capturing
+        "ARPA|arpa|"
+        "ASIA|asia|"
+        "BIZ|biz|"
+        "CAT|cat|"
+        "COM|com|"
+        "COOP|coop|"
+        "EDU|edu|"
+        "GOV|gov|"
+        "INFO|info|"
+        "INT|int|"
+        "JOBS|jobs|"
+        "MIL|mil|"
+        "MOBI|mobi|"
+        "MUSEUM|museum|"
+        "NAME|name|"
+        "NET|net|"
+        "ORG|org|"
+        "PRO|pro|"
+        "RO|ro|"
+        "RU|ru|"
+        "TEL|tel|"
+        "TRAVEL|travel"
+        ")"
+        "([a-zA-Z0-9\\?%=&/_\\.:#;-]+)"             //  everything to 1st non-URI char, must be at least one char after the previous dot (cannot use ".*" because it can be too greedy)
+        ")"
+        "|"
+        "("                                             // case 2b no scheme, no TLD, must have at least 2 alphanum strings plus uncommon TLD string  --> del.icio.us
+        "([a-zA-Z0-9_-]+\\.) {2,}"                   //2 or more domainpart.   --> del.icio.
+        "[a-zA-Z]{2,}"                              //one ab  (2 char or longer) --> us
+        "([a-zA-Z0-9\\?%=&/_\\.:#;-]*)"             // everything to 1st non-URI char, maybe nothing  in case of del.icio.us/path
+        ")"
+        ")"
+        );
+
+
+    // Capture links
+    result.replace(reURL, "\\1<a href=\"\\2\">\\2</a>");
+
+    // Capture links without scheme
+    static QRegExp reNoScheme("<a\\s+href=\"(?!http(s?))([a-zA-Z0-9\\?%=&/_\\.-:#]+)\\s*\">");
+    result.replace(reNoScheme, "<a href=\"http://\\1\">");
+
+    // to preserve plain text formatting
+    result = "<p style=\"white-space: pre-wrap;\">" + result + "</p>";
+    return result;
+}
+
+#ifndef DISABLE_GUI
+// Open the given path with an appropriate application
+void Utils::Misc::openPath(const QString& absolutePath)
+{
+    const QString path = Utils::Fs::fromNativePath(absolutePath);
+    // Hack to access samba shares with QDesktopServices::openUrl
+    if (path.startsWith("//"))
+        QDesktopServices::openUrl(Utils::Fs::toNativePath("file:" + path));
+    else
+        QDesktopServices::openUrl(QUrl::fromLocalFile(path));
+}
+
+// Open the parent directory of the given path with a file manager and select
+// (if possible) the item at the given path
+void Utils::Misc::openFolderSelect(const QString& absolutePath)
+{
+    const QString path = Utils::Fs::fromNativePath(absolutePath);
+#ifdef Q_OS_WIN
+    if (QFileInfo(path).exists()) {
+        // Syntax is: explorer /select, "C:\Folder1\Folder2\file_to_select"
+        // Dir separators MUST be win-style slashes
+
+        // QProcess::startDetached() has an obscure bug. If the path has
+        // no spaces and a comma(and maybe other special characters) it doesn't
+        // get wrapped in quotes. So explorer.exe can't find the correct path and
+        // displays the default one. If we wrap the path in quotes and pass it to
+        // QProcess::startDetached() explorer.exe still shows the default path. In
+        // this case QProcess::startDetached() probably puts its own quotes around ours.
+
+        STARTUPINFO startupInfo;
+        ::ZeroMemory(&startupInfo, sizeof(startupInfo));
+        startupInfo.cb = sizeof(startupInfo);
+
+        PROCESS_INFORMATION processInfo;
+        ::ZeroMemory(&processInfo, sizeof(processInfo));
+
+        QString cmd = QString("explorer.exe /select,\"%1\"").arg(Utils::Fs::toNativePath(absolutePath));
+        LPWSTR lpCmd = new WCHAR[cmd.size() + 1];
+        cmd.toWCharArray(lpCmd);
+        lpCmd[cmd.size()] = 0;
+
+        bool ret = ::CreateProcessW(NULL, lpCmd, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo);
+        delete [] lpCmd;
+
+        if (ret) {
+            ::CloseHandle(processInfo.hProcess);
+            ::CloseHandle(processInfo.hThread);
+        }
+    }
+    else {
+        // If the item to select doesn't exist, try to open its parent
+        openPath(path.left(path.lastIndexOf("/")));
+    }
+#elif defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
+    if (QFileInfo(path).exists()) {
+        QProcess proc;
+        QString output;
+        proc.start("xdg-mime", QStringList() << "query" << "default" << "inode/directory");
+        proc.waitForFinished();
+        output = proc.readLine().simplified();
+        if (output == "dolphin.desktop" || output == "org.kde.dolphin.desktop")
+            proc.startDetached("dolphin", QStringList() << "--select" << Utils::Fs::toNativePath(path));
+        else if (output == "nautilus.desktop" || output == "org.gnome.Nautilus.desktop"
+                 || output == "nautilus-folder-handler.desktop")
+            proc.startDetached("nautilus", QStringList() << "--no-desktop" << Utils::Fs::toNativePath(path));
+        else if (output == "caja-folder-handler.desktop")
+            proc.startDetached("caja", QStringList() << "--no-desktop" << Utils::Fs::toNativePath(path));
+        else if (output == "nemo.desktop")
+            proc.startDetached("nemo", QStringList() << "--no-desktop" << Utils::Fs::toNativePath(path));
+        else if (output == "konqueror.desktop" || output == "kfmclient_dir.desktop")
+            proc.startDetached("konqueror", QStringList() << "--select" << Utils::Fs::toNativePath(path));
+        else
+            openPath(path.left(path.lastIndexOf("/")));
+    }
+    else {
+        // If the item to select doesn't exist, try to open its parent
+        openPath(path.left(path.lastIndexOf("/")));
+    }
+#else
+    openPath(path.left(path.lastIndexOf("/")));
+#endif
+}
+#endif // DISABLE_GUI
+
+namespace
+{
+    //  Trick to get a portable sleep() function
+    class SleeperThread : public QThread
+    {
+    public:
+        static void msleep(unsigned long msecs)
+        {
+            QThread::msleep(msecs);
+        }
+    };
+}
+
+void Utils::Misc::msleep(unsigned long msecs)
+{
+    SleeperThread::msleep(msecs);
+}
+
+#ifndef DISABLE_GUI
+QSize Utils::Misc::smallIconSize()
+{
+    // Get DPI scaled icon size (device-dependent), see QT source
+    int s = QApplication::style()->pixelMetric(QStyle::PM_SmallIconSize);
+    return QSize(s, s);
+}
+#endif

src/base/utils/misc.h

@@ -0,0 +1,89 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#ifndef UTILS_MISC_H
+#define UTILS_MISC_H
+
+#include <vector>
+#include <QString>
+#include <QStringList>
+#include <ctime>
+#include <QPoint>
+#include <QFile>
+#include <QDir>
+#include <QUrl>
+#include "base/types.h"
+
+/*  Miscellaneous functions that can be useful */
+
+namespace Utils
+{
+    namespace Misc
+    {
+        QString parseHtmlLinks(const QString &raw_text);
+        bool isUrl(const QString &s);
+
+#ifndef DISABLE_GUI
+        void shutdownComputer(ShutdownAction action);
+        // Get screen center
+        QPoint screenCenter(QWidget *win);
+        QSize smallIconSize();
+#endif
+        int pythonVersion();
+        QString pythonExecutable();
+        QString pythonVersionComplete();
+        // return best userfriendly storage unit (B, KiB, MiB, GiB, TiB)
+        // use Binary prefix standards from IEC 60027-2
+        // see http://en.wikipedia.org/wiki/Kilobyte
+        // value must be given in bytes
+        QString friendlyUnit(qreal val, bool is_speed = false);
+        bool isPreviewable(const QString& extension);
+
+        QString bcLinkToMagnet(QString bc_link);
+        // Take a number of seconds and return an user-friendly
+        // time duration like "1d 2h 10m".
+        QString userFriendlyDuration(qlonglong seconds);
+        QString getUserIDString();
+
+        // Convert functions
+        QStringList toStringList(const QList<bool> &l);
+        QList<int> intListfromStringList(const QStringList &l);
+        QList<bool> boolListfromStringList(const QStringList &l);
+
+#ifndef DISABLE_GUI
+        void openPath(const QString& absolutePath);
+        void openFolderSelect(const QString& absolutePath);
+#endif
+
+        void msleep(unsigned long msecs);
+    }
+}
+
+#endif

src/base/utils/string.cpp

@@ -0,0 +1,211 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#include <QByteArray>
+#include <QString>
+#include <QLocale>
+#include <cmath>
+#include "string.h"
+
+QString Utils::String::fromStdString(const std::string &str)
+{
+    return QString::fromUtf8(str.c_str());
+}
+
+std::string Utils::String::toStdString(const QString &str)
+{
+    QByteArray utf8 = str.toUtf8();
+    return std::string(utf8.constData(), utf8.length());
+}
+
+// uses lessThan comparison
+bool Utils::String::naturalSort(const QString &left, const QString &right, bool &result)
+{
+    // Return value indicates if functions was successful
+    // result argument will contain actual comparison result if function was successful
+    int posL = 0;
+    int posR = 0;
+    do {
+        forever {
+            if (posL == left.size() || posR == right.size())
+                return false; // No data
+
+            QChar leftChar = left.at(posL);
+            QChar rightChar = right.at(posR);
+            bool leftCharIsDigit = leftChar.isDigit();
+            bool rightCharIsDigit = rightChar.isDigit();
+            if (leftCharIsDigit != rightCharIsDigit)
+                return false; // Digit positions mismatch
+
+            if (leftCharIsDigit)
+                break; // Both are digit, break this loop and compare numbers
+
+            if (leftChar != rightChar)
+                return false; // Strings' subsets before digit do not match
+
+            ++posL;
+            ++posR;
+        }
+
+        QString temp;
+        while (posL < left.size()) {
+            if (left.at(posL).isDigit())
+                temp += left.at(posL);
+            else
+                break;
+            posL++;
+        }
+        int numL = temp.toInt();
+        temp.clear();
+
+        while (posR < right.size()) {
+            if (right.at(posR).isDigit())
+                temp += right.at(posR);
+            else
+                break;
+            posR++;
+        }
+        int numR = temp.toInt();
+
+        if (numL != numR) {
+            result = (numL < numR);
+            return true;
+        }
+
+        // Strings + digits do match and we haven't hit string end
+        // Do another round
+
+    } while (true);
+
+    return false;
+}
+
+Utils::String::NaturalCompare::NaturalCompare()
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 2, 0))
+#if defined(Q_OS_WIN)
+    // Without ICU library, QCollator doesn't support `setNumericMode(true)` on OS older than Win7
+    if(QSysInfo::windowsVersion() < QSysInfo::WV_WINDOWS7)
+        return;
+#endif
+    m_collator.setNumericMode(true);
+    m_collator.setCaseSensitivity(Qt::CaseInsensitive);
+#endif
+}
+
+bool Utils::String::NaturalCompare::operator()(const QString &l, const QString &r)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 2, 0))
+#if defined(Q_OS_WIN)
+    // Without ICU library, QCollator doesn't support `setNumericMode(true)` on OS older than Win7
+    if(QSysInfo::windowsVersion() < QSysInfo::WV_WINDOWS7)
+        return lessThan(l, r);
+#endif
+    return (m_collator.compare(l, r) < 0);
+#else
+    return lessThan(l, r);
+#endif
+}
+
+bool Utils::String::NaturalCompare::lessThan(const QString &left, const QString &right)
+{
+    // Return value `false` indicates `right` should go before `left`, otherwise, after
+    int posL = 0;
+    int posR = 0;
+    while (true) {
+        while (true) {
+            if (posL == left.size() || posR == right.size())
+                return (left.size() < right.size());  // when a shorter string is another string's prefix, shorter string place before longer string
+
+            QChar leftChar = left[posL].toLower();
+            QChar rightChar = right[posR].toLower();
+            if (leftChar == rightChar)
+                ;  // compare next character
+            else if (leftChar.isDigit() && rightChar.isDigit())
+                break; // Both are digits, break this loop and compare numbers
+            else
+                return leftChar < rightChar;
+
+            ++posL;
+            ++posR;
+        }
+
+        int startL = posL;
+        while ((posL < left.size()) && left[posL].isDigit())
+            ++posL;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
+        int numL = left.midRef(startL, posL - startL).toInt();
+#else
+        int numL = left.mid(startL, posL - startL).toInt();
+#endif
+
+        int startR = posR;
+        while ((posR < right.size()) && right[posR].isDigit())
+            ++posR;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
+        int numR = right.midRef(startR, posR - startR).toInt();
+#else
+        int numR = right.mid(startR, posR - startR).toInt();
+#endif
+
+        if (numL != numR)
+            return (numL < numR);
+
+        // Strings + digits do match and we haven't hit string end
+        // Do another round
+    }
+    return false;
+}
+
+// to send numbers instead of strings with suffixes
+QString Utils::String::fromDouble(double n, int precision)
+{
+    /* HACK because QString rounds up. Eg QString::number(0.999*100.0, 'f' ,1) == 99.9
+    ** but QString::number(0.9999*100.0, 'f' ,1) == 100.0 The problem manifests when
+    ** the number has more digits after the decimal than we want AND the digit after
+    ** our 'wanted' is >= 5. In this case our last digit gets rounded up. So for each
+    ** precision we add an extra 0 behind 1 in the below algorithm. */
+
+    double prec = std::pow(10.0, precision);
+    return QLocale::system().toString(std::floor(n * prec) / prec, 'f', precision);
+}
+
+// Implements constant-time comparison to protect against timing attacks
+// Taken from https://crackstation.net/hashing-security.htm
+bool Utils::String::slowEquals(const QByteArray &a, const QByteArray &b)
+{
+    int lengthA = a.length();
+    int lengthB = b.length();
+
+    int diff = lengthA ^ lengthB;
+    for (int i = 0; (i < lengthA) && (i < lengthB); i++)
+        diff |= a[i] ^ b[i];
+
+    return (diff == 0);
+}

src/base/utils/string.h

@@ -0,0 +1,70 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#ifndef UTILS_STRING_H
+#define UTILS_STRING_H
+
+#include <string>
+#include <QtGlobal>
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 2, 0))
+#include <QCollator>
+#endif
+
+class QString;
+class QByteArray;
+
+namespace Utils
+{
+    namespace String
+    {
+        QString fromStdString(const std::string &str);
+        std::string toStdString(const QString &str);
+        QString fromDouble(double n, int precision);
+
+        // Implements constant-time comparison to protect against timing attacks
+        // Taken from https://crackstation.net/hashing-security.htm
+        bool slowEquals(const QByteArray &a, const QByteArray &b);
+
+        bool naturalSort(const QString &left, const QString &right, bool &result);
+
+        class NaturalCompare
+        {
+        public:
+            NaturalCompare();
+            bool operator()(const QString &l, const QString &r);
+            bool lessThan(const QString &left, const QString &right);
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 2, 0))
+        private:
+            QCollator m_collator;
+#endif
+        };
+    }
+}
+
+#endif // UTILS_STRING_H