{

QByteArray hash;

int steps = fmhash.length() / 2;

for (int i = 0; i < steps; i++) {

hash.append(fmhash[i * 2]);

hash.append(fmhash[i * 2 + 1]);

hash.append(' ');

}

QString fp = QString::fromLatin1(hash.trimmed());

if (colonSeparated) {

fp.replace(QLatin1Char(' '), QLatin1Char(':'));

}

return fp;

{

#define THE_FACTOR 1024

static const qint64 kb = THE_FACTOR;

static const qint64 mb = THE_FACTOR * kb;

static const qint64 gb = THE_FACTOR * mb;

QString s;

qreal value = octets;

// Whether we care about decimals: only for GB/MB and only

// if it's less than 10 units.

bool round = true;

// do not display terra byte with the current units, as when

// the MB, GB and KB units were made, there was no TB,

// see the JEDEC standard

// https://en.wikipedia.org/wiki/JEDEC_memory_standards

if (octets >= gb) {

s = QCoreApplication::translate("Utility", "%L1 GB");

value /= gb;

round = false;

} else if (octets >= mb) {

s = QCoreApplication::translate("Utility", "%L1 MB");

value /= mb;

round = false;

} else if (octets >= kb) {

s = QCoreApplication::translate("Utility", "%L1 KB");

value /= kb;

} else {

s = QCoreApplication::translate("Utility", "%L1 B");

}

if (value > 9.95)

round = true;

if (round)

return s.arg(qRound(value));

return s.arg(value, 0, 'g', 2);

{

#if defined(Q_OS_WIN)

return QLatin1String("Windows");

#elif defined(Q_OS_MAC)

return QLatin1String("Macintosh");

#elif defined(Q_OS_LINUX)

return QLatin1String("Linux");

#elif defined(__DragonFly__) // Q_OS_FREEBSD also defined

return QLatin1String("DragonFlyBSD");

#elif defined(Q_OS_FREEBSD) || defined(Q_OS_FREEBSD_KERNEL)

return QLatin1String("FreeBSD");

#elif defined(Q_OS_NETBSD)

return QLatin1String("NetBSD");

#elif defined(Q_OS_OPENBSD)

return QLatin1String("OpenBSD");

#elif defined(Q_OS_SOLARIS)

return QLatin1String("Solaris");

#else

return QSysInfo::productType();

#endif

{

return QStringLiteral("Mozilla/5.0 (%1) mirall/%2 (%3, %4-%5 ClientArchitecture: %6 OsArchitecture: %7)")

.arg(platform(),

OCC::Version::displayString(),

// accessing the theme to fetch the string is rather difficult

// since this is only needed server-side to identify clients, the app name (as of 2.9, the short name) is good enough

qApp->applicationName(),

QSysInfo::productType(),

QSysInfo::kernelVersion(),

QSysInfo::buildCpuArchitecture(),

QSysInfo::currentCpuArchitecture())

.toLatin1();

{

#if defined(Q_OS_MAC) || defined(Q_OS_FREEBSD) || defined(Q_OS_FREEBSD_KERNEL) || defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD)

struct statvfs stat;

if (statvfs(path.toLocal8Bit().data(), &stat) == 0) {

return (qint64)stat.f_bavail * stat.f_frsize;

}

#elif defined(Q_OS_UNIX)

struct statvfs64 stat;

if (statvfs64(path.toLocal8Bit().data(), &stat) == 0) {

return (qint64)stat.f_bavail * stat.f_frsize;

}

#elif defined(Q_OS_WIN)

ULARGE_INTEGER freeBytes;

freeBytes.QuadPart = 0L;

if (GetDiskFreeSpaceEx(reinterpret_cast<const wchar_t *>(FileSystem::longWinPath(path).utf16()), &freeBytes, NULL, NULL)) {

return freeBytes.QuadPart;

}

#endif

return -1;

{

QLocale locale = QLocale::system();

QChar decPoint = locale.decimalPoint();

QString str = locale.toString(value, 'f', prec);

while (str.endsWith(QLatin1Char('0')) || str.endsWith(decPoint)) {

if (str.endsWith(decPoint)) {

str.chop(1);

break;

}

str.chop(1);

}

if (!unit.isEmpty())

str += (QLatin1Char(' ') + unit);

return str;

{

const QDir fd1(fn1);

const QDir fd2(fn2);

// Attention: If the path does not exist, canonicalPath returns ""

// ONLY use this function with existing pathes.

const QString a = fd1.canonicalPath();

const QString b = fd2.canonicalPath();

bool re = !a.isEmpty() && QString::compare(a, b, fsCasePreserving() ? Qt::CaseInsensitive : Qt::CaseSensitive) == 0;

return re;

{

const char *name;

quint64 msec;

QString description(quint64 value) const

{

return QCoreApplication::translate("Utility", name, nullptr, value);

}

{

int p = 0;

while (periods[p + 1].name && msecs < periods[p].msec) {

p++;

}

auto firstPart = periods[p].description(int(msecs / periods[p].msec));

if (!periods[p + 1].name) {

return firstPart;

}

quint64 secondPartNum = qRound(double(msecs % periods[p].msec) / periods[p + 1].msec);

if (secondPartNum == 0) {

return firstPart;

}

return QCoreApplication::translate("Utility", "%1 %2").arg(firstPart, periods[p + 1].description(secondPartNum));

{

int p = 0;

while (periods[p + 1].name && msecs < periods[p].msec) {

p++;

}

quint64 amount = qRound(double(msecs) / periods[p].msec);

return periods[p].description(amount);

{

if (isMac()) {

QString n(fName);

return n.replace(QLatin1Char(':'), QLatin1Char('/'));

}

return fName;

{

/* strip "XXXX-gzip" */

if(etag.startsWith('"') && etag.endsWith("-gzip\"")) {

etag.chop(6);

etag.remove(0, 1);

}

/* strip trailing -gzip */

if(etag.endsWith("-gzip")) {

etag.chop(5);

}

/* strip normal quotes */

if (etag.startsWith('"') && etag.endsWith('"')) {

etag.chop(1);

etag.remove(0, 1);

}

etag.squeeze();

return etag;

{

volatile int *a = (int *)nullptr;

*a = 1;

{

QByteArray re;

if (isLinux()) {

QString binary(command);

if (binary.isEmpty()) {

binary = qApp->arguments()[0];

}

QStringList params;

params << QStringLiteral("--version");

QProcess process;

process.start(binary, params);

process.waitForFinished(); // sets current thread to sleep and waits for pingProcess end

re = process.readAllStandardOutput();

int newline = re.indexOf('\n');

if (newline > 0) {

re.truncate(newline);

}

}

return re;

{

QDateTime now = QDateTime::currentDateTimeUtc();

if (from.isValid()) {

now = from;

}

if (dt.daysTo(now) > 0) {

int dtn = dt.daysTo(now);

return QObject::tr("%n day(s) ago", "", dtn);

} else {

qint64 secs = dt.secsTo(now);

if (secs < 0) {

return QObject::tr("in the future");

}

if (floor(secs / 3600.0) > 0) {

int hours = floor(secs / 3600.0);

return (QObject::tr("%n hour(s) ago", "", hours));

} else {

int minutes = qRound(secs / 60.0);

if (minutes == 0) {

if (secs < 5) {

return QObject::tr("now");

} else {

return QObject::tr("Less than a minute ago");

}

}

return (QObject::tr("%n minute(s) ago", "", minutes));

}

}

return QObject::tr("Some time ago");

{

QCollator collator;

collator.setNumericMode(true);

collator.setCaseSensitivity(Qt::CaseInsensitive);

std::sort(fileNames.begin(), fileNames.end(), collator);

const QUrlQuery &queryItems)

{

QString path = url.path();

if (!concatPath.isEmpty()) {

// avoid '//'

if (path.endsWith(QLatin1Char('/')) && concatPath.startsWith(QLatin1Char('/'))) {

path.chop(1);

} // avoid missing '/'

else if (!path.endsWith(QLatin1Char('/')) && !concatPath.startsWith(QLatin1Char('/'))) {

path += QLatin1Char('/');

}

path += concatPath; // put the complete path together

}

QUrl tmpUrl = url;

tmpUrl.setPath(path);

tmpUrl.setQuery(queryItems);

return tmpUrl;

const QString &fn, const QDateTime &dt, const QString &user)

{

QString conflictFileName(fn);

// Add conflict tag before the extension.

int dotLocation = conflictFileName.lastIndexOf(QLatin1Char('.'));

// If no extension, add it at the end (take care of cases like foo/.hidden or foo.bar/file)

if (dotLocation <= conflictFileName.lastIndexOf(QLatin1Char('/')) + 1) {

dotLocation = conflictFileName.size();

}

QString conflictMarker = QStringLiteral(" (conflicted copy ");

if (!user.isEmpty()) {

// Don't allow parens in the user name, to ensure

// we can find the beginning and end of the conflict tag.

const auto userName = sanitizeForFileName(user).replace(QLatin1Char('('), QLatin1Char('_')).replace(QLatin1Char(')'), QLatin1Char('_'));;

conflictMarker += userName + QLatin1Char(' ');

}

conflictMarker += dt.toString(QStringLiteral("yyyy-MM-dd hhmmss")) + QLatin1Char(')');

conflictFileName.insert(dotLocation, conflictMarker);

return conflictFileName;

{

auto bname = name.mid(name.lastIndexOf(QLatin1Char('/')) + 1);

if (bname.contains(QStringLiteral("_conflict-")))

return true;

if (bname.contains(QStringLiteral("(conflicted copy")))

return true;

return false;

{

// This function must be able to deal with conflict files for conflict files.

// To do this, we scan backwards, for the outermost conflict marker and

// strip only that to generate the conflict file base name.

auto startOld = conflictName.lastIndexOf("_conflict-");

// A single space before "(conflicted copy" is considered part of the tag

auto startNew = conflictName.lastIndexOf("(conflicted copy");

if (startNew > 0 && conflictName[startNew - 1] == ' ')

startNew -= 1;

// The rightmost tag is relevant

auto tagStart = qMax(startOld, startNew);

if (tagStart == -1)

return "";

// Find the end of the tag

auto tagEnd = conflictName.size();

auto dot = conflictName.lastIndexOf('.'); // dot could be part of user name for new tag!

if (dot > tagStart)

tagEnd = dot;

if (tagStart == startNew) {

auto paren = conflictName.indexOf(')', tagStart);

if (paren != -1)

tagEnd = paren + 1;

}

return conflictName.left(tagStart) + conflictName.mid(tagEnd);

{

const auto invalid = QStringLiteral("/?<>\\:*|\"");

QString result;

result.reserve(name.size());

for (const auto &c : name) {

if (!invalid.contains(c)

&& c.category() != QChar::Other_Control

&& c.category() != QChar::Other_Format) {

result.append(c);

}

}

return result;