Use OWNCLOUD_BIN_DIR directly in C++ code.

No need to do a STR replacement. It actually broke test execution for Debian. See https://bugs.debian.org/844937
2016-11-19 14:30:11 +01:00
@@ -58,9 +58,6 @@ if( UNIX AND NOT APPLE )
 endif()
 ####

-# Enable Q_ASSERT etc. in all builds
-add_definitions( -DQT_FORCE_ASSERTS )
-
 include(GNUInstallDirs)
 include(DefineInstallationPaths)
 include(GenerateExportHeader)
@@ -72,7 +69,7 @@ get_git_head_revision(GIT_REFSPEC GIT_SHA1)
 # if we cannot get it from git, directly try .tag (packages)
 # this will work if the tar balls have been properly created
 # via git-archive.
-if ("${GIT_SHA1}" STREQUAL "GITDIR-NOTFOUND")
+if (${GIT_SHA1} STREQUAL "GITDIR-NOTFOUND")
    file(READ ${CMAKE_SOURCE_DIR}/.tag sha1_candidate)
    string(REPLACE "\n" "" sha1_candidate ${sha1_candidate})
    if (NOT ${sha1_candidate} STREQUAL "$Format:%H$")
@@ -40,6 +40,7 @@ QT_PLUGINS = [
    'imageformats/libqico.dylib',
    'imageformats/libqjpeg.dylib',
    'imageformats/libqsvg.dylib',
+    'imageformats/libqmng.dylib',
 ]

 QT_PLUGINS_SEARCH_PATH=[
@@ -0,0 +1,42 @@
+From ea4dcc5931d455e4ee3e958ffa54a9f54ab022c8 Mon Sep 17 00:00:00 2001
+From: Daniel Molkentin <daniel@molkentin.de>
+Date: Mon, 5 Jan 2015 10:45:25 +0100
+Subject: [PATCH 1/3] Fix crash on Mac OS if PAC URL contains non-URL legal
+ chars
+
+macQueryInternal() was retrieving the PAC URL string as-entered by
+the user in the 'Proxies' tab of the system network settings dialog
+and passing it to CFURLCreateWithString().
+
+CFURLCreateWithString() returns null if the input string contains
+non-URL legal chars or is empty.
+
+Change-Id: I9166d0433a62c7b2274b5435a7dea0a16997d10e
+Patch-By: Robert Knight
+Task-number: QTBUG-36787
+Reviewed-by: Peter Hartmann <phartmann@blackberry.com>
+Reviewed-by: Markus Goetz <markus@woboq.com>
+---
+ src/network/kernel/qnetworkproxy_mac.cpp | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/src/network/kernel/qnetworkproxy_mac.cpp b/src/network/kernel/qnetworkproxy_mac.cpp
+index 7d26246..81bce0c 100644
+--- a/src/network/kernel/qnetworkproxy_mac.cpp
+++ b/src/network/kernel/qnetworkproxy_mac.cpp
+@@ -221,7 +221,11 @@ QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
+         int enabled;
+         if (CFNumberGetValue(pacEnabled, kCFNumberIntType, &enabled) && enabled) {
+             // PAC is enabled
+-            CFStringRef cfPacLocation = (CFStringRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigURLString);
+            // kSCPropNetProxiesProxyAutoConfigURLString returns the URL string
+            // as entered in the system proxy configuration dialog
+            CFStringRef pacLocationSetting = (CFStringRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigURLString);
+            QCFType<CFStringRef> cfPacLocation = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, pacLocationSetting, NULL, NULL,
+                kCFStringEncodingUTF8);
+ 
+             if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+                 QCFType<CFDataRef> pacData;
+-- 
+1.8.3.4 (Apple Git-47)
+
@@ -0,0 +1,38 @@
+From a83e4d1d9dd90d4563ce60f27dfb7802a780e33e Mon Sep 17 00:00:00 2001
+From: Daniel Molkentin <daniel@molkentin.de>
+Date: Mon, 5 Jan 2015 11:42:52 +0100
+Subject: [PATCH 2/3] Fix possible crash when passing an invalid PAC URL
+
+This commit checks whether CFURLCreateWithString() succeeded.
+
+It does not appear to be possible to enter an empty URL directly in the
+PAC configuration dialog but I can't rule out the possibility
+that it could find its way into the settings via some other means.
+
+Change-Id: I6c2053d385503bf0330f5ae9fb1ec36a473d425d
+Patch-By: Robert Knight
+Task-number: QTBUG-36787
+Reviewed-by: Markus Goetz <markus@woboq.com>
+Reviewed-by: Peter Hartmann <phartmann@blackberry.com>
+---
+ src/network/kernel/qnetworkproxy_mac.cpp | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/src/network/kernel/qnetworkproxy_mac.cpp b/src/network/kernel/qnetworkproxy_mac.cpp
+index 81bce0c..6be032e 100644
+--- a/src/network/kernel/qnetworkproxy_mac.cpp
+++ b/src/network/kernel/qnetworkproxy_mac.cpp
+@@ -230,6 +230,10 @@ QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
+             if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+                 QCFType<CFDataRef> pacData;
+                 QCFType<CFURLRef> pacUrl = CFURLCreateWithString(kCFAllocatorDefault, cfPacLocation, NULL);
+                if (!pacUrl) {
+                    qWarning("Invalid PAC URL \"%s\"", qPrintable(QCFString::toQString(cfPacLocation)));
+                    return result;
+                }
+                 SInt32 errorCode;
+                 if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, pacUrl, &pacData, NULL, NULL, &errorCode)) {
+                     QString pacLocation = QCFString::toQString(cfPacLocation);
+-- 
+1.8.3.4 (Apple Git-47)
+
@@ -0,0 +1,39 @@
+From 83bd9393e5564ea9168fda90c0f44456633a483a Mon Sep 17 00:00:00 2001
+From: Daniel Molkentin <daniel@molkentin.de>
+Date: Mon, 5 Jan 2015 15:22:57 +0100
+Subject: [PATCH 3/3] Fix crash if PAC script retrieval returns a null CFData
+ instance
+
+The documentation for CFURLCreateDataAndPropertiesFromResource()
+does not make this clear but from looking at the CFNetwork implementation
+and a user stacktrace it appears that this function can return true
+but not set the data argument under certain circumstances.
+
+Change-Id: I48034a640d6f47a51cd5883bbafacad4bcbd0415
+Task-number: QTBUG-36787
+Patch-By: Robert Knight
+Reviewed-by: Markus Goetz <markus@woboq.com>
+Reviewed-by: Peter Hartmann <phartmann@blackberry.com>
+---
+ src/network/kernel/qnetworkproxy_mac.cpp | 5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/src/network/kernel/qnetworkproxy_mac.cpp b/src/network/kernel/qnetworkproxy_mac.cpp
+index 6be032e..a1ac349 100644
+--- a/src/network/kernel/qnetworkproxy_mac.cpp
+++ b/src/network/kernel/qnetworkproxy_mac.cpp
+@@ -240,7 +240,10 @@ QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
+                     qWarning("Unable to get the PAC script at \"%s\" (%s)", qPrintable(pacLocation), cfurlErrorDescription(errorCode));
+                     return result;
+                 }
+-
+                if (!pacData) {
+                    qWarning("\"%s\" returned an empty PAC script", qPrintable(QCFString::toQString(cfPacLocation)));
+                    return result;
+                }
+                 QCFType<CFStringRef> pacScript = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, pacData, kCFStringEncodingISOLatin1);
+                 if (!pacScript) {
+                     // This should never happen, but the documentation says it may return NULL if there was a problem creating the object.
+-- 
+1.8.3.4 (Apple Git-47)
+
@@ -0,0 +1,32 @@
+From 22f3d359350fd65e4bbe2e9420fcc4460e8a590a Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Morten=20Johan=20S=C3=B8rvig?= <morten.sorvig@digia.com>
+Date: Tue, 10 Mar 2015 22:37:39 +0100
+Subject: [PATCH] Cocoa: Fix systray SVG icons.
+
+Regression caused by f3699510.
+
+Task-number: QTBUG-44686
+Change-Id: I546422a67d4da29fac196025b09bddcb45c1b641
+Reviewed-by: Timur Pocheptsov <Timur.Pocheptsov@digia.com>
+---
+ src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+index e449fd3..8a35705 100755
+--- a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+++ b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+@@ -234,6 +234,10 @@ void QCocoaSystemTrayIcon::updateIcon(const QIcon &icon)
+         }
+     }
+ 
+    // Handle SVG icons, which do not return anything for availableSizes().
+    if (!selectedSize.isValid())
+        selectedSize = icon.actualSize(QSize(maxPixmapHeight, maxPixmapHeight), mode);
+
+     QPixmap pixmap = icon.pixmap(selectedSize, mode);
+ 
+     // Draw a low-resolution icon if there is not enough pixels for a retina
+-- 
+1.9.1
+
@@ -0,0 +1,115 @@
+From ee7fea33383726f0bb72e8082a357820e3ee3675 Mon Sep 17 00:00:00 2001
+From: Jocelyn Turcotte <jturcotte@woboq.com>
+Date: Tue, 24 Feb 2015 17:02:02 +0100
+Subject: [PATCH] OSX Fix disapearing tray icon
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+It would happen together with an error:
+    QPainter::begin: Paint device returned engine == 0
+and would be caused by the size provided to QIcon::pixmap being empty,
+itself caused by the availableSizes list being empty for the Selected
+mode.
+
+This bug was most often hidden by the fact that the Selected icon mode
+was not triggered properly since we usually only set menuVisible after
+calling updateIcon, and most of the time when it did, we would overwrite
+it right after with a Normal mode icon.
+
+Fix the issue by disabling the broken feature completely since the
+default Selected icon is grayed out while tray icons are now usually
+black (or white when selected). To support the dark menu bar mode on
+10.10 we'll need to use NSImage's setTemplate anyway and that
+knowing in advance if we can invert the colors ourselves would also
+better solve the menuVisible usecase.
+
+Task-number: QTBUG-42910
+Change-Id: If9ec9659af28ecceb841bfc2f11721e6029fe891
+Reviewed-by: Morten Johan Sørvig <morten.sorvig@theqtcompany.com>
+---
+ src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm | 17 +++--------------
+ 1 file changed, 3 insertions(+), 14 deletions(-)
+
+diff --git a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+index 8a35705..d366a3c 100755
+--- a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+++ b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+@@ -102,7 +102,6 @@ QT_USE_NAMESPACE
+     QCocoaSystemTrayIcon *systray;
+     NSStatusItem *item;
+     QCocoaMenu *menu;
+-    bool menuVisible;
+     QIcon icon;
+     QT_MANGLE_NAMESPACE(QNSImageView) *imageCell;
+ }
+@@ -202,8 +201,6 @@ void QCocoaSystemTrayIcon::updateIcon(const QIcon &icon)
+ 
+     m_sys->item->icon = icon;
+ 
+-    const bool menuVisible = m_sys->item->menu && m_sys->item->menuVisible;
+-
+     // The reccomended maximum title bar icon height is 18 points
+     // (device independent pixels). The menu height on past and
+     // current OS X versions is 22 points. Provide some future-proofing
+@@ -218,9 +215,8 @@ void QCocoaSystemTrayIcon::updateIcon(const QIcon &icon)
+     // devicePixelRatio for the "best" screen on the system.
+     qreal devicePixelRatio = qApp->devicePixelRatio();
+     const int maxPixmapHeight = maxImageHeight * devicePixelRatio;
+-    const QIcon::Mode mode = menuVisible ? QIcon::Selected : QIcon::Normal;
+     QSize selectedSize;
+-    Q_FOREACH (const QSize& size, sortByHeight(icon.availableSizes(mode))) {
+    Q_FOREACH (const QSize& size, sortByHeight(icon.availableSizes())) {
+         // Select a pixmap based on the height. We want the largest pixmap
+         // with a height smaller or equal to maxPixmapHeight. The pixmap
+         // may rectangular; assume it has a reasonable size. If there is
+@@ -236,9 +232,9 @@ void QCocoaSystemTrayIcon::updateIcon(const QIcon &icon)
+ 
+     // Handle SVG icons, which do not return anything for availableSizes().
+     if (!selectedSize.isValid())
+-        selectedSize = icon.actualSize(QSize(maxPixmapHeight, maxPixmapHeight), mode);
+        selectedSize = icon.actualSize(QSize(maxPixmapHeight, maxPixmapHeight));
+ 
+-    QPixmap pixmap = icon.pixmap(selectedSize, mode);
+    QPixmap pixmap = icon.pixmap(selectedSize);
+ 
+     // Draw a low-resolution icon if there is not enough pixels for a retina
+     // icon. This prevents showing a small icon on retina displays.
+@@ -385,9 +381,6 @@ QT_END_NAMESPACE
+     Q_UNUSED(notification);
+     down = NO;
+ 
+-    parent->systray->updateIcon(parent->icon);
+-    parent->menuVisible = false;
+-
+     [self setNeedsDisplay:YES];
+ }
+ 
+@@ -397,8 +390,6 @@ QT_END_NAMESPACE
+     int clickCount = [mouseEvent clickCount];
+     [self setNeedsDisplay:YES];
+ 
+-    parent->systray->updateIcon(parent->icon);
+-
+     if (clickCount == 2) {
+         [self menuTrackingDone:nil];
+         [parent doubleClickSelector:self];
+@@ -454,7 +445,6 @@ QT_END_NAMESPACE
+     if (self) {
+         item = [[[NSStatusBar systemStatusBar] statusItemWithLength:NSSquareStatusItemLength] retain];
+         menu = 0;
+-        menuVisible = false;
+         systray = sys;
+         imageCell = [[QNSImageView alloc] initWithParent:self];
+         [item setView: imageCell];
+@@ -498,7 +488,6 @@ QT_END_NAMESPACE
+          selector:@selector(menuTrackingDone:)
+              name:NSMenuDidEndTrackingNotification
+                  object:m];
+-        menuVisible = true;
+         [item popUpStatusItemMenu: m];
+     }
+ }
+-- 
+1.9.1
+
@@ -1,27 +1,30 @@
-From 96c34ce85136cbdc16ef83effa8a13137f7ae4c5 Mon Sep 17 00:00:00 2001
+From f3cd07c11e0b7327ffc629f48a89c8c457cdba75 Mon Sep 17 00:00:00 2001
 From: Jocelyn Turcotte <jturcotte@woboq.com>
 Date: Fri, 6 Mar 2015 16:12:37 +0100
-Subject: [PATCH] [NOUPSTREAM] Fix -force-debug-info with macx-clang
+Subject: [PATCH] Fix -force-debug-info with macx-clang

 ---
 mkspecs/common/clang.conf | 2 ++
 1 file changed, 2 insertions(+)

 diff --git a/mkspecs/common/clang.conf b/mkspecs/common/clang.conf
-index e003b94..e9b3291 100644
+index 2c29bb8..110d380 100644
 --- a/mkspecs/common/clang.conf
 +++ b/mkspecs/common/clang.conf
-@@ -21,11 +21,13 @@ QMAKE_CFLAGS_PRECOMPILE          = -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_
+@@ -20,11 +20,13 @@ QMAKE_CFLAGS_ISYSTEM             = -isystem
+ QMAKE_CFLAGS_PRECOMPILE          = -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
 QMAKE_CFLAGS_USE_PRECOMPILE      = -Xclang -include-pch -Xclang ${QMAKE_PCH_OUTPUT}
 QMAKE_CFLAGS_LTCG                = -flto
- QMAKE_CFLAGS_DISABLE_LTCG        = -fno-lto
 +QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO = $$QMAKE_CFLAGS_OPTIMIZE -g
 
 QMAKE_CXXFLAGS_PRECOMPILE        = -x c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
 QMAKE_CXXFLAGS_USE_PRECOMPILE    = $$QMAKE_CFLAGS_USE_PRECOMPILE
 QMAKE_CXXFLAGS_LTCG              = $$QMAKE_CFLAGS_LTCG
- QMAKE_CXXFLAGS_DISABLE_LTCG      = $$QMAKE_CFLAGS_DISABLE_LTCG
-+QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO = $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO
 QMAKE_CXXFLAGS_CXX11             = -std=c++11
- QMAKE_CXXFLAGS_CXX14             = -std=c++1y
- QMAKE_CXXFLAGS_CXX1Z             = -std=c++1z
+QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO = $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO
+ 
+ QMAKE_LFLAGS_CXX11      =
+ QMAKE_LFLAGS_LTCG       = $$QMAKE_CFLAGS_LTCG
+-- 
+2.2.0
+
@@ -0,0 +1,691 @@
+From cff39fba10ffc10ee4dcfdc66ff6528eb26462d3 Mon Sep 17 00:00:00 2001
+From: Markus Goetz <markus@woboq.com>
+Date: Fri, 10 Apr 2015 14:09:53 +0200
+Subject: [PATCH] QNAM: Fix upload corruptions when server closes connection
+
+This patch fixes several upload corruptions if the server closes the connection
+while/before we send data into it. They happen inside multiple places in the HTTP
+layer and are explained in the comments.
+Corruptions are:
+* The upload byte device has an in-flight signal with pending upload data, if
+it gets reset (because server closes the connection) then the re-send of the
+request was sometimes taking this stale in-flight pending upload data.
+* Because some signals were DirectConnection and some were QueuedConnection, there
+was a chance that a direct signal overtakes a queued signal. The state machine
+then sent data down the socket which was buffered there (and sent later) although
+it did not match the current state of the state machine when it was actually sent.
+* A socket was seen as being able to have requests sent even though it was not
+encrypted yet. This relates to the previous corruption where data is stored inside
+the socket's buffer and then sent later.
+
+The included auto test produces all fixed corruptions, I detected no regressions
+via the other tests.
+This code also adds a bit of sanity checking to protect from possible further
+problems.
+
+[ChangeLog][QtNetwork] Fix HTTP(s) upload corruption when server closes connection
+
+Change-Id: I54c883925ec897050941498f139c4b523030432e
+Reviewed-by: Peter Hartmann <peter-qt@hartmann.tk>
+---
+ src/corelib/io/qnoncontiguousbytedevice.cpp        |  18 +++
+ src/corelib/io/qnoncontiguousbytedevice_p.h        |   4 +
+ .../access/qhttpnetworkconnectionchannel.cpp       |  35 ++++-
+ .../access/qhttpnetworkconnectionchannel_p.h       |   2 +
+ src/network/access/qhttpprotocolhandler.cpp        |   7 +
+ src/network/access/qhttpthreaddelegate_p.h         |  36 ++++-
+ src/network/access/qnetworkreplyhttpimpl.cpp       |  25 ++-
+ src/network/access/qnetworkreplyhttpimpl_p.h       |   7 +-
+ .../access/qnetworkreply/tst_qnetworkreply.cpp     | 175 ++++++++++++++++++++-
+ 9 files changed, 279 insertions(+), 30 deletions(-)
+
+diff --git a/src/corelib/io/qnoncontiguousbytedevice.cpp b/src/corelib/io/qnoncontiguousbytedevice.cpp
+index 11510a8..760ca3d 100644
+--- a/src/corelib/io/qnoncontiguousbytedevice.cpp
+++ b/src/corelib/io/qnoncontiguousbytedevice.cpp
+@@ -236,6 +236,11 @@ qint64 QNonContiguousByteDeviceByteArrayImpl::size()
+     return byteArray->size();
+ }
+ 
+qint64 QNonContiguousByteDeviceByteArrayImpl::pos()
+{
+    return currentPosition;
+}
+
+ QNonContiguousByteDeviceRingBufferImpl::QNonContiguousByteDeviceRingBufferImpl(QSharedPointer<QRingBuffer> rb)
+     : QNonContiguousByteDevice(), currentPosition(0)
+ {
+@@ -273,6 +278,11 @@ bool QNonContiguousByteDeviceRingBufferImpl::atEnd()
+     return currentPosition >= size();
+ }
+ 
+qint64 QNonContiguousByteDeviceRingBufferImpl::pos()
+{
+    return currentPosition;
+}
+
+ bool QNonContiguousByteDeviceRingBufferImpl::reset()
+ {
+     if (resetDisabled)
+@@ -406,6 +416,14 @@ qint64 QNonContiguousByteDeviceIoDeviceImpl::size()
+     return device->size() - initialPosition;
+ }
+ 
+qint64 QNonContiguousByteDeviceIoDeviceImpl::pos()
+{
+    if (device->isSequential())
+        return -1;
+
+    return device->pos();
+}
+
+ QByteDeviceWrappingIoDevice::QByteDeviceWrappingIoDevice(QNonContiguousByteDevice *bd) : QIODevice((QObject*)0)
+ {
+     byteDevice = bd;
+diff --git a/src/corelib/io/qnoncontiguousbytedevice_p.h b/src/corelib/io/qnoncontiguousbytedevice_p.h
+index c05ae11..4d7b7b0 100644
+--- a/src/corelib/io/qnoncontiguousbytedevice_p.h
+++ b/src/corelib/io/qnoncontiguousbytedevice_p.h
+@@ -61,6 +61,7 @@ public:
+     virtual const char* readPointer(qint64 maximumLength, qint64 &len) = 0;
+     virtual bool advanceReadPointer(qint64 amount) = 0;
+     virtual bool atEnd() = 0;
+    virtual qint64 pos() { return -1; }
+     virtual bool reset() = 0;
+     void disableReset();
+     bool isResetDisabled() { return resetDisabled; }
+@@ -106,6 +107,7 @@ public:
+     bool atEnd();
+     bool reset();
+     qint64 size();
+    qint64 pos() Q_DECL_OVERRIDE;
+ protected:
+     QByteArray* byteArray;
+     qint64 currentPosition;
+@@ -121,6 +123,7 @@ public:
+     bool atEnd();
+     bool reset();
+     qint64 size();
+    qint64 pos() Q_DECL_OVERRIDE;
+ protected:
+     QSharedPointer<QRingBuffer> ringBuffer;
+     qint64 currentPosition;
+@@ -138,6 +141,7 @@ public:
+     bool atEnd();
+     bool reset();
+     qint64 size();
+    qint64 pos() Q_DECL_OVERRIDE;
+ protected:
+     QIODevice* device;
+     QByteArray* currentReadBuffer;
+diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
+index 9f63280..49c6793 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -106,15 +106,19 @@ void QHttpNetworkConnectionChannel::init()
+     socket->setProxy(QNetworkProxy::NoProxy);
+ #endif
+ 
+    // We want all signals (except the interactive ones) be connected as QueuedConnection
+    // because else we're falling into cases where we recurse back into the socket code
+    // and mess up the state. Always going to the event loop (and expecting that when reading/writing)
+    // is safer.
+     QObject::connect(socket, SIGNAL(bytesWritten(qint64)),
+                      this, SLOT(_q_bytesWritten(qint64)),
+-                     Qt::DirectConnection);
+                     Qt::QueuedConnection);
+     QObject::connect(socket, SIGNAL(connected()),
+                      this, SLOT(_q_connected()),
+-                     Qt::DirectConnection);
+                     Qt::QueuedConnection);
+     QObject::connect(socket, SIGNAL(readyRead()),
+                      this, SLOT(_q_readyRead()),
+-                     Qt::DirectConnection);
+                     Qt::QueuedConnection);
+ 
+     // The disconnected() and error() signals may already come
+     // while calling connectToHost().
+@@ -143,13 +147,13 @@ void QHttpNetworkConnectionChannel::init()
+         // won't be a sslSocket if encrypt is false
+         QObject::connect(sslSocket, SIGNAL(encrypted()),
+                          this, SLOT(_q_encrypted()),
+-                         Qt::DirectConnection);
+                         Qt::QueuedConnection);
+         QObject::connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),
+                          this, SLOT(_q_sslErrors(QList<QSslError>)),
+                          Qt::DirectConnection);
+         QObject::connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)),
+                          this, SLOT(_q_encryptedBytesWritten(qint64)),
+-                         Qt::DirectConnection);
+                         Qt::QueuedConnection);
+ 
+         if (ignoreAllSslErrors)
+             sslSocket->ignoreSslErrors();
+@@ -186,8 +190,11 @@ void QHttpNetworkConnectionChannel::close()
+     // pendingEncrypt must only be true in between connected and encrypted states
+     pendingEncrypt = false;
+ 
+-    if (socket)
+    if (socket) {
+        // socket can be 0 since the host lookup is done from qhttpnetworkconnection.cpp while
+        // there is no socket yet.
+         socket->close();
+    }
+ }
+ 
+ 
+@@ -353,6 +360,14 @@ bool QHttpNetworkConnectionChannel::ensureConnection()
+         }
+         return false;
+     }
+
+    // This code path for ConnectedState
+    if (pendingEncrypt) {
+        // Let's only be really connected when we have received the encrypted() signal. Else the state machine seems to mess up
+        // and corrupt the things sent to the server.
+        return false;
+    }
+
+     return true;
+ }
+ 
+@@ -659,6 +674,12 @@ bool QHttpNetworkConnectionChannel::isSocketReading() const
+ void QHttpNetworkConnectionChannel::_q_bytesWritten(qint64 bytes)
+ {
+     Q_UNUSED(bytes);
+    if (ssl) {
+        // In the SSL case we want to send data from encryptedBytesWritten signal since that one
+        // is the one going down to the actual network, not only into some SSL buffer.
+        return;
+    }
+
+     // bytes have been written to the socket. write even more of them :)
+     if (isSocketWriting())
+         sendRequest();
+@@ -734,7 +755,7 @@ void QHttpNetworkConnectionChannel::_q_connected()
+ 
+     // ### FIXME: if the server closes the connection unexpectedly, we shouldn't send the same broken request again!
+     //channels[i].reconnectAttempts = 2;
+-    if (pendingEncrypt) {
+    if (ssl || pendingEncrypt) { // FIXME: Didn't work properly with pendingEncrypt only, we should refactor this into an EncrypingState
+ #ifndef QT_NO_SSL
+         if (connection->sslContext().isNull()) {
+             // this socket is making the 1st handshake for this connection,
+diff --git a/src/network/access/qhttpnetworkconnectionchannel_p.h b/src/network/access/qhttpnetworkconnectionchannel_p.h
+index 692c0e6..231fe11 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel_p.h
+++ b/src/network/access/qhttpnetworkconnectionchannel_p.h
+@@ -83,6 +83,8 @@ typedef QPair<QHttpNetworkRequest, QHttpNetworkReply*> HttpMessagePair;
+ class QHttpNetworkConnectionChannel : public QObject {
+     Q_OBJECT
+ public:
+    // TODO: Refactor this to add an EncryptingState (and remove pendingEncrypt).
+    // Also add an Unconnected state so IdleState does not have double meaning.
+     enum ChannelState {
+         IdleState = 0,          // ready to send request
+         ConnectingState = 1,    // connecting to host
+diff --git a/src/network/access/qhttpprotocolhandler.cpp b/src/network/access/qhttpprotocolhandler.cpp
+index 28e10f7..3357948 100644
+--- a/src/network/access/qhttpprotocolhandler.cpp
+++ b/src/network/access/qhttpprotocolhandler.cpp
+@@ -368,6 +368,13 @@ bool QHttpProtocolHandler::sendRequest()
+                 // nothing to read currently, break the loop
+                 break;
+             } else {
+                if (m_channel->written != uploadByteDevice->pos()) {
+                    // Sanity check. This was useful in tracking down an upload corruption.
+                    qWarning() << "QHttpProtocolHandler: Internal error in sendRequest. Expected to write at position" << m_channel->written << "but read device is at" << uploadByteDevice->pos();
+                    Q_ASSERT(m_channel->written == uploadByteDevice->pos());
+                    m_connection->d_func()->emitReplyError(m_socket, m_reply, QNetworkReply::ProtocolFailure);
+                    return false;
+                }
+                 qint64 currentWriteSize = m_socket->write(readPointer, currentReadSize);
+                 if (currentWriteSize == -1 || currentWriteSize != currentReadSize) {
+                     // socket broke down
+diff --git a/src/network/access/qhttpthreaddelegate_p.h b/src/network/access/qhttpthreaddelegate_p.h
+index 1661082..b553409 100644
+--- a/src/network/access/qhttpthreaddelegate_p.h
+++ b/src/network/access/qhttpthreaddelegate_p.h
+@@ -187,6 +187,7 @@ protected:
+     QByteArray m_dataArray;
+     bool m_atEnd;
+     qint64 m_size;
+    qint64 m_pos; // to match calls of haveDataSlot with the expected position
+ public:
+     QNonContiguousByteDeviceThreadForwardImpl(bool aE, qint64 s)
+         : QNonContiguousByteDevice(),
+@@ -194,7 +195,8 @@ public:
+           m_amount(0),
+           m_data(0),
+           m_atEnd(aE),
+-          m_size(s)
+          m_size(s),
+          m_pos(0)
+     {
+     }
+ 
+@@ -202,6 +204,11 @@ public:
+     {
+     }
+ 
+    qint64 pos() Q_DECL_OVERRIDE
+    {
+        return m_pos;
+    }
+
+     const char* readPointer(qint64 maximumLength, qint64 &len)
+     {
+         if (m_amount > 0) {
+@@ -229,11 +236,10 @@ public:
+ 
+         m_amount -= a;
+         m_data += a;
+        m_pos += a;
+ 
+-        // To main thread to inform about our state
+-        emit processedData(a);
+-
+-        // FIXME possible optimization, already ask user thread for some data
+        // To main thread to inform about our state. The m_pos will be sent as a sanity check.
+        emit processedData(m_pos, a);
+ 
+         return true;
+     }
+@@ -250,10 +256,21 @@ public:
+     {
+         m_amount = 0;
+         m_data = 0;
+        m_dataArray.clear();
+
+        if (wantDataPending) {
+            // had requested the user thread to send some data (only 1 in-flight at any moment)
+            wantDataPending = false;
+        }
+ 
+         // Communicate as BlockingQueuedConnection
+         bool b = false;
+         emit resetData(&b);
+        if (b) {
+            // the reset succeeded, we're at pos 0 again
+            m_pos = 0;
+            // the HTTP code will anyway abort the request if !b.
+        }
+         return b;
+     }
+ 
+@@ -264,8 +281,13 @@ public:
+ 
+ public slots:
+     // From user thread:
+-    void haveDataSlot(QByteArray dataArray, bool dataAtEnd, qint64 dataSize)
+    void haveDataSlot(qint64 pos, QByteArray dataArray, bool dataAtEnd, qint64 dataSize)
+     {
+        if (pos != m_pos) {
+            // Sometimes when re-sending a request in the qhttpnetwork* layer there is a pending haveData from the
+            // user thread on the way to us. We need to ignore it since it is the data for the wrong(later) chunk.
+            return;
+        }
+         wantDataPending = false;
+ 
+         m_dataArray = dataArray;
+@@ -285,7 +307,7 @@ signals:
+ 
+     // to main thread:
+     void wantData(qint64);
+-    void processedData(qint64);
+    void processedData(qint64 pos, qint64 amount);
+     void resetData(bool *b);
+ };
+ 
+diff --git a/src/network/access/qnetworkreplyhttpimpl.cpp b/src/network/access/qnetworkreplyhttpimpl.cpp
+index 4ce7303..974a101 100644
+--- a/src/network/access/qnetworkreplyhttpimpl.cpp
+++ b/src/network/access/qnetworkreplyhttpimpl.cpp
+@@ -424,6 +424,7 @@ QNetworkReplyHttpImplPrivate::QNetworkReplyHttpImplPrivate()
+     , synchronous(false)
+     , state(Idle)
+     , statusCode(0)
+    , uploadByteDevicePosition(false)
+     , uploadDeviceChoking(false)
+     , outgoingData(0)
+     , bytesUploaded(-1)
+@@ -863,9 +864,9 @@ void QNetworkReplyHttpImplPrivate::postRequest()
+                              q, SLOT(uploadByteDeviceReadyReadSlot()),
+                              Qt::QueuedConnection);
+ 
+-            // From main thread to user thread:
+-            QObject::connect(q, SIGNAL(haveUploadData(QByteArray,bool,qint64)),
+-                             forwardUploadDevice, SLOT(haveDataSlot(QByteArray,bool,qint64)), Qt::QueuedConnection);
+            // From user thread to http thread:
+            QObject::connect(q, SIGNAL(haveUploadData(qint64,QByteArray,bool,qint64)),
+                             forwardUploadDevice, SLOT(haveDataSlot(qint64,QByteArray,bool,qint64)), Qt::QueuedConnection);
+             QObject::connect(uploadByteDevice.data(), SIGNAL(readyRead()),
+                              forwardUploadDevice, SIGNAL(readyRead()),
+                              Qt::QueuedConnection);
+@@ -873,8 +874,8 @@ void QNetworkReplyHttpImplPrivate::postRequest()
+             // From http thread to user thread:
+             QObject::connect(forwardUploadDevice, SIGNAL(wantData(qint64)),
+                              q, SLOT(wantUploadDataSlot(qint64)));
+-            QObject::connect(forwardUploadDevice, SIGNAL(processedData(qint64)),
+-                             q, SLOT(sentUploadDataSlot(qint64)));
+            QObject::connect(forwardUploadDevice,SIGNAL(processedData(qint64, qint64)),
+                             q, SLOT(sentUploadDataSlot(qint64,qint64)));
+             QObject::connect(forwardUploadDevice, SIGNAL(resetData(bool*)),
+                     q, SLOT(resetUploadDataSlot(bool*)),
+                     Qt::BlockingQueuedConnection); // this is the only one with BlockingQueued!
+@@ -1268,12 +1269,22 @@ void QNetworkReplyHttpImplPrivate::replySslConfigurationChanged(const QSslConfig
+ void QNetworkReplyHttpImplPrivate::resetUploadDataSlot(bool *r)
+ {
+     *r = uploadByteDevice->reset();
+    if (*r) {
+        // reset our own position which is used for the inter-thread communication
+        uploadByteDevicePosition = 0;
+    }
+ }
+ 
+ // Coming from QNonContiguousByteDeviceThreadForwardImpl in HTTP thread
+-void QNetworkReplyHttpImplPrivate::sentUploadDataSlot(qint64 amount)
+void QNetworkReplyHttpImplPrivate::sentUploadDataSlot(qint64 pos, qint64 amount)
+ {
+    if (uploadByteDevicePosition + amount != pos) {
+        // Sanity check, should not happen.
+        error(QNetworkReply::UnknownNetworkError, "");
+        return;
+    }
+     uploadByteDevice->advanceReadPointer(amount);
+    uploadByteDevicePosition += amount;
+ }
+ 
+ // Coming from QNonContiguousByteDeviceThreadForwardImpl in HTTP thread
+@@ -1298,7 +1309,7 @@ void QNetworkReplyHttpImplPrivate::wantUploadDataSlot(qint64 maxSize)
+     QByteArray dataArray(data, currentUploadDataLength);
+ 
+     // Communicate back to HTTP thread
+-    emit q->haveUploadData(dataArray, uploadByteDevice->atEnd(), uploadByteDevice->size());
+    emit q->haveUploadData(uploadByteDevicePosition, dataArray, uploadByteDevice->atEnd(), uploadByteDevice->size());
+ }
+ 
+ void QNetworkReplyHttpImplPrivate::uploadByteDeviceReadyReadSlot()
+diff --git a/src/network/access/qnetworkreplyhttpimpl_p.h b/src/network/access/qnetworkreplyhttpimpl_p.h
+index 77d9c5a..1940922 100644
+--- a/src/network/access/qnetworkreplyhttpimpl_p.h
+++ b/src/network/access/qnetworkreplyhttpimpl_p.h
+@@ -120,7 +120,7 @@ public:
+ 
+     Q_PRIVATE_SLOT(d_func(), void resetUploadDataSlot(bool *r))
+     Q_PRIVATE_SLOT(d_func(), void wantUploadDataSlot(qint64))
+-    Q_PRIVATE_SLOT(d_func(), void sentUploadDataSlot(qint64))
+    Q_PRIVATE_SLOT(d_func(), void sentUploadDataSlot(qint64,qint64))
+     Q_PRIVATE_SLOT(d_func(), void uploadByteDeviceReadyReadSlot())
+     Q_PRIVATE_SLOT(d_func(), void emitReplyUploadProgress(qint64, qint64))
+     Q_PRIVATE_SLOT(d_func(), void _q_cacheSaveDeviceAboutToClose())
+@@ -144,7 +144,7 @@ signals:
+ 
+     void startHttpRequestSynchronously();
+ 
+-    void haveUploadData(QByteArray dataArray, bool dataAtEnd, qint64 dataSize);
+    void haveUploadData(const qint64 pos, QByteArray dataArray, bool dataAtEnd, qint64 dataSize);
+ };
+ 
+ class QNetworkReplyHttpImplPrivate: public QNetworkReplyPrivate
+@@ -195,6 +195,7 @@ public:
+     // upload
+     QNonContiguousByteDevice* createUploadByteDevice();
+     QSharedPointer<QNonContiguousByteDevice> uploadByteDevice;
+    qint64 uploadByteDevicePosition;
+     bool uploadDeviceChoking; // if we couldn't readPointer() any data at the moment
+     QIODevice *outgoingData;
+     QSharedPointer<QRingBuffer> outgoingDataBuffer;
+@@ -283,7 +284,7 @@ public:
+     // From QNonContiguousByteDeviceThreadForwardImpl in HTTP thread:
+     void resetUploadDataSlot(bool *r);
+     void wantUploadDataSlot(qint64);
+-    void sentUploadDataSlot(qint64);
+    void sentUploadDataSlot(qint64, qint64);
+ 
+     // From user's QNonContiguousByteDevice
+     void uploadByteDeviceReadyReadSlot();
+diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+index 3ccedf6..d2edf67 100644
+--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+@@ -457,6 +457,10 @@ private Q_SLOTS:
+ 
+     void putWithRateLimiting();
+ 
+#ifndef QT_NO_SSL
+    void putWithServerClosingConnectionImmediately();
+#endif
+
+     // NOTE: This test must be last!
+     void parentingRepliesToTheApp();
+ private:
+@@ -4718,18 +4722,22 @@ void tst_QNetworkReply::ioPostToHttpNoBufferFlag()
+ class SslServer : public QTcpServer {
+     Q_OBJECT
+ public:
+-    SslServer() : socket(0) {};
+    SslServer() : socket(0), m_ssl(true) {}
+     void incomingConnection(qintptr socketDescriptor) {
+         QSslSocket *serverSocket = new QSslSocket;
+         serverSocket->setParent(this);
+ 
+         if (serverSocket->setSocketDescriptor(socketDescriptor)) {
+            connect(serverSocket, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));
+            if (!m_ssl) {
+                emit newPlainConnection(serverSocket);
+                return;
+            }
+             QString testDataDir = QFileInfo(QFINDTESTDATA("rfc3252.txt")).absolutePath();
+             if (testDataDir.isEmpty())
+                 testDataDir = QCoreApplication::applicationDirPath();
+ 
+             connect(serverSocket, SIGNAL(encrypted()), this, SLOT(encryptedSlot()));
+-            connect(serverSocket, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));
+             serverSocket->setProtocol(QSsl::AnyProtocol);
+             connect(serverSocket, SIGNAL(sslErrors(QList<QSslError>)), serverSocket, SLOT(ignoreSslErrors()));
+             serverSocket->setLocalCertificate(testDataDir + "/certs/server.pem");
+@@ -4740,11 +4748,12 @@ public:
+         }
+     }
+ signals:
+-    void newEncryptedConnection();
+    void newEncryptedConnection(QSslSocket *s);
+    void newPlainConnection(QSslSocket *s);
+ public slots:
+     void encryptedSlot() {
+         socket = (QSslSocket*) sender();
+-        emit newEncryptedConnection();
+        emit newEncryptedConnection(socket);
+     }
+     void readyReadSlot() {
+         // for the incoming sockets, not the server socket
+@@ -4753,6 +4762,7 @@ public slots:
+ 
+ public:
+     QSslSocket *socket;
+    bool m_ssl;
+ };
+ 
+ // very similar to ioPostToHttpUploadProgress but for SSL
+@@ -4780,7 +4790,7 @@ void tst_QNetworkReply::ioPostToHttpsUploadProgress()
+     QNetworkReplyPtr reply(manager.post(request, sourceFile));
+ 
+     QSignalSpy spy(reply.data(), SIGNAL(uploadProgress(qint64,qint64)));
+-    connect(&server, SIGNAL(newEncryptedConnection()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    connect(&server, SIGNAL(newEncryptedConnection(QSslSocket*)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+     connect(reply, SIGNAL(sslErrors(QList<QSslError>)), reply.data(), SLOT(ignoreSslErrors()));
+ 
+     // get the request started and the incoming socket connected
+@@ -4788,7 +4798,7 @@ void tst_QNetworkReply::ioPostToHttpsUploadProgress()
+     QVERIFY(!QTestEventLoop::instance().timeout());
+     QTcpSocket *incomingSocket = server.socket;
+     QVERIFY(incomingSocket);
+-    disconnect(&server, SIGNAL(newEncryptedConnection()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    disconnect(&server, SIGNAL(newEncryptedConnection(QSslSocket*)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+ 
+ 
+     incomingSocket->setReadBufferSize(1*1024);
+@@ -7905,6 +7915,159 @@ void tst_QNetworkReply::putWithRateLimiting()
+ }
+ 
+ 
+#ifndef QT_NO_SSL
+
+class PutWithServerClosingConnectionImmediatelyHandler: public QObject
+{
+    Q_OBJECT
+public:
+    bool m_parsedHeaders;
+    QByteArray m_receivedData;
+    QByteArray m_expectedData;
+    QSslSocket *m_socket;
+    PutWithServerClosingConnectionImmediatelyHandler(QSslSocket *s, QByteArray expected) :m_parsedHeaders(false),  m_expectedData(expected), m_socket(s)
+    {
+        m_socket->setParent(this);
+        connect(m_socket, SIGNAL(readyRead()), SLOT(readyReadSlot()));
+        connect(m_socket, SIGNAL(disconnected()), SLOT(disconnectedSlot()));
+    }
+signals:
+    void correctFileUploadReceived();
+    void corruptFileUploadReceived();
+
+public slots:
+    void closeDelayed() {
+        m_socket->close();
+    }
+
+    void readyReadSlot()
+    {
+        QByteArray data = m_socket->readAll();
+        m_receivedData += data;
+        if (!m_parsedHeaders && m_receivedData.contains("\r\n\r\n")) {
+            m_parsedHeaders = true;
+            QTimer::singleShot(qrand()%10, this, SLOT(closeDelayed())); // simulate random network latency
+            // This server simulates a web server connection closing, e.g. because of Apaches MaxKeepAliveRequests or KeepAliveTimeout
+            // In this case QNAM needs to re-send the upload data but it had a bug which then corrupts the upload
+            // This test catches that.
+        }
+
+    }
+    void disconnectedSlot()
+    {
+        if (m_parsedHeaders) {
+            //qDebug() << m_receivedData.left(m_receivedData.indexOf("\r\n\r\n"));
+            m_receivedData = m_receivedData.mid(m_receivedData.indexOf("\r\n\r\n")+4); // check only actual data
+        }
+        if (m_receivedData.length() > 0 && !m_expectedData.startsWith(m_receivedData)) {
+            // We had received some data but it is corrupt!
+            qDebug() << "CORRUPT" << m_receivedData.count();
+
+            // Use this to track down the pattern of the corruption and conclude the source
+//            QFile a("/tmp/corrupt");
+//            a.open(QIODevice::WriteOnly);
+//            a.write(m_receivedData);
+//            a.close();
+
+//            QFile b("/tmp/correct");
+//            b.open(QIODevice::WriteOnly);
+//            b.write(m_expectedData);
+//            b.close();
+            //exit(1);
+            emit corruptFileUploadReceived();
+        } else {
+            emit correctFileUploadReceived();
+        }
+    }
+};
+
+class PutWithServerClosingConnectionImmediatelyServer: public SslServer
+{
+    Q_OBJECT
+public:
+    int m_correctUploads;
+    int m_corruptUploads;
+    int m_repliesFinished;
+    int m_expectedReplies;
+    QByteArray m_expectedData;
+    PutWithServerClosingConnectionImmediatelyServer() : SslServer(), m_correctUploads(0), m_corruptUploads(0), m_repliesFinished(0), m_expectedReplies(0)
+    {
+        QObject::connect(this, SIGNAL(newEncryptedConnection(QSslSocket*)), this, SLOT(createHandlerForConnection(QSslSocket*)));
+        QObject::connect(this, SIGNAL(newPlainConnection(QSslSocket*)), this, SLOT(createHandlerForConnection(QSslSocket*)));
+    }
+
+public slots:
+    void createHandlerForConnection(QSslSocket* s) {
+        PutWithServerClosingConnectionImmediatelyHandler *handler = new PutWithServerClosingConnectionImmediatelyHandler(s, m_expectedData);
+        handler->setParent(this);
+        QObject::connect(handler, SIGNAL(correctFileUploadReceived()), this, SLOT(increaseCorrect()));
+        QObject::connect(handler, SIGNAL(corruptFileUploadReceived()), this, SLOT(increaseCorrupt()));
+    }
+    void increaseCorrect() {
+        m_correctUploads++;
+    }
+    void increaseCorrupt() {
+        m_corruptUploads++;
+    }
+    void replyFinished() {
+        m_repliesFinished++;
+        if (m_repliesFinished == m_expectedReplies) {
+            QTestEventLoop::instance().exitLoop();
+        }
+     }
+};
+
+
+
+void tst_QNetworkReply::putWithServerClosingConnectionImmediately()
+{
+    const int numUploads = 40;
+    qint64 wantedSize = 512*1024; // 512 kB
+    QByteArray sourceFile;
+    for (int i = 0; i < wantedSize; ++i) {
+        sourceFile += (char)'a' +(i%26);
+    }
+    bool withSsl = false;
+
+    for (int s = 0; s <= 1; s++) {
+        withSsl = (s == 1);
+        // Test also needs to run several times because of 9c2ecf89
+        for (int j = 0; j < 20; j++) {
+            // emulate a minimal https server
+            PutWithServerClosingConnectionImmediatelyServer server;
+            server.m_ssl = withSsl;
+            server.m_expectedData = sourceFile;
+            server.m_expectedReplies = numUploads;
+            server.listen(QHostAddress(QHostAddress::LocalHost), 0);
+
+            for (int i = 0; i < numUploads; i++) {
+                // create the request
+                QUrl url = QUrl(QString("http%1://127.0.0.1:%2/file=%3").arg(withSsl ? "s" : "").arg(server.serverPort()).arg(i));
+                QNetworkRequest request(url);
+                QNetworkReply *reply = manager.put(request, sourceFile);
+                connect(reply, SIGNAL(sslErrors(QList<QSslError>)), reply, SLOT(ignoreSslErrors()));
+                connect(reply, SIGNAL(finished()), &server, SLOT(replyFinished()));
+                reply->setParent(&server);
+            }
+
+            // get the request started and the incoming socket connected
+            QTestEventLoop::instance().enterLoop(10);
+
+            //qDebug() << "correct=" << server.m_correctUploads << "corrupt=" << server.m_corruptUploads << "expected=" <<numUploads;
+
+            // Sanity check because ecause of 9c2ecf89 most replies will error out but we want to make sure at least some of them worked
+            QVERIFY(server.m_correctUploads > 5);
+            // Because actually important is that we don't get any corruption:
+            QCOMPARE(server.m_corruptUploads, 0);
+
+            server.close();
+        }
+    }
+
+
+}
+
+#endif
+ 
+ // NOTE: This test must be last testcase in tst_qnetworkreply!
+ void tst_QNetworkReply::parentingRepliesToTheApp()
+-- 
+1.9.1
+
@@ -0,0 +1,434 @@
+From eae0cb09f1310e755c2aff7c1112f7a6c09d7a53 Mon Sep 17 00:00:00 2001
+From: Markus Goetz <markus@woboq.com>
+Date: Fri, 19 Jun 2015 15:35:34 +0200
+Subject: [PATCH] Network: Fix up previous corruption patch
+
+This is a fix-up for cff39fba10ffc10ee4dcfdc66ff6528eb26462d3.
+That patch lead to some internal state issues that lead to the QTBUG-47048
+or to QNetworkReply objects erroring with "Connection Closed" when
+the server closed the Keep-Alive connection.
+
+This patch changes the QNAM socket slot connections to be DirectConnection.
+We don't close the socket anymore in slots where it is anyway in a closed state
+afterwards. This prevents event/stack recursions.
+We also flush QSslSocket/QTcpSocket receive buffers when receiving a disconnect
+so that the developer always gets the full decrypted data from the buffers.
+
+[ChangeLog][QtNetwork] Fix HTTP issues with "Unknown Error" and "Connection Closed"
+[ChangeLog][QtNetwork][Sockets] Read OS/encrypted read buffers when connection
+closed by server.
+
+Change-Id: Ib4d6a2d0d988317e3a5356f36e8dbcee4590beed
+Task-number: QTBUG-47048
+Reviewed-by: Kai Koehne <kai.koehne@theqtcompany.com>
+Reviewed-by: Richard J. Moore <rich@kde.org>
+---
+ src/network/access/qhttpnetworkconnection.cpp      |   1 -
+ .../access/qhttpnetworkconnectionchannel.cpp       | 108 +++++++++++++--------
+ .../access/qhttpnetworkconnectionchannel_p.h       |   1 +
+ src/network/access/qhttpnetworkreply.cpp           |   2 +-
+ src/network/access/qhttpprotocolhandler.cpp        |   1 -
+ src/network/socket/qabstractsocket.cpp             |   7 +-
+ src/network/ssl/qsslsocket.cpp                     |   8 ++
+ src/network/ssl/qsslsocket_openssl.cpp             |   7 ++
+ .../access/qnetworkreply/tst_qnetworkreply.cpp     |   9 +-
+ 9 files changed, 94 insertions(+), 50 deletions(-)
+
+diff --git a/src/network/access/qhttpnetworkconnection.cpp b/src/network/access/qhttpnetworkconnection.cpp
+index 365ce55..543c70e 100644
+--- a/src/network/access/qhttpnetworkconnection.cpp
+++ b/src/network/access/qhttpnetworkconnection.cpp
+@@ -917,7 +917,6 @@ void QHttpNetworkConnectionPrivate::_q_startNextRequest()
+     for (int i = 0; i < channelCount; ++i) {
+         if (channels[i].resendCurrent && (channels[i].state != QHttpNetworkConnectionChannel::ClosingState)) {
+             channels[i].resendCurrent = false;
+-            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
+
+             // if this is not possible, error will be emitted and connection terminated
+             if (!channels[i].resetUploadData())
+diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
+index 49c6793..e2f6307 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -58,6 +58,11 @@ QT_BEGIN_NAMESPACE
+
+ // TODO: Put channel specific stuff here so it does not polute qhttpnetworkconnection.cpp
+
+// Because in-flight when sending a request, the server might close our connection (because the persistent HTTP
+// connection times out)
+// We use 3 because we can get a _q_error 3 times depending on the timing:
+static const int reconnectAttemptsDefault = 3;
+
+ QHttpNetworkConnectionChannel::QHttpNetworkConnectionChannel()
+     : socket(0)
+     , ssl(false)
+@@ -69,7 +74,7 @@ QHttpNetworkConnectionChannel::QHttpNetworkConnectionChannel()
+     , resendCurrent(false)
+     , lastStatus(0)
+     , pendingEncrypt(false)
+-    , reconnectAttempts(2)
+    , reconnectAttempts(reconnectAttemptsDefault)
+     , authMethod(QAuthenticatorPrivate::None)
+     , proxyAuthMethod(QAuthenticatorPrivate::None)
+     , authenticationCredentialsSent(false)
+@@ -106,19 +111,18 @@ void QHttpNetworkConnectionChannel::init()
+     socket->setProxy(QNetworkProxy::NoProxy);
+ #endif
+
+-    // We want all signals (except the interactive ones) be connected as QueuedConnection
+-    // because else we're falling into cases where we recurse back into the socket code
+-    // and mess up the state. Always going to the event loop (and expecting that when reading/writing)
+-    // is safer.
+    // After some back and forth in all the last years, this is now a DirectConnection because otherwise
+    // the state inside the *Socket classes gets messed up, also in conjunction with the socket notifiers
+    // which behave slightly differently on Windows vs Linux
+     QObject::connect(socket, SIGNAL(bytesWritten(qint64)),
+                      this, SLOT(_q_bytesWritten(qint64)),
+-                     Qt::QueuedConnection);
+                     Qt::DirectConnection);
+     QObject::connect(socket, SIGNAL(connected()),
+                      this, SLOT(_q_connected()),
+-                     Qt::QueuedConnection);
+                     Qt::DirectConnection);
+     QObject::connect(socket, SIGNAL(readyRead()),
+                      this, SLOT(_q_readyRead()),
+-                     Qt::QueuedConnection);
+                     Qt::DirectConnection);
+
+     // The disconnected() and error() signals may already come
+     // while calling connectToHost().
+@@ -129,10 +133,10 @@ void QHttpNetworkConnectionChannel::init()
+     qRegisterMetaType<QAbstractSocket::SocketError>();
+     QObject::connect(socket, SIGNAL(disconnected()),
+                      this, SLOT(_q_disconnected()),
+-                     Qt::QueuedConnection);
+                     Qt::DirectConnection);
+     QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+                      this, SLOT(_q_error(QAbstractSocket::SocketError)),
+-                     Qt::QueuedConnection);
+                     Qt::DirectConnection);
+
+
+ #ifndef QT_NO_NETWORKPROXY
+@@ -147,13 +151,13 @@ void QHttpNetworkConnectionChannel::init()
+         // won't be a sslSocket if encrypt is false
+         QObject::connect(sslSocket, SIGNAL(encrypted()),
+                          this, SLOT(_q_encrypted()),
+-                         Qt::QueuedConnection);
+                         Qt::DirectConnection);
+         QObject::connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),
+                          this, SLOT(_q_sslErrors(QList<QSslError>)),
+                          Qt::DirectConnection);
+         QObject::connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)),
+                          this, SLOT(_q_encryptedBytesWritten(qint64)),
+-                         Qt::QueuedConnection);
+                         Qt::DirectConnection);
+
+         if (ignoreAllSslErrors)
+             sslSocket->ignoreSslErrors();
+@@ -397,7 +401,7 @@ void QHttpNetworkConnectionChannel::allDone()
+
+     // reset the reconnection attempts after we receive a complete reply.
+     // in case of failures, each channel will attempt two reconnects before emitting error.
+-    reconnectAttempts = 2;
+    reconnectAttempts = reconnectAttemptsDefault;
+
+     // now the channel can be seen as free/idle again, all signal emissions for the reply have been done
+     if (state != QHttpNetworkConnectionChannel::ClosingState)
+@@ -651,6 +655,15 @@ void QHttpNetworkConnectionChannel::closeAndResendCurrentRequest()
+         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+ }
+
+void QHttpNetworkConnectionChannel::resendCurrentRequest()
+{
+    requeueCurrentlyPipelinedRequests();
+    if (reply)
+        resendCurrent = true;
+    if (qobject_cast<QHttpNetworkConnection*>(connection))
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+}
+
+ bool QHttpNetworkConnectionChannel::isSocketBusy() const
+ {
+     return (state & QHttpNetworkConnectionChannel::BusyState);
+@@ -694,8 +707,8 @@ void QHttpNetworkConnectionChannel::_q_disconnected()
+         return;
+     }
+
+-    // read the available data before closing
+-    if (isSocketWaiting() || isSocketReading()) {
+    // read the available data before closing (also done in _q_error for other codepaths)
+    if ((isSocketWaiting() || isSocketReading()) && socket->bytesAvailable()) {
+         if (reply) {
+             state = QHttpNetworkConnectionChannel::ReadingState;
+             _q_receiveReply();
+@@ -707,7 +720,8 @@ void QHttpNetworkConnectionChannel::_q_disconnected()
+     state = QHttpNetworkConnectionChannel::IdleState;
+
+     requeueCurrentlyPipelinedRequests();
+-    close();
+
+    pendingEncrypt = false;
+ }
+
+
+@@ -789,11 +803,19 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+         errorCode = QNetworkReply::ConnectionRefusedError;
+         break;
+     case QAbstractSocket::RemoteHostClosedError:
+-        // try to reconnect/resend before sending an error.
+-        // while "Reading" the _q_disconnected() will handle this.
+-        if (state != QHttpNetworkConnectionChannel::IdleState && state != QHttpNetworkConnectionChannel::ReadingState) {
+        // This error for SSL comes twice in a row, first from SSL layer ("The TLS/SSL connection has been closed") then from TCP layer.
+        // Depending on timing it can also come three times in a row (first time when we try to write into a closing QSslSocket).
+        // The reconnectAttempts handling catches the cases where we can re-send the request.
+        if (!reply && state == QHttpNetworkConnectionChannel::IdleState) {
+            // Not actually an error, it is normal for Keep-Alive connections to close after some time if no request
+            // is sent on them. No need to error the other replies below. Just bail out here.
+            // The _q_disconnected will handle the possibly pipelined replies
+            return;
+        } else if (state != QHttpNetworkConnectionChannel::IdleState && state != QHttpNetworkConnectionChannel::ReadingState) {
+            // Try to reconnect/resend before sending an error.
+            // While "Reading" the _q_disconnected() will handle this.
+             if (reconnectAttempts-- > 0) {
+-                closeAndResendCurrentRequest();
+                resendCurrentRequest();
+                 return;
+             } else {
+                 errorCode = QNetworkReply::RemoteHostClosedError;
+@@ -818,24 +840,15 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+                 // we can ignore the readbuffersize as the data is already
+                 // in memory and we will not receive more data on the socket.
+                 reply->setReadBufferSize(0);
+                reply->setDownstreamLimited(false);
+                 _q_receiveReply();
+-#ifndef QT_NO_SSL
+-                if (ssl) {
+-                    // QT_NO_OPENSSL. The QSslSocket can still have encrypted bytes in the plainsocket.
+-                    // So we need to check this if the socket is a QSslSocket. When the socket is flushed
+-                    // it will force a decrypt of the encrypted data in the plainsocket.
+-                    QSslSocket *sslSocket = static_cast<QSslSocket*>(socket);
+-                    qint64 beforeFlush = sslSocket->encryptedBytesAvailable();
+-                    while (sslSocket->encryptedBytesAvailable()) {
+-                        sslSocket->flush();
+-                        _q_receiveReply();
+-                        qint64 afterFlush = sslSocket->encryptedBytesAvailable();
+-                        if (afterFlush == beforeFlush)
+-                            break;
+-                        beforeFlush = afterFlush;
+-                    }
+                if (!reply) {
+                    // No more reply assigned after the previous call? Then it had been finished successfully.
+                    requeueCurrentlyPipelinedRequests();
+                    state = QHttpNetworkConnectionChannel::IdleState;
+                    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+                    return;
+                 }
+-#endif
+             }
+
+             errorCode = QNetworkReply::RemoteHostClosedError;
+@@ -846,7 +859,7 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+     case QAbstractSocket::SocketTimeoutError:
+         // try to reconnect/resend before sending an error.
+         if (state == QHttpNetworkConnectionChannel::WritingState && (reconnectAttempts-- > 0)) {
+-            closeAndResendCurrentRequest();
+            resendCurrentRequest();
+             return;
+         }
+         errorCode = QNetworkReply::TimeoutError;
+@@ -860,7 +873,7 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+     case QAbstractSocket::ProxyConnectionClosedError:
+         // try to reconnect/resend before sending an error.
+         if (reconnectAttempts-- > 0) {
+-            closeAndResendCurrentRequest();
+            resendCurrentRequest();
+             return;
+         }
+         errorCode = QNetworkReply::ProxyConnectionClosedError;
+@@ -868,7 +881,7 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+     case QAbstractSocket::ProxyConnectionTimeoutError:
+         // try to reconnect/resend before sending an error.
+         if (reconnectAttempts-- > 0) {
+-            closeAndResendCurrentRequest();
+            resendCurrentRequest();
+             return;
+         }
+         errorCode = QNetworkReply::ProxyTimeoutError;
+@@ -916,8 +929,18 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+     // send the next request
+     QMetaObject::invokeMethod(that, "_q_startNextRequest", Qt::QueuedConnection);
+
+-    if (that) //signal emission triggered event loop
+-        close();
+    if (that) {
+        //signal emission triggered event loop
+        if (!socket)
+            state = QHttpNetworkConnectionChannel::IdleState;
+        else if (socket->state() == QAbstractSocket::UnconnectedState)
+            state = QHttpNetworkConnectionChannel::IdleState;
+        else
+            state = QHttpNetworkConnectionChannel::ClosingState;
+
+        // pendingEncrypt must only be true in between connected and encrypted states
+        pendingEncrypt = false;
+    }
+ }
+
+ #ifndef QT_NO_NETWORKPROXY
+@@ -941,7 +964,8 @@ void QHttpNetworkConnectionChannel::_q_proxyAuthenticationRequired(const QNetwor
+
+ void QHttpNetworkConnectionChannel::_q_uploadDataReadyRead()
+ {
+-    sendRequest();
+    if (reply)
+        sendRequest();
+ }
+
+ #ifndef QT_NO_SSL
+diff --git a/src/network/access/qhttpnetworkconnectionchannel_p.h b/src/network/access/qhttpnetworkconnectionchannel_p.h
+index 231fe11..a834b7d 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel_p.h
+++ b/src/network/access/qhttpnetworkconnectionchannel_p.h
+@@ -169,6 +169,7 @@ public:
+
+     void handleUnexpectedEOF();
+     void closeAndResendCurrentRequest();
+    void resendCurrentRequest();
+
+     bool isSocketBusy() const;
+     bool isSocketWriting() const;
+diff --git a/src/network/access/qhttpnetworkreply.cpp b/src/network/access/qhttpnetworkreply.cpp
+index 55863a3..8b71bd8 100644
+--- a/src/network/access/qhttpnetworkreply.cpp
+++ b/src/network/access/qhttpnetworkreply.cpp
+@@ -191,7 +191,7 @@ QByteArray QHttpNetworkReply::readAny()
+         return QByteArray();
+
+     // we'll take the last buffer, so schedule another read from http
+-    if (d->downstreamLimited && d->responseData.bufferCount() == 1)
+    if (d->downstreamLimited && d->responseData.bufferCount() == 1 && !isFinished())
+         d->connection->d_func()->readMoreLater(this);
+     return d->responseData.read();
+ }
+diff --git a/src/network/access/qhttpprotocolhandler.cpp b/src/network/access/qhttpprotocolhandler.cpp
+index 3357948..380aaac 100644
+--- a/src/network/access/qhttpprotocolhandler.cpp
+++ b/src/network/access/qhttpprotocolhandler.cpp
+@@ -250,7 +250,6 @@ bool QHttpProtocolHandler::sendRequest()
+     if (!m_reply) {
+         // heh, how should that happen!
+         qWarning() << "QAbstractProtocolHandler::sendRequest() called without QHttpNetworkReply";
+-        m_channel->state = QHttpNetworkConnectionChannel::IdleState;
+         return false;
+     }
+
+diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
+index 2666771..0e82d4a 100644
+--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
+@@ -768,6 +768,7 @@ bool QAbstractSocketPrivate::canReadNotification()
+ void QAbstractSocketPrivate::canCloseNotification()
+ {
+     Q_Q(QAbstractSocket);
+    // Note that this method is only called on Windows. Other platforms close in the canReadNotification()
+
+ #if defined (QABSTRACTSOCKET_DEBUG)
+     qDebug("QAbstractSocketPrivate::canCloseNotification()");
+@@ -777,7 +778,11 @@ void QAbstractSocketPrivate::canCloseNotification()
+     if (isBuffered) {
+         // Try to read to the buffer, if the read fail we can close the socket.
+         newBytes = buffer.size();
+-        if (!readFromSocket()) {
+        qint64 oldReadBufferMaxSize = readBufferMaxSize;
+        readBufferMaxSize = 0; // temporarily disable max read buffer, we want to empty the OS buffer
+        bool hadReadFromSocket = readFromSocket();
+        readBufferMaxSize = oldReadBufferMaxSize;
+        if (!hadReadFromSocket) {
+             q->disconnectFromHost();
+             return;
+         }
+diff --git a/src/network/ssl/qsslsocket.cpp b/src/network/ssl/qsslsocket.cpp
+index c1fab94..2b9e923 100644
+--- a/src/network/ssl/qsslsocket.cpp
+++ b/src/network/ssl/qsslsocket.cpp
+@@ -2294,6 +2294,14 @@ void QSslSocketPrivate::_q_errorSlot(QAbstractSocket::SocketError error)
+     qCDebug(lcSsl) << "\tstate =" << q->state();
+     qCDebug(lcSsl) << "\terrorString =" << q->errorString();
+ #endif
+    // this moves encrypted bytes from plain socket into our buffer
+    if (plainSocket->bytesAvailable()) {
+        qint64 tmpReadBufferMaxSize = readBufferMaxSize;
+        readBufferMaxSize = 0; // reset temporarily so the plain sockets completely drained drained
+        transmit();
+        readBufferMaxSize = tmpReadBufferMaxSize;
+    }
+
+     q->setSocketError(plainSocket->error());
+     q->setErrorString(plainSocket->errorString());
+     emit q->error(error);
+diff --git a/src/network/ssl/qsslsocket_openssl.cpp b/src/network/ssl/qsslsocket_openssl.cpp
+index ac4336a..94655fe 100644
+--- a/src/network/ssl/qsslsocket_openssl.cpp
+++ b/src/network/ssl/qsslsocket_openssl.cpp
+@@ -1419,6 +1419,13 @@ void QSslSocketBackendPrivate::disconnected()
+ {
+     if (plainSocket->bytesAvailable() <= 0)
+         destroySslContext();
+    else {
+        // Move all bytes into the plain buffer
+        qint64 tmpReadBufferMaxSize = readBufferMaxSize;
+        readBufferMaxSize = 0; // reset temporarily so the plain socket buffer is completely drained
+        transmit();
+        readBufferMaxSize = tmpReadBufferMaxSize;
+    }
+     //if there is still buffered data in the plain socket, don't destroy the ssl context yet.
+     //it will be destroyed when the socket is deleted.
+ }
+diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+index d2edf67..138f528 100644
+--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+@@ -1051,7 +1051,7 @@ protected:
+         // clean up QAbstractSocket's residue:
+         while (client->bytesToWrite() > 0) {
+             qDebug() << "Still having" << client->bytesToWrite() << "bytes to write, doing that now";
+-            if (!client->waitForBytesWritten(2000)) {
+            if (!client->waitForBytesWritten(10000)) {
+                 qDebug() << "ERROR: FastSender:" << client->error() << "cleaning up residue";
+                 return;
+             }
+@@ -1071,7 +1071,7 @@ protected:
+             measuredSentBytes += writeNextData(client, bytesToWrite);
+
+             while (client->bytesToWrite() > 0) {
+-                if (!client->waitForBytesWritten(2000)) {
+                if (!client->waitForBytesWritten(10000)) {
+                     qDebug() << "ERROR: FastSender:" << client->error() << "during blocking write";
+                     return;
+                 }
+@@ -7946,7 +7946,7 @@ public slots:
+         m_receivedData += data;
+         if (!m_parsedHeaders && m_receivedData.contains("\r\n\r\n")) {
+             m_parsedHeaders = true;
+-            QTimer::singleShot(qrand()%10, this, SLOT(closeDelayed())); // simulate random network latency
+            QTimer::singleShot(qrand()%60, this, SLOT(closeDelayed())); // simulate random network latency
+             // This server simulates a web server connection closing, e.g. because of Apaches MaxKeepAliveRequests or KeepAliveTimeout
+             // In this case QNAM needs to re-send the upload data but it had a bug which then corrupts the upload
+             // This test catches that.
+@@ -8052,11 +8052,12 @@ void tst_QNetworkReply::putWithServerClosingConnectionImmediately()
+
+             // get the request started and the incoming socket connected
+             QTestEventLoop::instance().enterLoop(10);
+            QVERIFY(!QTestEventLoop::instance().timeout());
+
+             //qDebug() << "correct=" << server.m_correctUploads << "corrupt=" << server.m_corruptUploads << "expected=" <<numUploads;
+
+             // Sanity check because ecause of 9c2ecf89 most replies will error out but we want to make sure at least some of them worked
+-            QVERIFY(server.m_correctUploads > 5);
+            QVERIFY(server.m_correctUploads > 2);
+             // Because actually important is that we don't get any corruption:
+             QCOMPARE(server.m_corruptUploads, 0);
+
+--
+1.9.1
@@ -0,0 +1,64 @@
+From bc32c0ebc0bc00db84ca2f28eb16ab2e5b53a1b6 Mon Sep 17 00:00:00 2001
+From: Markus Goetz <markus@woboq.com>
+Date: Fri, 24 Jul 2015 09:53:20 +0200
+Subject: [PATCH] QNAM: Fix reply deadlocks on server closing connection
+
+The _q_readyRead can also be called from readMoreLater() because we implemented
+it so that bandwidth limited reading can be implemented.
+This can lead to a race condition if the socket is closing at the specific moment
+and then deadlock the channel: It will stay unusable with a zombie request.
+The fix in QHttpProtocolaHandler checks if there is actually bytes available to read
+from the socket and only then continue.
+
+The fix in the HTTP channel needs to be done to properly finish the reply in
+cases of a server replying with HTTP/1.0 or "Connection: close".
+The delayed incovation of _q_receiveReply will properly finish up the reply.
+
+Change-Id: I19ce2ae595f91d56386cc7406ccacc9935672b6b
+Reviewed-by: Richard J. Moore <rich@kde.org>
+---
+ src/network/access/qhttpnetworkconnectionchannel.cpp | 4 ++++
+ src/network/access/qhttpprotocolhandler.cpp          | 7 ++++++-
+ 2 files changed, 10 insertions(+), 1 deletion(-)
+
+diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
+index 7428f9b..257aa13 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -829,11 +829,15 @@ void QHttpNetworkConnectionChannel::_q_error(QAbstractSocket::SocketError socket
+ 
+             if (!reply->d_func()->expectContent()) {
+                 // No content expected, this is a valid way to have the connection closed by the server
+                // We need to invoke this asynchronously to make sure the state() of the socket is on QAbstractSocket::UnconnectedState
+                QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
+                 return;
+             }
+             if (reply->contentLength() == -1 && !reply->d_func()->isChunked()) {
+                 // There was no content-length header and it's not chunked encoding,
+                 // so this is a valid way to have the connection closed by the server
+                // We need to invoke this asynchronously to make sure the state() of the socket is on QAbstractSocket::UnconnectedState
+                QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
+                 return;
+             }
+             // ok, we got a disconnect even though we did not expect it
+diff --git a/src/network/access/qhttpprotocolhandler.cpp b/src/network/access/qhttpprotocolhandler.cpp
+index ab2e3da..a208315 100644
+--- a/src/network/access/qhttpprotocolhandler.cpp
+++ b/src/network/access/qhttpprotocolhandler.cpp
+@@ -237,7 +237,12 @@ void QHttpProtocolHandler::_q_readyRead()
+     }
+ 
+     if (m_channel->isSocketWaiting() || m_channel->isSocketReading()) {
+-        m_channel->state = QHttpNetworkConnectionChannel::ReadingState;
+        if (m_socket->bytesAvailable()) {
+            // We might get a spurious call from readMoreLater()
+            // call of the QHttpNetworkConnection even while the socket is disconnecting.
+            // Therefore check if there is actually bytes available before changing the channel state.
+            m_channel->state = QHttpNetworkConnectionChannel::ReadingState;
+        }
+         if (m_reply)
+             _q_receiveReply();
+     }
+-- 
+1.9.1
+
@@ -0,0 +1,33 @@
+From 63cf5d3d26a6f65938c3cdec1734eac9faaaf8cb Mon Sep 17 00:00:00 2001
+From: Markus Goetz <markus@woboq.com>
+Date: Tue, 22 Sep 2015 14:26:24 -0400
+Subject: [PATCH] QNAM: Assign proper channel before sslErrors() emission
+
+There can be a race condition where another channel connects
+and gets the sslErrors() from the socket first. Then the
+QSslConfiguration from the wrong socket (the default
+channel 0's socket) was used.
+
+Task-number: QTBUG-18722
+Change-Id: Ibbfa48c27f181563745daf540fa792a57cc09682
+Reviewed-by: Richard J. Moore <rich@kde.org>
+---
+ src/network/access/qhttpnetworkconnectionchannel.cpp | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
+index 257aa13..477cba2 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -1066,6 +1066,8 @@ void QHttpNetworkConnectionChannel::_q_sslErrors(const QList<QSslError> &errors)
+     connection->d_func()->pauseConnection();
+     if (pendingEncrypt && !reply)
+         connection->d_func()->dequeueRequest(socket);
+    if (reply) // a reply was actually dequeued.
+        reply->d_func()->connectionChannel = this; // set correct channel like in sendRequest() and queueRequest();
+     if (connection->connectionType() == QHttpNetworkConnection::ConnectionTypeHTTP) {
+         if (reply)
+             emit reply->sslErrors(errors);
+-- 
+1.9.1
+
@@ -0,0 +1,121 @@
+From 0df5d079290b4c3b13e58e9397fabdc1dfdba96b Mon Sep 17 00:00:00 2001
+From: Ulf Hermann <ulf.hermann@theqtcompany.com>
+Date: Fri, 25 Sep 2015 13:23:46 +0200
+Subject: [PATCH] Don't let closed http sockets pass as valid connections
+
+A QAbstractSocket can be close()'d at any time, independently of its
+current connection state. being closed means that we cannot use it to
+read or write data, but internally it might still have some data to
+send or receive, for example to an http server. We can even get a
+connected() signal after close()'ing the socket.
+
+We need to catch this condition and mark any pending data not yet
+written to the socket for resending.
+
+Task-number: QTBUG-48326
+Change-Id: I6f61c35f2c567f2a138f8cfe9ade7fd1ec039be6
+Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>
+---
+ .../access/qhttpnetworkconnectionchannel.cpp       |  7 ++-
+ .../tst_qhttpnetworkconnection.cpp                 | 54 ++++++++++++++++++++++
+ 2 files changed, 60 insertions(+), 1 deletion(-)
+
+diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
+index 293909c..b4eda34 100644
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -272,7 +272,12 @@ bool QHttpNetworkConnectionChannel::ensureConnection()
+     QAbstractSocket::SocketState socketState = socket->state();
+
+     // resend this request after we receive the disconnected signal
+-    if (socketState == QAbstractSocket::ClosingState) {
+    // If !socket->isOpen() then we have already called close() on the socket, but there was still a
+    // pending connectToHost() for which we hadn't seen a connected() signal, yet. The connected()
+    // has now arrived (as indicated by socketState != ClosingState), but we cannot send anything on
+    // such a socket anymore.
+    if (socketState == QAbstractSocket::ClosingState ||
+            (socketState != QAbstractSocket::UnconnectedState && !socket->isOpen())) {
+         if (reply)
+             resendCurrent = true;
+         return false;
+diff --git a/tests/auto/network/access/qhttpnetworkconnection/tst_qhttpnetworkconnection.cpp b/tests/auto/network/access/qhttpnetworkconnection/tst_qhttpnetworkconnection.cpp
+index 5d072af..0d188a8 100644
+--- a/tests/auto/network/access/qhttpnetworkconnection/tst_qhttpnetworkconnection.cpp
+++ b/tests/auto/network/access/qhttpnetworkconnection/tst_qhttpnetworkconnection.cpp
+@@ -36,6 +36,7 @@
+ #include "private/qhttpnetworkconnection_p.h"
+ #include "private/qnoncontiguousbytedevice_p.h"
+ #include <QAuthenticator>
+#include <QTcpServer>
+
+ #include "../../../network-settings.h"
+
+@@ -106,6 +107,8 @@ private Q_SLOTS:
+
+     void getAndThenDeleteObject();
+     void getAndThenDeleteObject_data();
+
+    void overlappingCloseAndWrite();
+ };
+
+ tst_QHttpNetworkConnection::tst_QHttpNetworkConnection()
+@@ -1112,6 +1115,57 @@ void tst_QHttpNetworkConnection::getAndThenDeleteObject()
+     }
+ }
+
+class TestTcpServer : public QTcpServer
+{
+    Q_OBJECT
+public:
+    TestTcpServer() : errorCodeReports(0)
+    {
+        connect(this, &QTcpServer::newConnection, this, &TestTcpServer::onNewConnection);
+        QVERIFY(listen(QHostAddress::LocalHost));
+    }
+
+    int errorCodeReports;
+
+public slots:
+    void onNewConnection()
+    {
+        QTcpSocket *socket = nextPendingConnection();
+        if (!socket)
+            return;
+        // close socket instantly!
+        connect(socket, &QTcpSocket::readyRead, socket, &QTcpSocket::close);
+    }
+
+    void onReply(QNetworkReply::NetworkError code)
+    {
+        QCOMPARE(code, QNetworkReply::RemoteHostClosedError);
+        ++errorCodeReports;
+    }
+};
+
+void tst_QHttpNetworkConnection::overlappingCloseAndWrite()
+{
+    // server accepts connections, but closes the socket instantly
+    TestTcpServer server;
+    QNetworkAccessManager accessManager;
+
+    // ten requests are scheduled. All should result in an RemoteHostClosed...
+    QUrl url;
+    url.setScheme(QStringLiteral("http"));
+    url.setHost(server.serverAddress().toString());
+    url.setPort(server.serverPort());
+    for (int i = 0; i < 10; ++i) {
+        QNetworkRequest request(url);
+        QNetworkReply *reply = accessManager.get(request);
+        // Not using Qt5 connection syntax here because of overly baroque syntax to discern between
+        // different error() methods.
+        QObject::connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+                         &server, SLOT(onReply(QNetworkReply::NetworkError)));
+    }
+
+    QTRY_COMPARE(server.errorCodeReports, 10);
+}
+
+
+ QTEST_MAIN(tst_QHttpNetworkConnection)
+--
+1.9.1
@@ -0,0 +1,113 @@
+From c056e63cea1915667997c982f48296ce5acdcc80 Mon Sep 17 00:00:00 2001
+From: Lorn Potter <lorn.potter@gmail.com>
+Date: Tue, 2 Jun 2015 13:22:23 +1000
+Subject: [PATCH] Make sure to report correct NetworkAccessibility
+
+Task-number: QTBUG-46323
+Change-Id: Ibdeb3280091a97d785d4314340678a63e88fb219
+Reviewed-by: Markus Goetz (Woboq GmbH) <markus@woboq.com>
+Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>
+---
+ src/network/access/qnetworkaccessmanager.cpp | 25 +++++++++++++++++--------
+ src/network/access/qnetworkaccessmanager_p.h |  2 ++
+ 2 files changed, 19 insertions(+), 8 deletions(-)
+
+diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
+index e878feb..84931cb 100644
+--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
+@@ -472,11 +472,11 @@ QNetworkAccessManager::QNetworkAccessManager(QObject *parent)
+         // the QNetworkSession's signals
+         connect(&d->networkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
+                 SLOT(_q_onlineStateChanged(bool)));
+-        // we would need all active configurations to check for
+-        // d->networkConfigurationManager.isOnline(), which is asynchronous
+-        // and potentially expensive. We can just check the configuration here
+-        d->online = (d->networkConfiguration.state() & QNetworkConfiguration::Active);
+     }
+    // we would need all active configurations to check for
+    // d->networkConfigurationManager.isOnline(), which is asynchronous
+    // and potentially expensive. We can just check the configuration here
+    d->online = (d->networkConfiguration.state() & QNetworkConfiguration::Active);
+ #endif
+ }
+ 
+@@ -946,6 +946,7 @@ QNetworkConfiguration QNetworkAccessManager::activeConfiguration() const
+ void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkAccessibility accessible)
+ {
+     Q_D(QNetworkAccessManager);
+    d->defaultAccessControl = false;
+ 
+     if (d->networkAccessible != accessible) {
+         NetworkAccessibility previous = networkAccessible();
+@@ -964,7 +965,6 @@ void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkA
+ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccessible() const
+ {
+     Q_D(const QNetworkAccessManager);
+-
+     if (d->networkSessionRequired) {
+         QSharedPointer<QNetworkSession> networkSession(d->getNetworkSession());
+         if (networkSession) {
+@@ -975,7 +975,13 @@ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccess
+                 return NotAccessible;
+         } else {
+             // Network accessibility is either disabled or unknown.
+-            return (d->networkAccessible == NotAccessible) ? NotAccessible : UnknownAccessibility;
+            if (d->defaultAccessControl) {
+                if (d->online)
+                    return d->networkAccessible;
+                else
+                    return NotAccessible;
+            }
+            return (d->networkAccessible);
+         }
+     } else {
+         if (d->online)
+@@ -1568,7 +1574,7 @@ void QNetworkAccessManagerPrivate::createSession(const QNetworkConfiguration &co
+     if (!networkSessionStrongRef) {
+         online = false;
+ 
+-        if (networkAccessible == QNetworkAccessManager::NotAccessible)
+        if (networkAccessible == QNetworkAccessManager::NotAccessible || !online)
+             emit q->networkAccessibleChanged(QNetworkAccessManager::NotAccessible);
+         else
+             emit q->networkAccessibleChanged(QNetworkAccessManager::UnknownAccessibility);
+@@ -1616,11 +1622,14 @@ void QNetworkAccessManagerPrivate::_q_networkSessionStateChanged(QNetworkSession
+     if (online) {
+         if (state != QNetworkSession::Connected && state != QNetworkSession::Roaming) {
+             online = false;
+-            emit q->networkAccessibleChanged(QNetworkAccessManager::NotAccessible);
+            networkAccessible = QNetworkAccessManager::NotAccessible;
+            emit q->networkAccessibleChanged(networkAccessible);
+         }
+     } else {
+         if (state == QNetworkSession::Connected || state == QNetworkSession::Roaming) {
+             online = true;
+            if (defaultAccessControl)
+                networkAccessible = QNetworkAccessManager::Accessible;
+             emit q->networkAccessibleChanged(networkAccessible);
+         }
+     }
+diff --git a/src/network/access/qnetworkaccessmanager_p.h b/src/network/access/qnetworkaccessmanager_p.h
+index f513324..c715da0 100644
+--- a/src/network/access/qnetworkaccessmanager_p.h
+++ b/src/network/access/qnetworkaccessmanager_p.h
+@@ -84,6 +84,7 @@ public:
+           initializeSession(true),
+ #endif
+           cookieJarCreated(false),
+          defaultAccessControl(true),
+           authenticationManager(QSharedPointer<QNetworkAccessAuthenticationManager>::create())
+     { }
+     ~QNetworkAccessManagerPrivate();
+@@ -164,6 +165,7 @@ public:
+ #endif
+ 
+     bool cookieJarCreated;
+    bool defaultAccessControl;
+ 
+     // The cache with authorization data:
+     QSharedPointer<QNetworkAccessAuthenticationManager> authenticationManager;
+-- 
+1.9.1
+
@@ -0,0 +1,233 @@
+From bb281eea179d50a413f4ec1ff172d27ee48d3a41 Mon Sep 17 00:00:00 2001
+From: Lorn Potter <lorn.potter@gmail.com>
+Date: Fri, 17 Jul 2015 15:32:23 +1000
+Subject: [PATCH] Make sure networkAccessibilityChanged is emitted
+
+Task-number: QTBUG-46323
+Change-Id: I8297072b62763136f457ca6ae15282d1c22244f4
+Reviewed-by: Timo Jyrinki <timo.jyrinki@canonical.com>
+Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>
+---
+ src/network/access/qnetworkaccessmanager.cpp       | 70 +++++++++++++++-------
+ src/network/access/qnetworkaccessmanager_p.h       | 14 ++++-
+ .../tst_qnetworkaccessmanager.cpp                  | 31 +++++-----
+ 3 files changed, 77 insertions(+), 38 deletions(-)
+
+diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
+index 84931cb..f9e9513 100644
+--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
+@@ -278,7 +278,8 @@ static void ensureInitialized()
+ 
+     \snippet code/src_network_access_qnetworkaccessmanager.cpp 4
+ 
+-    Network requests can be reenabled again by calling
+    Network requests can be re-enabled again, and this property will resume to
+    reflect the actual device state by calling
+ 
+     \snippet code/src_network_access_qnetworkaccessmanager.cpp 5
+ 
+@@ -467,16 +468,12 @@ QNetworkAccessManager::QNetworkAccessManager(QObject *parent)
+     qRegisterMetaType<QSharedPointer<char> >();
+ 
+ #ifndef QT_NO_BEARERMANAGEMENT
+-    if (!d->networkSessionRequired) {
+-        // if a session is required, we track online state through
+-        // the QNetworkSession's signals
+-        connect(&d->networkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
+-                SLOT(_q_onlineStateChanged(bool)));
+-    }
+-    // we would need all active configurations to check for
+-    // d->networkConfigurationManager.isOnline(), which is asynchronous
+-    // and potentially expensive. We can just check the configuration here
+-    d->online = (d->networkConfiguration.state() & QNetworkConfiguration::Active);
+    // if a session is required, we track online state through
+    // the QNetworkSession's signals if a request is already made.
+    // we need to track current accessibility state by default
+    //
+    connect(&d->networkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
+            SLOT(_q_onlineStateChanged(bool)));
+ #endif
+ }
+ 
+@@ -946,7 +943,8 @@ QNetworkConfiguration QNetworkAccessManager::activeConfiguration() const
+ void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkAccessibility accessible)
+ {
+     Q_D(QNetworkAccessManager);
+-    d->defaultAccessControl = false;
+
+    d->defaultAccessControl = accessible == NotAccessible ? false : true;
+ 
+     if (d->networkAccessible != accessible) {
+         NetworkAccessibility previous = networkAccessible();
+@@ -965,6 +963,10 @@ void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkA
+ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccessible() const
+ {
+     Q_D(const QNetworkAccessManager);
+
+    if (d->networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined))
+        return UnknownAccessibility;
+
+     if (d->networkSessionRequired) {
+         QSharedPointer<QNetworkSession> networkSession(d->getNetworkSession());
+         if (networkSession) {
+@@ -1622,32 +1624,56 @@ void QNetworkAccessManagerPrivate::_q_networkSessionStateChanged(QNetworkSession
+     if (online) {
+         if (state != QNetworkSession::Connected && state != QNetworkSession::Roaming) {
+             online = false;
+-            networkAccessible = QNetworkAccessManager::NotAccessible;
+-            emit q->networkAccessibleChanged(networkAccessible);
+            if (networkAccessible != QNetworkAccessManager::NotAccessible) {
+                networkAccessible = QNetworkAccessManager::NotAccessible;
+                emit q->networkAccessibleChanged(networkAccessible);
+            }
+         }
+     } else {
+         if (state == QNetworkSession::Connected || state == QNetworkSession::Roaming) {
+             online = true;
+             if (defaultAccessControl)
+-                networkAccessible = QNetworkAccessManager::Accessible;
+-            emit q->networkAccessibleChanged(networkAccessible);
+                if (networkAccessible != QNetworkAccessManager::Accessible) {
+                    networkAccessible = QNetworkAccessManager::Accessible;
+                    emit q->networkAccessibleChanged(networkAccessible);
+                }
+         }
+     }
+ }
+ 
+ void QNetworkAccessManagerPrivate::_q_onlineStateChanged(bool isOnline)
+ {
+-    // if the user set a config, we only care whether this one is active.
+   Q_Q(QNetworkAccessManager);
+   // if the user set a config, we only care whether this one is active.
+     // Otherwise, this QNAM is online if there is an online config.
+     if (customNetworkConfiguration) {
+         online = (networkConfiguration.state() & QNetworkConfiguration::Active);
+     } else {
+-        if (isOnline && online != isOnline) {
+-            networkSessionStrongRef.clear();
+-            networkSessionWeakRef.clear();
+        if (online != isOnline) {
+            if (isOnline) {
+                networkSessionStrongRef.clear();
+                networkSessionWeakRef.clear();
+            }
+            online = isOnline;
+        }
+    }
+    if (online) {
+        if (defaultAccessControl) {
+            if (networkAccessible != QNetworkAccessManager::Accessible) {
+                networkAccessible = QNetworkAccessManager::Accessible;
+                emit q->networkAccessibleChanged(networkAccessible);
+            }
+        }
+    } else if (networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined)) {
+        if (networkAccessible != QNetworkAccessManager::UnknownAccessibility) {
+            networkAccessible = QNetworkAccessManager::UnknownAccessibility;
+            emit q->networkAccessibleChanged(networkAccessible);
+        }
+    } else {
+        if (networkAccessible != QNetworkAccessManager::NotAccessible) {
+            networkAccessible = QNetworkAccessManager::NotAccessible;
+            emit q->networkAccessibleChanged(networkAccessible);
+         }
+-
+-        online = isOnline;
+     }
+ }
+ 
+diff --git a/src/network/access/qnetworkaccessmanager_p.h b/src/network/access/qnetworkaccessmanager_p.h
+index c715da0..54ae114 100644
+--- a/src/network/access/qnetworkaccessmanager_p.h
+++ b/src/network/access/qnetworkaccessmanager_p.h
+@@ -78,7 +78,6 @@ public:
+           customNetworkConfiguration(false),
+           networkSessionRequired(networkConfigurationManager.capabilities()
+                                  & QNetworkConfigurationManager::NetworkSessionRequired),
+-          networkAccessible(QNetworkAccessManager::Accessible),
+           activeReplyCount(0),
+           online(false),
+           initializeSession(true),
+@@ -86,7 +85,18 @@ public:
+           cookieJarCreated(false),
+           defaultAccessControl(true),
+           authenticationManager(QSharedPointer<QNetworkAccessAuthenticationManager>::create())
+-    { }
+    {
+#ifndef QT_NO_BEARERMANAGEMENT
+        // we would need all active configurations to check for
+        // d->networkConfigurationManager.isOnline(), which is asynchronous
+        // and potentially expensive. We can just check the configuration here
+        online = (networkConfiguration.state().testFlag(QNetworkConfiguration::Active));
+        if (online)
+            networkAccessible = QNetworkAccessManager::Accessible;
+        else
+            networkAccessible = QNetworkAccessManager::NotAccessible;
+#endif
+    }
+     ~QNetworkAccessManagerPrivate();
+ 
+     void _q_replyFinished();
+diff --git a/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp b/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
+index b4e4b9c..8ecb57d 100644
+--- a/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
+++ b/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
+@@ -74,6 +74,10 @@ void tst_QNetworkAccessManager::networkAccessible()
+     // if there is no session, we cannot know in which state we are in
+     QNetworkAccessManager::NetworkAccessibility initialAccessibility =
+             manager.networkAccessible();
+
+    if (initialAccessibility == QNetworkAccessManager::UnknownAccessibility)
+          QSKIP("Unknown accessibility", SkipAll);
+
+     QCOMPARE(manager.networkAccessible(), initialAccessibility);
+ 
+     manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+@@ -94,29 +98,28 @@ void tst_QNetworkAccessManager::networkAccessible()
+     QCOMPARE(manager.networkAccessible(), initialAccessibility);
+ 
+     QNetworkConfigurationManager configManager;
+-    bool sessionRequired = (configManager.capabilities()
+-                            & QNetworkConfigurationManager::NetworkSessionRequired);
+     QNetworkConfiguration defaultConfig = configManager.defaultConfiguration();
+     if (defaultConfig.isValid()) {
+         manager.setConfiguration(defaultConfig);
+ 
+-        // the accessibility has not changed if no session is required
+-        if (sessionRequired) {
+        QCOMPARE(spy.count(), 0);
+
+        if (defaultConfig.state().testFlag(QNetworkConfiguration::Active))
+            QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::Accessible);
+        else
+            QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
+
+        manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+
+        if (defaultConfig.state().testFlag(QNetworkConfiguration::Active)) {
+             QCOMPARE(spy.count(), 1);
+-            QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
+-                     QNetworkAccessManager::Accessible);
+            QCOMPARE(QNetworkAccessManager::NetworkAccessibility(spy.takeFirst().at(0).toInt()),
+                     QNetworkAccessManager::NotAccessible);
+         } else {
+             QCOMPARE(spy.count(), 0);
+         }
+-        QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::Accessible);
+-
+-        manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+-
+-        QCOMPARE(spy.count(), 1);
+-        QCOMPARE(QNetworkAccessManager::NetworkAccessibility(spy.takeFirst().at(0).toInt()),
+-                 QNetworkAccessManager::NotAccessible);
+-        QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
+     }
+    QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
+ #endif
+ }
+ 
+-- 
+1.9.1
+
@@ -0,0 +1,52 @@
+From e996d68f6130847637ba287518cff1289cfa48e5 Mon Sep 17 00:00:00 2001
+From: Lorn Potter <lorn.potter@gmail.com>
+Date: Fri, 6 Nov 2015 14:22:44 +1000
+Subject: [PATCH] Make UnknownAccessibility not block requests
+
+This allows requests to proceed without needing bearer plugins.
+
+Task-number: QTBUG-49267
+Change-Id: Ie5ce188ddefebd14d666bb5846e8f93ee2925ed1
+Reviewed-by: Markus Goetz (Woboq GmbH) <markus@woboq.com>
+---
+ src/network/access/qnetworkaccessmanager.cpp | 3 +--
+ src/network/access/qnetworkaccessmanager_p.h | 2 ++
+ 2 files changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
+index 086140f..0e5870a 100644
+--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
+@@ -976,7 +976,6 @@ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccess
+             else
+                 return NotAccessible;
+         } else {
+-            // Network accessibility is either disabled or unknown.
+             if (d->defaultAccessControl) {
+                 if (d->online)
+                     return d->networkAccessible;
+@@ -1161,7 +1160,7 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
+ #ifndef QT_NO_BEARERMANAGEMENT
+     // Return a disabled network reply if network access is disabled.
+     // Except if the scheme is empty or file://.
+-    if (!d->networkAccessible && !isLocalFile) {
+    if (d->networkAccessible == NotAccessible && !isLocalFile) {
+         return new QDisabledNetworkReply(this, req, op);
+     }
+ 
+diff --git a/src/network/access/qnetworkaccessmanager_p.h b/src/network/access/qnetworkaccessmanager_p.h
+index 54ae114..3fc33b5 100644
+--- a/src/network/access/qnetworkaccessmanager_p.h
+++ b/src/network/access/qnetworkaccessmanager_p.h
+@@ -93,6 +93,8 @@ public:
+         online = (networkConfiguration.state().testFlag(QNetworkConfiguration::Active));
+         if (online)
+             networkAccessible = QNetworkAccessManager::Accessible;
+        else if (networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined))
+            networkAccessible = QNetworkAccessManager::UnknownAccessibility;
+         else
+             networkAccessible = QNetworkAccessManager::NotAccessible;
+ #endif
+-- 
+1.9.1
+
@@ -1,7 +1,7 @@
-From e6bccb1f0d8ca59acb1ffdac74a823c06346e7f3 Mon Sep 17 00:00:00 2001
+From 06818f6d1c602aa3c4f9356324866432d2dd0195 Mon Sep 17 00:00:00 2001
 From: Daniel Molkentin <daniel@molkentin.de>
 Date: Mon, 16 Nov 2015 15:02:37 +0100
-Subject: [PATCH] Remove legacy platform code in QSslSocket for OS X < 10.5
+Subject: [PATCH 1/2] Remove legacy platform code in QSslSocket for OS X < 10.5

 This avoids manual symbol lookups and makes the code more readable.
 Mark identical code.
@@ -16,18 +16,20 @@ Reviewed-by: Markus Goetz (Woboq GmbH) <markus@woboq.com>
 Conflicts:
 	src/network/ssl/qsslsocket_openssl.cpp
 ---
- src/network/ssl/qsslsocket_openssl.cpp | 81 +++++++++++-----------------------
+ src/network/ssl/qsslsocket_openssl.cpp | 83 +++++++++++-----------------------
 src/network/ssl/qsslsocket_p.h         |  6 +--
- 2 files changed, 26 insertions(+), 61 deletions(-)
+ 2 files changed, 28 insertions(+), 61 deletions(-)

 diff --git a/src/network/ssl/qsslsocket_openssl.cpp b/src/network/ssl/qsslsocket_openssl.cpp
-index 82644c1..415f147 100644
+index 13fc534..7d0fe00 100644
 --- a/src/network/ssl/qsslsocket_openssl.cpp
 +++ b/src/network/ssl/qsslsocket_openssl.cpp
-@@ -76,14 +76,17 @@
- 
- #include <string.h>
+@@ -69,14 +69,19 @@
+ #include <QtCore/qvarlengtharray.h>
+ #include <QLibrary> // for loading the security lib for the CA store
 
+#include <string.h>
+
 +#ifdef Q_OS_DARWIN
 +#  include <private/qcore_mac_p.h>
 +#endif
@@ -48,7 +50,7 @@ index 82644c1..415f147 100644
     PtrCertOpenSystemStoreW QSslSocketPrivate::ptrCertOpenSystemStoreW = 0;
     PtrCertFindCertificateInStore QSslSocketPrivate::ptrCertFindCertificateInStore = 0;
     PtrCertCloseStore QSslSocketPrivate::ptrCertCloseStore = 0;
-@@ -509,23 +512,7 @@ void QSslSocketPrivate::ensureCiphersAndCertsLoaded()
+@@ -482,23 +487,7 @@ void QSslSocketPrivate::ensureCiphersAndCertsLoaded()
 
 #ifndef QT_NO_LIBRARY
     //load symbols needed to receive certificates from system store
@@ -57,23 +59,23 @@ index 82644c1..415f147 100644
 -    if (securityLib.load()) {
 -        ptrSecCertificateCopyData = (PtrSecCertificateCopyData) securityLib.resolve("SecCertificateCopyData");
 -        if (!ptrSecCertificateCopyData)
-            qCWarning(lcSsl, "could not resolve symbols in security library"); // should never happen
+-            qWarning("could not resolve symbols in security library"); // should never happen
 -
 -        ptrSecTrustSettingsCopyCertificates = (PtrSecTrustSettingsCopyCertificates) securityLib.resolve("SecTrustSettingsCopyCertificates");
 -        if (!ptrSecTrustSettingsCopyCertificates) { // method was introduced in Leopard, use legacy method if it's not there
 -            ptrSecTrustCopyAnchorCertificates = (PtrSecTrustCopyAnchorCertificates) securityLib.resolve("SecTrustCopyAnchorCertificates");
 -            if (!ptrSecTrustCopyAnchorCertificates)
-                qCWarning(lcSsl, "could not resolve symbols in security library"); // should never happen
+-                qWarning("could not resolve symbols in security library"); // should never happen
 -        }
 -    } else {
-        qCWarning(lcSsl, "could not load security library");
+-        qWarning("could not load security library");
 -    }
 -#elif defined(Q_OS_WIN)
 +#if defined(Q_OS_WIN)
     HINSTANCE hLib = LoadLibraryW(L"Crypt32");
     if (hLib) {
 #if defined(Q_OS_WINCE)
-@@ -693,40 +680,22 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
+@@ -635,40 +624,22 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
     timer.start();
 #endif
     QList<QSslCertificate> systemCerts;
@@ -99,7 +101,7 @@ index 82644c1..415f147 100644
 -                data = ptrSecCertificateCopyData(cfCert);
 -
 -                if (data == NULL) {
-                    qCWarning(lcSsl, "error retrieving a CA certificate from the system store");
+-                    qWarning("error retrieving a CA certificate from the system store");
 -                } else {
 -                    QByteArray rawCert = QByteArray::fromRawData((const char *)CFDataGetBytePtr(data), CFDataGetLength(data));
 -                    systemCerts.append(QSslCertificate::fromData(rawCert, QSsl::Der));
@@ -125,15 +127,15 @@ index 82644c1..415f147 100644
 -        }
 -        else {
 -           // no detailed error handling here
-           qCWarning(lcSsl, "could not retrieve system CA certificates");
+-           qWarning("could not retrieve system CA certificates");
         }
     }
 #elif defined(Q_OS_WIN)
 diff --git a/src/network/ssl/qsslsocket_p.h b/src/network/ssl/qsslsocket_p.h
-index d651971..17cc7b4 100644
+index 6e7a2c5..c1a6f05 100644
 --- a/src/network/ssl/qsslsocket_p.h
 +++ b/src/network/ssl/qsslsocket_p.h
-@@ -151,11 +151,7 @@ public:
+@@ -145,11 +145,7 @@ public:
     static bool isMatchingHostname(const QSslCertificate &cert, const QString &peerName);
     Q_AUTOTEST_EXPORT static bool isMatchingHostname(const QString &cn, const QString &hostname);
 
@@ -146,3 +148,6 @@ index d651971..17cc7b4 100644
     static PtrCertOpenSystemStoreW ptrCertOpenSystemStoreW;
     static PtrCertFindCertificateInStore ptrCertFindCertificateInStore;
     static PtrCertCloseStore ptrCertCloseStore;
+-- 
+1.9.1
+
@@ -1,7 +1,7 @@
-From 9d1120db0973ea7741b13a6555b20ae61f6d037e Mon Sep 17 00:00:00 2001
+From 6b9366e7748857f14d5b0f92ced70c08ab5235b7 Mon Sep 17 00:00:00 2001
 From: Daniel Molkentin <danimo@owncloud.com>
 Date: Wed, 25 Nov 2015 12:37:27 +0100
-Subject: [PATCH] QSslSocket: evaluate CAs in all keychain categories
+Subject: [PATCH 2/2] QSslSocket: evaluate CAs in all keychain categories

 This will make sure that certs in the domainUser (login),
 and domainAdmin (per machine) keychain are being picked up
@@ -15,7 +15,7 @@ it will be accepted.
 [ChangeLog][Platform Specific Changes] OS X now accepts trusted
        certificates from the login and system keychains.

-(Backport of fe3a84138e266c425f11353f7d8dc28a588af89e)
+(Backport of fe3a84138e266c425f11353f7d8dc28a588af89e to Qt 5.4)

 Task-number: QTBUG-32898
 Change-Id: Ia23083d5af74388eeee31ba07239735cbbe64368
@@ -29,10 +29,10 @@ Reviewed-by: Markus Goetz (Woboq GmbH) <markus@woboq.com>
 create mode 100644 src/network/ssl/qsslsocket_mac_shared.cpp

 diff --git a/src/network/ssl/qsslsocket.cpp b/src/network/ssl/qsslsocket.cpp
-index 549906a..7b202b0 100644
+index 8887f47..6347c20 100644
 --- a/src/network/ssl/qsslsocket.cpp
 +++ b/src/network/ssl/qsslsocket.cpp
-@@ -1508,6 +1508,10 @@ QList<QSslCertificate> QSslSocket::defaultCaCertificates()
+@@ -1446,6 +1446,10 @@ QList<QSslCertificate> QSslSocket::defaultCaCertificates()
     returned by defaultCaCertificates(). You can replace that database
     with your own with setDefaultCaCertificates().
 
@@ -198,10 +198,10 @@ index 0000000..60fea4c
 +
 +QT_END_NAMESPACE
 diff --git a/src/network/ssl/qsslsocket_openssl.cpp b/src/network/ssl/qsslsocket_openssl.cpp
-index 415f147..7a3cb42 100644
+index 7d0fe00..7415e32 100644
 --- a/src/network/ssl/qsslsocket_openssl.cpp
 +++ b/src/network/ssl/qsslsocket_openssl.cpp
-@@ -76,14 +76,6 @@
+@@ -71,14 +71,6 @@
 
 #include <string.h>
 
@@ -216,15 +216,15 @@ index 415f147..7a3cb42 100644
 QT_BEGIN_NAMESPACE
 
 #if defined(Q_OS_WIN)
-@@ -672,6 +664,7 @@ void QSslSocketPrivate::resetDefaultEllipticCurves()
-     setDefaultSupportedEllipticCurves(curves);
+@@ -616,6 +608,7 @@ void QSslSocketPrivate::resetDefaultCiphers()
+     setDefaultCiphers(defaultCiphers);
 }
 
 +#ifndef Q_OS_DARWIN // Apple implementation in qsslsocket_mac_shared.cpp
 QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
 {
     ensureInitialized();
-@@ -680,25 +673,7 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
+@@ -624,25 +617,7 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
     timer.start();
 #endif
     QList<QSslCertificate> systemCerts;
@@ -251,7 +251,7 @@ index 415f147..7a3cb42 100644
     if (ptrCertOpenSystemStoreW && ptrCertFindCertificateInStore && ptrCertCloseStore) {
         HCERTSTORE hSystemStore;
 #if defined(Q_OS_WINCE)
-@@ -775,6 +750,7 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
+@@ -719,6 +694,7 @@ QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
 
     return systemCerts;
 }
@@ -260,10 +260,10 @@ index 415f147..7a3cb42 100644
 void QSslSocketBackendPrivate::startClientEncryption()
 {
 diff --git a/src/network/ssl/ssl.pri b/src/network/ssl/ssl.pri
-index 29c47cd..8eb605b 100644
+index 384e149..9546f18 100644
 --- a/src/network/ssl/ssl.pri
 +++ b/src/network/ssl/ssl.pri
-@@ -62,7 +62,9 @@ contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
+@@ -45,7 +45,9 @@ contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
                ssl/qsslsocket_openssl.cpp \
                ssl/qsslsocket_openssl_symbols.cpp
 
@@ -274,3 +274,6 @@ index 29c47cd..8eb605b 100644
 
     # Add optional SSL libs
     # Static linking of OpenSSL with msvc:
+-- 
+1.9.1
+
@@ -0,0 +1,152 @@
+From ae9d3f4c6c1a732788cd1f24c6a928cee16c3991 Mon Sep 17 00:00:00 2001
+From: Daniel Molkentin <daniel@molkentin.de>
+Date: Tue, 27 Jan 2015 16:58:32 +0100
+Subject: [PATCH] Win32: Re-init system proxy if internet settings change
+
+Because Proxy Auto Configuration performs DNS lookups,
+the proxy settings are being cached. For long-running
+programs this means that once users switch e.g. from or
+to company networks with a proxy, they instantly will
+lose connectivity because we cache the old setting.
+
+To remedy this, we monitor the Registry (locations
+courtesy of Chromium's platform support) for changes
+in its settings, and requery for the current proxy in
+that case.
+
+Task-number: QTBUG-3470
+Task-number: QTBUG-29990
+Change-Id: Id25a51387bcd232c5f879cea0371038986d0e2de
+Reviewed-by: Oliver Wolff <oliver.wolff@theqtcompany.com>
+---
+ src/network/kernel/qnetworkproxy_win.cpp | 86 +++++++++++++++++++++++++++++++-
+ 1 file changed, 84 insertions(+), 2 deletions(-)
+
+diff --git a/src/network/kernel/qnetworkproxy_win.cpp b/src/network/kernel/qnetworkproxy_win.cpp
+index da2c020..f7741ce 100644
+--- a/src/network/kernel/qnetworkproxy_win.cpp
+++ b/src/network/kernel/qnetworkproxy_win.cpp
+@@ -345,12 +345,66 @@ static QList<QNetworkProxy> parseServerList(const QNetworkProxyQuery &query, con
+     return removeDuplicateProxies(result);
+ }
+
+#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+namespace {
+class QRegistryWatcher {
+public:
+    void addLocation(HKEY hive, const QString& path)
+    {
+        HKEY openedKey;
+        if (RegOpenKeyEx(hive, reinterpret_cast<const wchar_t*>(path.utf16()), 0, KEY_READ, &openedKey) != ERROR_SUCCESS)
+            return;
+
+        const DWORD filter = REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_ATTRIBUTES |
+                REG_NOTIFY_CHANGE_LAST_SET | REG_NOTIFY_CHANGE_SECURITY;
+
+        // Watch the registry key for a change of value.
+        HANDLE handle = CreateEvent(NULL, true, false, NULL);
+        if (RegNotifyChangeKeyValue(openedKey, true, filter, handle, true) != ERROR_SUCCESS) {
+            CloseHandle(handle);
+            return;
+        }
+        m_watchEvents.append(handle);
+        m_registryHandles.append(openedKey);
+    }
+
+    bool hasChanged() const {
+        return !isEmpty() &&
+               WaitForMultipleObjects(m_watchEvents.size(), m_watchEvents.data(), false, 0) < WAIT_OBJECT_0 + m_watchEvents.size();
+    }
+
+    bool isEmpty() const {
+        return m_watchEvents.isEmpty();
+    }
+
+    void clear() {
+        foreach (HANDLE event, m_watchEvents)
+            CloseHandle(event);
+        foreach (HKEY key, m_registryHandles)
+            RegCloseKey(key);
+
+        m_watchEvents.clear();
+        m_registryHandles.clear();
+    }
+
+    ~QRegistryWatcher() {
+        clear();
+    }
+
+private:
+    QVector<HANDLE> m_watchEvents;
+    QVector<HKEY> m_registryHandles;
+};
+} // namespace
+#endif // !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+
+ class QWindowsSystemProxy
+ {
+ public:
+     QWindowsSystemProxy();
+     ~QWindowsSystemProxy();
+     void init();
+    void reset();
+
+     QMutex mutex;
+
+@@ -361,7 +415,9 @@ public:
+     QStringList proxyServerList;
+     QStringList proxyBypass;
+     QList<QNetworkProxy> defaultResult;
+-
+#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+    QRegistryWatcher proxySettingsWatcher;
+#endif
+     bool initialized;
+     bool functional;
+     bool isAutoConfig;
+@@ -381,16 +437,42 @@ QWindowsSystemProxy::~QWindowsSystemProxy()
+         ptrWinHttpCloseHandle(hHttpSession);
+ }
+
+void QWindowsSystemProxy::reset()
+{
+    autoConfigUrl.clear();
+    proxyServerList.clear();
+    proxyBypass.clear();
+    defaultResult.clear();
+    defaultResult << QNetworkProxy::NoProxy;
+    functional = false;
+    isAutoConfig = false;
+}
+
+ void QWindowsSystemProxy::init()
+ {
+-    if (initialized)
+    bool proxySettingsChanged = false;
+#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+    proxySettingsChanged = proxySettingsWatcher.hasChanged();
+#endif
+
+    if (initialized && !proxySettingsChanged)
+         return;
+     initialized = true;
+
+    reset();
+
+ #ifdef Q_OS_WINCE
+     // Windows CE does not have any of the following API
+     return;
+ #else
+
+#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+    proxySettingsWatcher.clear(); // needs reset to trigger a new detection
+    proxySettingsWatcher.addLocation(HKEY_CURRENT_USER,  QStringLiteral("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"));
+    proxySettingsWatcher.addLocation(HKEY_LOCAL_MACHINE, QStringLiteral("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"));
+    proxySettingsWatcher.addLocation(HKEY_LOCAL_MACHINE, QStringLiteral("Software\\Policies\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"));
+#endif
+
+     // load the winhttp.dll library
+     QSystemLibrary lib(L"winhttp");
+     if (!lib.load())
+--
+1.9.1
@@ -0,0 +1,32 @@
+From c1a67e7dc3a6f8876efa32cdbabbfde1c5a37bc6 Mon Sep 17 00:00:00 2001
+From: Daniel Molkentin <daniel@molkentin.de>
+Date: Tue, 31 Mar 2015 17:43:44 +0200
+Subject: [PATCH] Windows: Do not crash if SSL context is gone after root cert
+ lookup
+
+On Windows, we perform an extra certificate lookup for root CAs that
+are not in Windows' (minimal) root store. This check can take up to
+15 seconds. The SSL context can already be gone once we return. Hence
+we now check for a non-null SSL context on Windows before proceeding.
+
+Change-Id: I1951569d9b17da33fa604f7c9d8b33255acf200d
+Reviewed-by: Richard J. Moore <rich@kde.org>
+---
+ src/network/ssl/qsslsocket_openssl.cpp | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/network/ssl/qsslsocket_openssl.cpp b/src/network/ssl/qsslsocket_openssl.cpp
+index 0e1a3e5..b132aec 100644
+--- a/src/network/ssl/qsslsocket_openssl.cpp
+++ b/src/network/ssl/qsslsocket_openssl.cpp
+@@ -1281,7 +1281,7 @@ void QSslSocketBackendPrivate::_q_caRootLoaded(QSslCertificate cert, QSslCertifi
+     if (plainSocket)
+         plainSocket->resume();
+     paused = false;
+-    if (checkSslErrors())
+    if (checkSslErrors() && ssl)
+         continueHandshake();
+ }
+
+--
+1.9.1
@@ -0,0 +1,39 @@
+From cf6881c03d9f08c6ace83defe461423bb87f30d8 Mon Sep 17 00:00:00 2001
+From: =?utf8?q?Tor=20Arne=20Vestb=C3=B8?= <tor.arne.vestbo@theqtcompany.com>
+Date: Fri, 15 Jan 2016 14:15:51 +0100
+Subject: [PATCH] OS X: Ensure system tray icon is prepared even when menu bar
+ is hidden
+
+On OS X 10.11 (El Capitan) the system menu bar can be automatically
+hidden, in which case the menu bar height is reported to be 0 when
+using the menuBarHeight API.
+
+This resulted in failing to prepare an image for the system tray
+icon item, making the tray item "invisible".
+
+Instead we now use the [[NSStatusBar systemStatusBar] thickness]
+API, which returns the correct height regardless of the menu bar
+being hidden or not.
+
+Task-number: QTBUG-48960
+Change-Id: I208fb8df13754964a6f254cadfbff06dd56c6bab
+---
+ src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+index a3ffb5b..8152c57 100644
+--- a/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+++ b/src/plugins/platforms/cocoa/qcocoasystemtrayicon.mm
+@@ -198,7 +198,7 @@ void QCocoaSystemTrayIcon::updateIcon(const QIcon &icon)
+     // current OS X versions is 22 points. Provide some future-proofing
+     // by deriving the icon height from the menu height.
+     const int padding = 4;
+-    const int menuHeight = [[[NSApplication sharedApplication] mainMenu] menuBarHeight];
+    const int menuHeight = [[NSStatusBar systemStatusBar] thickness];
+     const int maxImageHeight = menuHeight - padding;
+ 
+     // Select pixmap based on the device pixel height. Ideally we would use
+-- 
+2.6.2.2.g1b5ffa3
+
@@ -1,20 +1,55 @@
 ## Patches used

-There are our patches on top of Qt 5.6.2, which we are currently
-using for our binary packages on Windows and macOS. Most of them
+There are our patches on top of Qt 5.4.0, which we are currently
+using for our binary packages on Windows and Mac OS X. Most of them
 have been sent upstream and are part of newer Qt releases.

-All changes are designed to be upstream, and all those that are
+All changes are designed to up upstream, and all those that are
 special hacks to Qt will bear a NOUPSTREAM in their name

-You can apply those patches on a git clone using:
+The git-style numeration is ordered by order of creation, their
+purpose is outlined in each patches' front matter.

-```
-git am <client>/admin/qt/patches/qtbase/*.patch
-```
+### Part of Qt v5.4.1 and later
+* 0001-Fix-crash-on-Mac-OS-if-PAC-URL-contains-non-URL-lega.patch
+* 0002-Fix-possible-crash-when-passing-an-invalid-PAC-URL.patch
+* 0003-Fix-crash-if-PAC-script-retrieval-returns-a-null-CFD.patch
+
+### Part of Qt v5.4.2 and later
+* 0004-Cocoa-Fix-systray-SVG-icons.patch
+* 0005-OSX-Fix-disapearing-tray-icon.patch
+* 0007-QNAM-Fix-upload-corruptions-when-server-closes-conne.patch
+* 0018-Windows-Do-not-crash-if-SSL-context-is-gone-after-ro.patch
+
+### Part of Qt v5.5.0 and later
+* 0017-Win32-Re-init-system-proxy-if-internet-settings-chan.patch
+
+### Part of Qt v5.5.1 and later
+* 0007-X-Network-Fix-up-previous-corruption-patch.patch
+* 0008-QNAM-Fix-reply-deadlocks-on-server-closing-connectio.patch
+* 0014-Fix-SNI-for-TlsV1_0OrLater-TlsV1_1OrLater-and-TlsV1_.patch
+* 0016-Fix-possible-crash-when-passing-an-invalid-PAC-URL.patch
+* 0011-Make-sure-to-report-correct-NetworkAccessibility.patch
+
+### Part of Qt v5.5.2 (UNRELEASED!)
+* 0009-QNAM-Assign-proper-channel-before-sslErrors-emission.patch
+* 0010-Don-t-let-closed-http-sockets-pass-as-valid-connecti.patch
+* 0012-Make-sure-networkAccessibilityChanged-is-emitted.patch
+
+### Part of Qt v5.6 and later
+* 0009-QNAM-Assign-proper-channel-before-sslErrors-emission.patch
+* 0010-Don-t-let-closed-http-sockets-pass-as-valid-connecti.patch
+* 0011-Make-sure-to-report-correct-NetworkAccessibility.patch
+* 0012-Make-sure-networkAccessibilityChanged-is-emitted.patch
+* 0013-Make-UnknownAccessibility-not-block-requests.patch
+* 0019-Ensure-system-tray-icon-is-prepared-even-when-menu-bar.patch
+
+### Part of Qt 5.7 and later
+* 0015-Remove-legacy-platform-code-in-QSslSocket-for-OS-X-1.patch
+
+### Not submitted upstream to be part of any release:
+* 0006-Fix-force-debug-info-with-macx-clang_NOUPSTREAM.patch
+This is only needed if you intent to harvest debugging symbols
+for breakpad.

-You can update them using:

-```
-git format-patch -N --no-signature -o <client>/admin/qt/patches/qtbase/ <v5.x.y>
-```
@@ -89,7 +89,7 @@ static int _data_cmp(const void *key, const void *data) {
  return 0;
 }

-void csync_create(CSYNC **csync, const char *local) {
+void csync_create(CSYNC **csync, const char *local, const char *remote) {
  CSYNC *ctx;
  size_t len = 0;

@@ -103,6 +103,12 @@ void csync_create(CSYNC **csync, const char *local) {

  ctx->local.uri = c_strndup(local, len);

+  /* remove trailing slashes */
+  len = strlen(remote);
+  while(len > 0 && remote[len - 1] == '/') --len;
+
+  ctx->remote.uri = c_strndup(remote, len);
+
  ctx->status_code = CSYNC_STATUS_OK;

  ctx->current_fs = NULL;
@@ -114,7 +120,7 @@ void csync_create(CSYNC **csync, const char *local) {
  *csync = ctx;
 }

-void csync_init(CSYNC *ctx, const char *db_file) {
+void csync_init(CSYNC *ctx) {
  assert(ctx);
  /* Do not initialize twice */

@@ -125,9 +131,6 @@ void csync_init(CSYNC *ctx, const char *db_file) {

  ctx->remote.type = REMOTE_REPLICA;

-  SAFE_FREE(ctx->statedb.file);
-  ctx->statedb.file = c_strdup(db_file);
-
  c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp);
  c_rbtree_create(&ctx->remote.tree, _key_cmp, _data_cmp);

@@ -149,11 +152,19 @@ int csync_update(CSYNC *ctx) {
  }
  ctx->status_code = CSYNC_STATUS_OK;

-  /* Path of database file is set in csync_init */
-  if (csync_statedb_load(ctx, ctx->statedb.file, &ctx->statedb.db) < 0) {
+  /* create/load statedb */
+    rc = asprintf(&ctx->statedb.file, "%s/.csync_journal.db",
+                  ctx->local.uri);
+    if (rc < 0) {
+        ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
+        return rc;
+    }
+    CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Journal: %s", ctx->statedb.file);
+
+    if (csync_statedb_load(ctx, ctx->statedb.file, &ctx->statedb.db) < 0) {
      rc = -1;
      return rc;
-  }
+    }

  ctx->status_code = CSYNC_STATUS_OK;

@@ -188,7 +199,7 @@ int csync_update(CSYNC *ctx) {
  ctx->current = REMOTE_REPLICA;
  ctx->replica = ctx->remote.type;

-  rc = csync_ftw(ctx, "", csync_walker, MAX_DEPTH);
+  rc = csync_ftw(ctx, ctx->remote.uri, csync_walker, MAX_DEPTH);
  if (rc < 0) {
      if(ctx->status_code == CSYNC_STATUS_OK) {
          ctx->status_code = csync_errno_to_status(errno, CSYNC_STATUS_UPDATE_ERROR);
@@ -510,6 +521,7 @@ static void _csync_clean_ctx(CSYNC *ctx)
    c_rbtree_free(ctx->local.tree);
    c_rbtree_free(ctx->remote.tree);

+    SAFE_FREE(ctx->statedb.file);
    SAFE_FREE(ctx->remote.root_perms);
 }

@@ -566,8 +578,8 @@ int csync_destroy(CSYNC *ctx) {

  _csync_clean_ctx(ctx);

-  SAFE_FREE(ctx->statedb.file);
  SAFE_FREE(ctx->local.uri);
+  SAFE_FREE(ctx->remote.uri);
  SAFE_FREE(ctx->error_string);

 #ifdef WITH_ICONV
@@ -44,6 +44,11 @@
 extern "C" {
 #endif

+struct csync_client_certs_s {
+  char *certificatePath;
+  char *certificatePasswd;
+};  
+  
 enum csync_status_codes_e {
  CSYNC_STATUS_OK         = 0,

@@ -312,7 +317,7 @@ typedef const char* (*csync_checksum_hook) (
 *
 * @param csync  The context variable to allocate.
 */
-void OCSYNC_EXPORT csync_create(CSYNC **csync, const char *local);
+void OCSYNC_EXPORT csync_create(CSYNC **csync, const char *local, const char *remote);

 /**
 * @brief Initialize the file synchronizer.
@@ -321,7 +326,7 @@ void OCSYNC_EXPORT csync_create(CSYNC **csync, const char *local);
 *
 * @param ctx  The context to initialize.
 */
-void OCSYNC_EXPORT csync_init(CSYNC *ctx, const char *db_file);
+void OCSYNC_EXPORT csync_init(CSYNC *ctx);

 /**
 * @brief Update detection
@@ -230,11 +230,6 @@ static CSYNC_EXCLUDE_TYPE _csync_excluded_common(c_strlist_t *excludes, const ch
    }
    blen = strlen(bname);

-    rc = csync_fnmatch("._sync_*.db*", bname, 0);
-    if (rc == 0) {
-        match = CSYNC_FILE_SILENTLY_EXCLUDED;
-        goto out;
-    }
    rc = csync_fnmatch(".csync_journal.db*", bname, 0);
    if (rc == 0) {
        match = CSYNC_FILE_SILENTLY_EXCLUDED;
@@ -103,6 +103,9 @@ struct csync_s {

  } callbacks;
  c_strlist_t *excludes;
+
+  // needed for SSL client certificate support
+  struct csync_client_certs_s *clientCerts;
  
  struct {
    char *file;
@@ -123,6 +126,7 @@ struct csync_s {
  } local;

  struct {
+    char *uri;
    c_rbtree_t *tree;
    enum csync_replica_e type;
    int  read_from_db;
@@ -56,13 +56,26 @@ static uint64_t _hash_of_file(CSYNC *ctx, const char *file) {

  if( ctx && file ) {
    path = file;
-    if (ctx->current == LOCAL_REPLICA) {
+    switch (ctx->current) {
+    case LOCAL_REPLICA:
      if (strlen(path) <= strlen(ctx->local.uri)) {
        return 0;
      }
      path += strlen(ctx->local.uri) + 1;
+      break;
+    case REMOTE_REPLICA:
+      if (strlen(path) <= strlen(ctx->remote.uri)) {
+        return 0;
+      }
+      path += strlen(ctx->remote.uri) + 1;
+      break;
+    default:
+      path = NULL;
+      return 0;
+      break;
    }
    len = strlen(path);
+
    h = c_jhash64((uint8_t *) path, len, 0);
  }
  return h;
@@ -175,12 +188,25 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
  }

  path = file;
-  if (ctx->current == LOCAL_REPLICA) {
+  switch (ctx->current) {
+    case LOCAL_REPLICA:
      if (strlen(path) <= strlen(ctx->local.uri)) {
        ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
        return -1;
      }
      path += strlen(ctx->local.uri) + 1;
+      break;
+    case REMOTE_REPLICA:
+      if (strlen(path) <= strlen(ctx->remote.uri)) {
+        ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+        return -1;
+      }
+      path += strlen(ctx->remote.uri) + 1;
+      break;
+    default:
+      path = NULL;
+      ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+      return -1;
  }

  len = strlen(path);
@@ -603,7 +629,16 @@ int csync_walker(CSYNC *ctx, const char *file, const csync_vio_file_stat_t *fs,

 static bool fill_tree_from_db(CSYNC *ctx, const char *uri)
 {
-    if( csync_statedb_get_below_path(ctx, uri) < 0 ) {
+    const char *path = NULL;
+
+    if( strlen(uri) < strlen(ctx->remote.uri)+1) {
+        CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "name does not contain remote uri!");
+        return false;
+    }
+
+    path = uri + strlen(ctx->remote.uri)+1;
+
+    if( csync_statedb_get_below_path(ctx, path) < 0 ) {
        CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "StateDB could not be read!");
        return false;
    }
@@ -645,6 +680,12 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,

  bool do_read_from_db = (ctx->current == REMOTE_REPLICA && ctx->remote.read_from_db);

+  if (uri[0] == '\0') {
+    errno = ENOENT;
+    ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+    goto error;
+  }
+
  read_from_db = ctx->remote.read_from_db;

  // if the etag of this dir is still the same, its content is restored from the
@@ -658,7 +699,16 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
      goto done;
  }

-  if ((dh = csync_vio_opendir(ctx, uri)) == NULL) {
+  const char *uri_for_vio = uri;
+  if (ctx->current == REMOTE_REPLICA) {
+      uri_for_vio += strlen(ctx->remote.uri);
+      if (strlen(uri_for_vio) > 0 && uri_for_vio[0] == '/') {
+          uri_for_vio++; // cut leading slash
+      }
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "URI without fuzz for %s is \"%s\"", uri, uri_for_vio);
+  }
+
+  if ((dh = csync_vio_opendir(ctx, uri_for_vio)) == NULL) {
      if (ctx->abort) {
          CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Aborted!");
          ctx->status_code = CSYNC_STATUS_ABORTED;
@@ -704,6 +754,8 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
  }

  while ((dirent = csync_vio_readdir(ctx, dh))) {
+    const char *path = NULL;
+    size_t ulen = 0;
    int flen;
    int flag;

@@ -729,19 +781,50 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
      continue;
    }

-    if (uri[0] == '\0') {
-      filename = c_strdup(d_name);
-      flen = strlen(d_name);
-    } else {
-      flen = asprintf(&filename, "%s/%s", uri, d_name);
-    }
-    if (flen < 0 || !filename) {
+    flen = asprintf(&filename, "%s/%s", uri, d_name);
+    if (flen < 0) {
      csync_vio_file_stat_destroy(dirent);
      dirent = NULL;
      ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
      goto error;
    }

+    /* Create relative path */
+    switch (ctx->current) {
+      case LOCAL_REPLICA:
+        ulen = strlen(ctx->local.uri) + 1;
+        break;
+      case REMOTE_REPLICA:
+        ulen = strlen(ctx->remote.uri) + 1;
+        break;
+      default:
+        break;
+    }
+
+    if (((size_t)flen) < ulen) {
+      csync_vio_file_stat_destroy(dirent);
+      dirent = NULL;
+      ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+      goto error;
+    }
+
+    path = filename + ulen;
+
+    /* skip ".csync_journal.db" and ".csync_journal.db.ctmp" */
+    /* Isn't this done via csync_exclude already? */
+    if (c_streq(path, ".csync_journal.db")
+            || c_streq(path, ".csync_journal.db.ctmp")
+            || c_streq(path, ".csync_journal.db.ctmp-journal")
+            || c_streq(path, ".csync-progressdatabase")
+            || c_streq(path, ".csync_journal.db-shm")
+            || c_streq(path, ".csync_journal.db-wal")
+            || c_streq(path, ".csync_journal.db-journal")) {
+        csync_vio_file_stat_destroy(dirent);
+        dirent = NULL;
+        SAFE_FREE(filename);
+        continue;
+    }
+
    /* Only for the local replica we have to stat(), for the remote one we have all data already */
    if (ctx->replica == LOCAL_REPLICA) {
        res = csync_vio_stat(ctx, filename, dirent);
@@ -23,36 +23,38 @@

 #include "csync_private.h"

-static int setup(void **state) {
+static void setup(void **state) {
    CSYNC *csync;
    int rc;

    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    *state = csync;
-    
-    return 0;
 }

-static int setup_module(void **state) {
+static void setup_module(void **state) {
    CSYNC *csync;
    int rc;

    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);

-    csync_init(csync, "foo");
+    csync_create(&csync, "/tmp/check_csync1", "dummy://foo/bar");
+
+    csync_init(csync);
    *state = csync;
-    
-    return 0;
 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc;

@@ -64,9 +66,10 @@ static int teardown(void **state) {
    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);

+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
    *state = NULL;
-    
-    return 0;
 }

 static void check_csync_commit(void **state)
@@ -94,10 +97,10 @@ static void check_csync_commit_dummy(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_commit, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_commit_dummy, setup_module, teardown),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_commit, setup, teardown),
+        unit_test_setup_teardown(check_csync_commit_dummy, setup_module, teardown),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }
@@ -42,7 +42,7 @@ static void check_csync_create(void **state)

    (void) state; /* unused */

-    csync_create(&csync, "/tmp/csync1");
+    csync_create(&csync, "/tmp/csync1", "/tmp/csync2");

    rc = csync_destroy(csync);
    assert_int_equal(rc, 0);
@@ -50,11 +50,11 @@ static void check_csync_create(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test(check_csync_destroy_null),
-        cmocka_unit_test(check_csync_create),
+    const UnitTest tests[] = {
+        unit_test(check_csync_destroy_null),
+        unit_test(check_csync_create),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -29,20 +29,19 @@

 #define EXCLUDE_LIST_FILE SOURCEDIR"/../sync-exclude.lst"

-static int setup(void **state) {
+static void setup(void **state) {
    CSYNC *csync;

-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    *state = csync;
-    return 0;
 }

-static int setup_init(void **state) {
+static void setup_init(void **state) {
    CSYNC *csync;
    int rc;

-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    rc = csync_exclude_load(EXCLUDE_LIST_FILE, &(csync->excludes));
    assert_int_equal(rc, 0);
@@ -60,10 +59,9 @@ static int setup_init(void **state) {
    assert_int_equal(rc, 0);

    *state = csync;
-    return 0;
 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc;

@@ -76,8 +74,6 @@ static int teardown(void **state) {
    assert_int_equal(rc, 0);

    *state = NULL;
-    
-    return 0;
 }

 static void check_csync_exclude_add(void **state)
@@ -147,17 +143,6 @@ static void check_csync_excluded(void **state)
    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
    rc = csync_excluded_no_ctx(csync->excludes, "subdir/.csync_journal.db", CSYNC_FTW_TYPE_FILE);
    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
-    
-    /* also the new form of the database name */
-    rc = csync_excluded_no_ctx(csync->excludes, "._sync_5bdd60bdfcfa.db", CSYNC_FTW_TYPE_FILE);
-    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
-    rc = csync_excluded_no_ctx(csync->excludes, "._sync_5bdd60bdfcfa.db.ctmp", CSYNC_FTW_TYPE_FILE);
-    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
-    rc = csync_excluded_no_ctx(csync->excludes, "._sync_5bdd60bdfcfa.db-shm", CSYNC_FTW_TYPE_FILE);
-    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
-    rc = csync_excluded_no_ctx(csync->excludes, "subdir/._sync_5bdd60bdfcfa.db", CSYNC_FTW_TYPE_FILE);
-    assert_int_equal(rc, CSYNC_FILE_SILENTLY_EXCLUDED);
-    

    /* pattern ]*.directory - ignore and remove */
    rc = csync_excluded_no_ctx(csync->excludes, "my.~directory", CSYNC_FTW_TYPE_FILE);
@@ -395,16 +380,16 @@ static void check_csync_exclude_expand_escapes(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_exclude_add, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_exclude_load, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_excluded, setup_init, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_excluded_traversal, setup_init, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_pathes, setup_init, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_is_windows_reserved_word, setup_init, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_excluded_performance, setup_init, teardown),
-        cmocka_unit_test(check_csync_exclude_expand_escapes),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_exclude_add, setup, teardown),
+        unit_test_setup_teardown(check_csync_exclude_load, setup, teardown),
+        unit_test_setup_teardown(check_csync_excluded, setup_init, teardown),
+        unit_test_setup_teardown(check_csync_excluded_traversal, setup_init, teardown),
+        unit_test_setup_teardown(check_csync_pathes, setup_init, teardown),
+        unit_test_setup_teardown(check_csync_is_windows_reserved_word, setup_init, teardown),
+        unit_test_setup_teardown(check_csync_excluded_performance, setup_init, teardown),
+        unit_test(check_csync_exclude_expand_escapes),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }
@@ -23,33 +23,37 @@

 #include "csync_private.h"

-static int setup(void **state) {
+static void setup(void **state) {
    CSYNC *csync;
    int rc;

    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    *state = csync;
-    return 0;
 }

-static int setup_module(void **state) {
+static void setup_module(void **state) {
    CSYNC *csync;
    int rc;

    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "dummy://foo/bar");

    *state = csync;
-    return 0;
 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc;

@@ -61,28 +65,28 @@ static int teardown(void **state) {
    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);

+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
    *state = NULL;
-    
-    return 0;
 }

 static void check_csync_init(void **state)
 {
    CSYNC *csync = *state;

-    csync_init(csync, "");
+    csync_init(csync);

    assert_int_equal(csync->status & CSYNC_STATUS_INIT, 1);
-
 }

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_init, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_init, setup_module, teardown),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_init, setup, teardown),
+        unit_test_setup_teardown(check_csync_init, setup_module, teardown),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -26,21 +26,22 @@
 #include "csync_log.c"
 #include "c_private.h"

-static int setup(void **state) {
+static void setup(void **state) {
    CSYNC *csync;
    int rc;

    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    *state = csync;
-    
-    return 0;
 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc;

@@ -52,9 +53,10 @@ static int teardown(void **state) {
    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);

+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
    *state = NULL;
-    
-    return 0;
 }

 static void check_log_callback(int verbosity,
@@ -138,11 +140,11 @@ static void check_logging(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test(check_set_log_level),
-        cmocka_unit_test(check_set_auth_callback),
-        cmocka_unit_test_setup_teardown(check_logging, setup, teardown),
+    const UnitTest tests[] = {
+        unit_test(check_set_log_level),
+        unit_test(check_set_auth_callback),
+        unit_test_setup_teardown(check_logging, setup, teardown),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }
@@ -48,10 +48,10 @@ static void check_csync_normalize_etag(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test(check_csync_normalize_etag),
+    const UnitTest tests[] = {
+        unit_test(check_csync_normalize_etag),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -26,7 +26,7 @@

 #define TESTDB "/tmp/check_csync1/test.db"

-static int setup(void **state) {
+static void setup(void **state) {
    CSYNC *csync;
    int rc;

@@ -36,7 +36,7 @@ static int setup(void **state) {
    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");

    csync->statedb.file = c_strdup( TESTDB );
    *state = csync;
@@ -47,11 +47,9 @@ static int setup(void **state) {

    rc = sqlite3_close(db);
    assert_int_equal(rc, SQLITE_OK);
-
-    return 0;
 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc;

@@ -62,8 +60,6 @@ static int teardown(void **state) {
    assert_int_equal(rc, 0);

    *state = NULL;
-    
-    return 0;
 }

 static void check_csync_statedb_load(void **state)
@@ -120,11 +116,11 @@ static void check_csync_statedb_close(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_statedb_load, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_close, setup, teardown),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_statedb_load, setup, teardown),
+        unit_test_setup_teardown(check_csync_statedb_close, setup, teardown),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -27,19 +27,23 @@



-static int setup(void **state)
+static void setup(void **state)
 {
    CSYNC *csync;
    int rc = 0;

    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
    rc = system("mkdir -p /tmp/check_csync");
    assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp/check_csync1");
-    csync_init(csync, TESTDB);
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
+    csync_init(csync);

    sqlite3 *db = NULL;
    rc = sqlite3_open_v2(TESTDB, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
@@ -51,11 +55,9 @@ static int setup(void **state)
    assert_int_equal(rc, 0);

    *state = csync;
-    
-    return 0;
 }

-static int setup_db(void **state)
+static void setup_db(void **state)
 {
    char *errmsg;
    int rc = 0;
@@ -91,12 +93,10 @@ static int setup_db(void **state)
    assert_int_equal(rc, SQLITE_OK);

    sqlite3_close(db);
-    
-    return 0;

 }

-static int teardown(void **state) {
+static void teardown(void **state) {
    CSYNC *csync = *state;
    int rc = 0;

@@ -106,10 +106,10 @@ static int teardown(void **state) {
    assert_int_equal(rc, 0);
    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);

    *state = NULL;
-    
-    return 0;
 }


@@ -210,15 +210,15 @@ static void check_csync_statedb_get_stat_by_inode_not_found(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_statedb_query_statement, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_drop_tables, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_insert_metadata, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_write, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_get_stat_by_hash_not_found, setup_db, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_statedb_get_stat_by_inode_not_found, setup_db, teardown),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_statedb_query_statement, setup, teardown),
+        unit_test_setup_teardown(check_csync_statedb_drop_tables, setup, teardown),
+        unit_test_setup_teardown(check_csync_statedb_insert_metadata, setup, teardown),
+        unit_test_setup_teardown(check_csync_statedb_write, setup, teardown),
+        unit_test_setup_teardown(check_csync_statedb_get_stat_by_hash_not_found, setup_db, teardown),
+        unit_test_setup_teardown(check_csync_statedb_get_stat_by_inode_not_found, setup_db, teardown),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -81,7 +81,7 @@ static void statedb_insert_metadata(sqlite3 *db)
    }
 }

-static int setup(void **state)
+static void setup(void **state)
 {
    CSYNC *csync;
    int rc;
@@ -91,8 +91,10 @@ static int setup(void **state)
    assert_int_equal(rc, 0);
    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp/check_csync1");
-    csync_init(csync, TESTDB);
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
+    csync_init(csync);

    /* Create a new db with metadata */
    sqlite3 *db;
@@ -109,11 +111,9 @@ static int setup(void **state)
    assert_int_equal(rc, 0);

    *state = csync;
-    
-    return 0;
 }

-static int setup_ftw(void **state)
+static void setup_ftw(void **state)
 {
    CSYNC *csync;
    int rc;
@@ -122,8 +122,10 @@ static int setup_ftw(void **state)
    assert_int_equal(rc, 0);
    rc = system("mkdir -p /tmp/check_csync1");
    assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp");
-    csync_init(csync, TESTDB);
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+    csync_create(&csync, "/tmp", "/tmp");
+    csync_init(csync);

    sqlite3 *db = NULL;
    rc = sqlite3_open_v2(TESTDB, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
@@ -137,11 +139,9 @@ static int setup_ftw(void **state)

    csync->statedb.file = c_strdup( TESTDB );
    *state = csync;
-    
-    return 0;
 }

-static int teardown(void **state)
+static void teardown(void **state)
 {
    CSYNC *csync = *state;
    int rc;
@@ -151,11 +151,9 @@ static int teardown(void **state)
    assert_int_equal(rc, 0);

    *state = NULL;
-    
-    return 0;
 }

-static int teardown_rm(void **state) {
+static void teardown_rm(void **state) {
    int rc;

    teardown(state);
@@ -164,8 +162,8 @@ static int teardown_rm(void **state) {
    assert_int_equal(rc, 0);
    rc = system("rm -rf /tmp/check_csync1");
    assert_int_equal(rc, 0);
-    
-    return 0;
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
 }

 /* create a file stat, caller must free memory */
@@ -432,19 +430,19 @@ static void check_csync_ftw_failing_fn(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test_setup_teardown(check_csync_detect_update, setup, teardown_rm),
-        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_none, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_eval, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_rename, setup, teardown),
-        cmocka_unit_test_setup_teardown(check_csync_detect_update_db_new, setup, teardown_rm),
-        cmocka_unit_test_setup_teardown(check_csync_detect_update_null, setup, teardown_rm),
+    const UnitTest tests[] = {
+        unit_test_setup_teardown(check_csync_detect_update, setup, teardown_rm),
+        unit_test_setup_teardown(check_csync_detect_update_db_none, setup, teardown),
+        unit_test_setup_teardown(check_csync_detect_update_db_eval, setup, teardown),
+        unit_test_setup_teardown(check_csync_detect_update_db_rename, setup, teardown),
+        unit_test_setup_teardown(check_csync_detect_update_db_new, setup, teardown_rm),
+        unit_test_setup_teardown(check_csync_detect_update_null, setup, teardown_rm),

-        cmocka_unit_test_setup_teardown(check_csync_ftw, setup_ftw, teardown_rm),
-        cmocka_unit_test_setup_teardown(check_csync_ftw_empty_uri, setup_ftw, teardown_rm),
-        cmocka_unit_test_setup_teardown(check_csync_ftw_failing_fn, setup_ftw, teardown_rm),
+        unit_test_setup_teardown(check_csync_ftw, setup_ftw, teardown_rm),
+        unit_test_setup_teardown(check_csync_ftw_empty_uri, setup_ftw, teardown_rm),
+        unit_test_setup_teardown(check_csync_ftw_failing_fn, setup_ftw, teardown_rm),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -43,11 +43,11 @@ static void check_csync_memstat(void **state)

 int torture_run_tests(void)
 {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test(check_csync_instruction_str),
-        cmocka_unit_test(check_csync_memstat),
+    const UnitTest tests[] = {
+        unit_test(check_csync_instruction_str),
+        unit_test(check_csync_memstat),
    };

-    return cmocka_run_group_tests(tests, NULL, NULL);
+    return run_tests(tests);
 }

@@ -457,7 +457,6 @@ sub traverse( $$;$ )

 	$isHere = 1 if( $acceptConflicts && !$isHere && $f =~ /_conflict/ );
 	$isHere = 1 if( $f =~ /\.csync/ );
-	$isHere = 1 if( $f =~ /\._sync_/ );
 	assert( $isHere, "Filename local, but not remote: $f" );
    }

@@ -176,7 +176,7 @@ assertLocalAndRemoteDir( 'remoteToLocal1', 1);

 printInfo("simulate a owncloud 5 update by removing all the fileid");
 ## simulate a owncloud 5 update by removing all the fileid
-system( "sqlite3 " . localDir() . "._sync_*.db \"UPDATE metadata SET fileid='';\"");
+system( "sqlite3 " . localDir() . ".csync_journal.db \"UPDATE metadata SET fileid='';\"");
 #refresh the ids
 csync();
 assertLocalAndRemoteDir( 'remoteToLocal1', 1);
@@ -61,7 +61,7 @@ sub getETagFromJournal($$)
 {
    my ($name,$num) = @_;

-    my $sql = "sqlite3 " . localDir() . "._sync_*.db \"SELECT md5 FROM metadata WHERE path='$name';\"";
+    my $sql = "sqlite3 " . localDir() . ".csync_journal.db \"SELECT md5 FROM metadata WHERE path='$name';\"";
    open(my $fh, '-|', $sql) or die $!;
    my $etag  = <$fh>;
    close $fh;
@@ -37,8 +37,8 @@ sub assertCsyncJournalOk {
 	my $path = $_[0];

    # FIXME: should test also remoteperm but it's not working with owncloud6
-    #     my $cmd = 'sqlite3 ' . $path . '._sync_*.db "SELECT count(*) from metadata where length(remotePerm) == 0 or length(fileId) == 0"';
-    my $cmd = 'sqlite3 ' . $path . '._sync_*.db "SELECT count(*) from metadata where length(fileId) == 0"';
+    #     my $cmd = 'sqlite3 ' . $path . '.csync_journal.db "SELECT count(*) from metadata where length(remotePerm) == 0 or length(fileId) == 0"';
+    my $cmd = 'sqlite3 ' . $path . '.csync_journal.db "SELECT count(*) from metadata where length(fileId) == 0"';
 	my $result = `$cmd`;
 	assert($result == "0");
 }
@@ -170,14 +170,14 @@ assertLocalAndRemoteDir( '', 0);

 #######################################################################
 printInfo( "move a directory in a outside read only folder" );
-system("sqlite3 " . localDir().'._sync_*.db .dump');
+system("sqlite3 " . localDir().'.csync_journal.db .dump');

 #Missing directory should be restored
 #new directory should be uploaded
 system("mv " . localDir().'readonlyDirectory_PERM_M_/subdir_PERM_CK_ ' . localDir().'normalDirectory_PERM_CKDNV_/subdir_PERM_CKDNV_'  );

 csync();
-system("sqlite3 " . localDir().'._sync_*.db .dump');
+system("sqlite3 " . localDir().'.csync_journal.db .dump');
 assertCsyncJournalOk(localDir());

 # old name restored
@@ -229,7 +229,7 @@ system("rm -r " . localDir(). "readonlyDirectory_PERM_M_/moved_PERM_CK_");

 assertLocalAndRemoteDir( '', 0);

-system("sqlite3 " . localDir().'._sync_*.db .dump');
+system("sqlite3 " . localDir().'.csync_journal.db .dump');


 #######################################################################
@@ -48,7 +48,7 @@ static void setup(void **state)
    rc = system("rm -rf /tmp/csync_test");
    assert_int_equal(rc, 0);

-    csync_create(&csync, "/tmp/csync1");
+    csync_create(&csync, "/tmp/csync1", "/tmp/csync2");

    csync->replica = LOCAL_REPLICA;

@@ -96,7 +96,7 @@ static void setup_testenv(void **state) {
    statevar *mystate = malloc( sizeof(statevar) );
    mystate->result = NULL;

-    csync_create(&(mystate->csync), "/tmp/csync1");
+    csync_create(&(mystate->csync), "/tmp/csync1", "/tmp/csync2");

    mystate->csync->replica = LOCAL_REPLICA;

@@ -153,8 +153,7 @@ By default, the ownCloud Client ignores the following files:

 * Files matched by one of the patterns defined in the Ignored Files Editor
 * Files containing characters that do not work on certain file systems ``(`\, /, :, ?, *, ", >, <, |`)``.
-* Files starting with ``._sync_xxxxxxx.db`` and the old format ``.csync_journal.db``, 
-as these files are reserved for journalling.
+* Files starting with ``.csync_journal.db``, as these files are reserved for journalling.

 If a pattern selected using a checkbox in the `ignoredFilesEditor-label` (or if
 a line in the exclude file starts with the character ``]`` directly followed by
@@ -83,7 +83,7 @@ To set up your build environment for development using HomeBrew_:

 3. Add Qt from brew to the path::

-    export PATH=/usr/local/Cellar/qt5/5.x.y/bin:$PATH
+    export PATH=/usr/local/Cellar/qt5/5.x.y/bin/qmake

   Where ``x.z`` is the current version of Qt 5 that brew has installed
   on your machine.
@@ -100,7 +100,7 @@ To set up your build environment for development using HomeBrew_:
   its Common Name as a third parameter (use quotes) to have the package
   signed automatically.

-  .. note::  Contrary to earlier versions, ownCloud 1.7 and later are packaged
+   .. note:: Contrary to earlier versions, ownCloud 1.7 and later are packaged
             as a ``pkg`` installer. Do not call "make package" at any time when
             compiling for OS X, as this will build a disk image, and will not
             work correctly.
@@ -249,10 +249,6 @@ To build the most up-to-date version of the client:

   .. note:: Example:: cmake -DCMAKE_PREFIX_PATH=/usr/local/opt/qt5 -DCMAKE_INSTALL_PREFIX=/Users/path/to/client/install/  -D_OPENSSL_LIBDIR=/usr/local/opt/openssl/lib/ -D_OPENSSL_INCLUDEDIR=/usr/local/opt/openssl/include/   -DOPENSSL_INCLUDE_DIR=/usr/local/opt/openssl/include/ -DNO_SHIBBOLETH=1

-   .. note:: Example:: cmake -DCMAKE_PREFIX_PATH=/usr/local/opt/qt5 -DCMAKE_INSTALL_PREFIX=/Users/path/to/client/install/  -D_OPENSSL_LIBDIR=/usr/local/opt/openssl/lib/ -D_OPENSSL_INCLUDEDIR=/usr/local/opt/openssl/include/  -D_OPENSSL_VERSION=1.0.2a -DOPENSSL_INCLUDE_DIR=/usr/local/opt/openssl/include/ -DNO_SHIBBOLETH=1
-
-   qtkeychain must be compiled with the same prefix e.g CMAKE_INSTALL_PREFIX=/Users/path/to/client/install/ .
-
 4. Call ``make``.

   The owncloud binary will appear in the ``bin`` directory.
@@ -12,7 +12,7 @@ Desktop Sync client enables you to:
 Your files are always automatically synchronized between your ownCloud server 
 and local PC.

-Because of various technical issues, desktop sync clients older than 2.2.1 will 
+Because of various technical issues, desktop sync clients older than 1.7 will 
 not allowed to connect and sync with the ownCloud 8.1+ server. It is highly 
 recommended to keep your client updated.

@@ -65,7 +65,7 @@ If no client is configured, or if you choose to use a different user to synchron
 you can specify the user
 password setting with the usual URL pattern.  For example::

-  $ owncloudcmd /home/user/my_sync_folder https://carla:secret@server/owncloud/remote.php/webdav/
+  $ owncloudcmd / https://carla:secret@server/owncloud/remote.php/webdav/

 To synchronize the ownCloud directory ``Music`` to the local directory
 ``media/music``, through a proxy listening on port ``8080``, and on a gateway
@@ -502,120 +502,6 @@ X-GNOME-Autostart-Delay=3
 # Translations


-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
 # Translations
 Comment[oc]=@APPLICATION_NAME@ sincronizacion del client
 GenericName[oc]=Dorsièr de Sincronizacion
@@ -49,6 +49,5 @@ target_link_libraries(${OWNCLOUDDOLPHINOVERLAYPLUGIN} KF5::CoreAddons KF5::KIOCo
 set(OWNCLOUDDOLPHINACTIONPLUGIN ${APPLICATION_EXECUTABLE}dolphinactionplugin)
 add_library(${OWNCLOUDDOLPHINACTIONPLUGIN} MODULE ownclouddolphinactionplugin.cpp)
 target_link_libraries(${OWNCLOUDDOLPHINACTIONPLUGIN} KF5::CoreAddons KF5::KIOCore KF5::KIOWidgets ${OWNCLOUDDOLPHINHELPER})
-configure_file(ownclouddolphinactionplugin.desktop.in ${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop ESCAPE_QUOTES @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR})
+install(FILES ownclouddolphinactionplugin.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR} RENAME ${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop)
 install(TARGETS ${OWNCLOUDDOLPHINACTIONPLUGIN} DESTINATION ${KDE_INSTALL_PLUGINDIR})
@@ -1,6 +1,6 @@
 [Desktop Entry]
 Type=Service
-Name=@APPLICATION_NAME@Action
+Name=OwncloudAction
 ServiceTypes=KFileItemAction/Plugin
 MimeType=application/octet-stream;inode/directory;
-X-KDE-Library=@APPLICATION_EXECUTABLE@dolphinactionplugin
+X-KDE-Library=ownclouddolphinactionplugin
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) by Pierre MOREAU <p.moreau@agim.idshost.fr>
+ *
+ * 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; version 2 of the License.
+ *
+ * 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.
+ */
+
+/**
+ * \file p12topem.cpp
+ * \brief Static library to convert p12 to pem
+ * \author Pierre MOREAU <p.moreau@agim.idshost.fr>
+ * \version 1.0.0
+ * \date 09 January 2014
+ */
+
+#include "p12topem.h"
+
+/**
+ * \fn string x509ToString (BIO)
+ * \brief Return string from BIO SSL
+ * \param BIO o PEM_write_BIO_...
+ * \return string PEM
+ */
+string x509ToString(BIO *o) {
+    BUF_MEM *bptr;
+    BIO_get_mem_ptr(o, &bptr);
+    int len = bptr->length;
+    void* data = calloc(len+10, sizeof(char));
+    BIO_read(o, data, len);
+    string ret = std::string(static_cast<char*>(data));
+    free(data);
+        
+    return ret;
+}
+
+/**
+ * \fn resultP12ToPem p12ToPem (string, string)
+ * \brief Convert P12 to PEM
+ * \param string p12File Path to P12 file
+ * \param string p12Passwd Password to open P12 file
+ * \return result (bool ReturnCode, Int ErrorCode, String Comment, String PrivateKey, String Certificate)
+ */
+resultP12ToPem p12ToPem(string p12File, string p12Passwd) {
+    FILE *fp;
+    PKCS12 *p12 = NULL;
+    EVP_PKEY *pkey = NULL;
+    X509 *cert = NULL;
+    STACK_OF(X509) *ca = NULL;
+    
+    BIO *o = BIO_new(BIO_s_mem());
+    
+    string privateKey = "";
+    string certificate = "";
+        
+    resultP12ToPem ret;
+    ret.ReturnCode = false;
+    ret.ErrorCode = 0;
+    ret.Comment = "";
+    ret.PrivateKey = "";
+    ret.Certificate = "";
+    
+    SSLeay_add_all_algorithms();
+    ERR_load_crypto_strings();
+    if(!(fp = fopen(p12File.c_str(), "rb"))) {
+        ret.ErrorCode = 1;
+        ret.Comment = strerror(errno);
+        return ret;
+    }
+    
+    p12 = d2i_PKCS12_fp(fp, &p12);
+    fclose (fp);
+    
+    if (!p12) {
+        ret.ErrorCode = 2;
+        ret.Comment = "Unable to open PKCS#12 file";
+        return ret;
+    }
+    if (!PKCS12_parse(p12, p12Passwd.c_str(), &pkey, &cert, &ca)) {
+        ret.ErrorCode = 3;
+        ret.Comment = "Unable to parse PKCS#12 file (wrong password ?)";
+        return ret;
+    }
+    PKCS12_free(p12);
+    
+    if (!(pkey && cert)) {
+        ret.ErrorCode = 4;
+        ret.Comment = "Certificate and/or key file doesn't exists";
+    } else {
+        PEM_write_bio_PrivateKey(o, pkey, 0, 0, 0, NULL, 0);
+        privateKey = x509ToString(o);
+                
+        PEM_write_bio_X509(o, cert);
+        certificate = x509ToString(o);
+        
+        BIO_free(o);
+        
+        ret.ReturnCode = true;
+        ret.ErrorCode = 0;
+        ret.Comment = "All is fine";
+        ret.PrivateKey = privateKey;
+        ret.Certificate = certificate;
+    }
+    return ret;
+}
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) by Pierre MOREAU <p.moreau@agim.idshost.fr>
+ *
+ * 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; version 2 of the License.
+ *
+ * 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.
+ */
+
+#ifndef P12TOPEM_H
+#define	P12TOPEM_H
+
+/**
+ * \file p12topem.h
+ * \brief Static library to convert p12 to pem
+ * \author Pierre MOREAU <p.moreau@agim.idshost.fr>
+ * \version 1.0.0
+ * \date 09 January 2014
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+#include <openssl/pkcs12.h>
+
+using namespace std;
+
+/**
+ * \struct resultP12ToPem p12topem.h
+ */
+struct resultP12ToPem {
+    bool ReturnCode;
+    int ErrorCode;
+    string Comment;
+    string PrivateKey;
+    string Certificate;
+};
+
+/**
+ * \brief Return string from BIO SSL
+ * \param BIO o PEM_write_BIO_...
+ * \return string PEM
+ */
+string x509ToString(BIO *o);
+
+/**
+ * \brief Convert P12 to PEM
+ * \param string p12File Path to P12 file
+ * \param string p12Passwd Password to open P12 file
+ * \return result (bool ReturnCode, Int ErrorCode, String Comment, String PrivateKey, String Certificate)
+ */
+resultP12ToPem p12ToPem(string p12File, string p12Passwd);
+
+#endif	/* P12TOPEM_H */
+
@@ -121,7 +121,7 @@ QString queryPassword(const QString &user)
 class HttpCredentialsText : public HttpCredentials {
 public:
    HttpCredentialsText(const QString& user, const QString& password)
-        : HttpCredentials(user, password), // FIXME: not working with client certs yet (qknight)
+        : HttpCredentials(user, password, "", ""), // FIXME: not working with client certs yet (qknight)
          _sslTrusted(false)
    {}

@@ -278,6 +278,7 @@ void selectiveSyncFixup(OCC::SyncJournalDb *journal, const QStringList &newList)
    }
 }

+
 int main(int argc, char **argv) {
    QCoreApplication app(argc, argv);

@@ -328,7 +329,8 @@ int main(int argc, char **argv) {
    if( !options.target_url.contains( account->davPath() )) {
        options.target_url.append(account->davPath());
    }
-
+    if (options.target_url.startsWith("http"))
+        options.target_url.replace(0, 4, "owncloud");
    QUrl url = QUrl::fromUserInput(options.target_url);

    // Order of retrieval attempt (later attempts override earlier ones):
@@ -369,24 +371,23 @@ int main(int argc, char **argv) {
         }
     }

+    // ### ensure URL is free of credentials
+    if (url.userName().isEmpty()) {
+        url.setUserName(user);
+    }
+    if (url.password().isEmpty()) {
+        url.setPassword(password);
+    }
+
    // take the unmodified url to pass to csync_create()
    QByteArray remUrl = options.target_url.toUtf8();

    // Find the folder and the original owncloud url
-    QStringList splitted = url.path().split("/" + account->davPath());
+    QStringList splitted = url.path().split(account->davPath());
    url.setPath(splitted.value(0));

    url.setScheme(url.scheme().replace("owncloud", "http"));
-
-    QUrl credentialFreeUrl = url;
-    credentialFreeUrl.setUserName(QString());
-    credentialFreeUrl.setPassword(QString());
-
-    // Remote folders typically start with a / and don't end with one
-    QString folder = "/" + splitted.value(1);
-    if (folder.endsWith("/") && folder != "/") {
-        folder.chop(1);
-    }
+    QString folder = splitted.value(1);

    SimpleSslErrorHandler *sslErrorHandler = new SimpleSslErrorHandler;

@@ -469,14 +470,12 @@ restart_sync:
    }

    Cmd cmd;
-    QString dbPath = options.source_dir + SyncJournalDb::makeDbName(credentialFreeUrl, folder, user);
-    SyncJournalDb db(dbPath);
-
+    SyncJournalDb db(options.source_dir);
    if (!selectiveSyncList.empty()) {
        selectiveSyncFixup(&db, selectiveSyncList);
    }

-    SyncEngine engine(account, options.source_dir, folder, &db);
+    SyncEngine engine(account, options.source_dir, QUrl(options.target_url), folder, &db);
    engine.setIgnoreHiddenFiles(options.ignoreHiddenFiles);
    QObject::connect(&engine, SIGNAL(finished(bool)), &app, SLOT(quit()));
    QObject::connect(&engine, SIGNAL(transmissionProgress(ProgressInfo)), &cmd, SLOT(transmissionProgressSlot()));
@@ -507,7 +506,7 @@ restart_sync:

    app.exec();

-    if (engine.isAnotherSyncNeeded() != NoFollowUpSync) {
+    if (engine.isAnotherSyncNeeded()) {
        if (restartCount < options.restartTimes) {
            restartCount++;
            qDebug() << "Restarting Sync, because another sync is needed" << restartCount;
@@ -151,6 +151,7 @@ set(3rdparty_SRC
    ../3rdparty/qtsingleapplication/qtlocalpeer.cpp
    ../3rdparty/qtsingleapplication/qtsingleapplication.cpp
    ../3rdparty/qtsingleapplication/qtsinglecoreapplication.cpp
+    ../3rdparty/certificates/p12topem.cpp
   )

 if (APPLE)
@@ -214,17 +214,6 @@ AccountPtr AccountManager::loadAccountHelper(QSettings& settings)
    auto acc = createAccount();

    QString authType = settings.value(QLatin1String(authTypeC)).toString();
-
-    // There was an account-type saving bug when 'skip folder config' was used
-    // See #5408. This attempts to fix up the "dummy" authType
-    if (authType == QLatin1String("dummy")) {
-        if (settings.contains(QLatin1String("http_user"))) {
-            authType = "http";
-        } else if (settings.contains(QLatin1String("shibboleth_shib_user"))) {
-            authType = "shibboleth";
-        }
-    }
-
    QString overrideUrl = Theme::instance()->overrideServerUrl();
    QString forceAuth = Theme::instance()->forceConfigAuthType();
    if(!forceAuth.isEmpty() && !overrideUrl.isEmpty() ) {
@@ -248,7 +237,7 @@ AccountPtr AccountManager::loadAccountHelper(QSettings& settings)

    acc->setCredentials(CredentialsFactory::create(authType));

-    // now the server cert, it is in the general group
+    // now the cert, it is in the general group
    settings.beginGroup(QLatin1String("General"));
    acc->setApprovedCerts(QSslCertificate::fromData(settings.value(caCertsKeyC).toByteArray()));
    settings.endGroup();
@@ -31,7 +31,6 @@
 #include "owncloudsetupwizard.h"
 #include "creds/abstractcredentials.h"
 #include "tooltipupdater.h"
-#include "filesystem.h"

 #include <math.h>

@@ -111,7 +110,7 @@ AccountSettings::AccountSettings(AccountState *accountState, QWidget *parent) :

    QAction *syncNowAction = new QAction(this);
    syncNowAction->setShortcut(QKeySequence(Qt::Key_F6));
-    connect(syncNowAction, SIGNAL(triggered()), SLOT(slotScheduleCurrentFolder()));
+    connect(syncNowAction, SIGNAL(triggered()), SLOT(slotSyncCurrentFolderNow()));
    addAction(syncNowAction);

    connect(ui->_folderList, SIGNAL(clicked(const QModelIndex &)),
@@ -214,10 +213,8 @@ void AccountSettings::slotCustomContextMenuRequested(const QPoint &pos)
    }

    tv->setCurrentIndex(index);
-    QString alias = _model->data( index, FolderStatusDelegate::FolderAliasRole ).toString();
    bool folderPaused = _model->data( index, FolderStatusDelegate::FolderSyncPaused).toBool();
    bool folderConnected = _model->data( index, FolderStatusDelegate::FolderAccountConnected ).toBool();
-    auto folderMan = FolderMan::instance();

    QMenu *menu = new QMenu(tv);
    menu->setAttribute(Qt::WA_DeleteOnClose);
@@ -231,15 +228,6 @@ void AccountSettings::slotCustomContextMenuRequested(const QPoint &pos)
        connect(ac, SIGNAL(triggered(bool)), this, SLOT(doExpand()));
    }

-    if (!folderPaused) {
-        ac = menu->addAction(tr("Force sync now"));
-        if (folderMan->currentSyncFolder() == folderMan->folder(alias)) {
-            ac->setText(tr("Restart sync"));
-        }
-        ac->setEnabled(folderConnected);
-        connect(ac, SIGNAL(triggered(bool)), this, SLOT(slotForceSyncCurrentFolder()));
-    }
-
    ac = menu->addAction(folderPaused ? tr("Resume sync") : tr("Pause sync"));
    connect(ac, SIGNAL(triggered(bool)), this, SLOT(slotEnableCurrentFolder()));

@@ -301,8 +289,7 @@ void AccountSettings::slotFolderWizardAccepted()
    FolderDefinition definition;
    definition.localPath    = FolderDefinition::prepareLocalPath(
            folderWizard->field(QLatin1String("sourceFolder")).toString());
-    definition.targetPath   = FolderDefinition::prepareTargetPath(
-            folderWizard->property("targetPath").toString());
+    definition.targetPath   = folderWizard->property("targetPath").toString();

    {
        QDir dir(definition.localPath);
@@ -313,9 +300,8 @@ void AccountSettings::slotFolderWizardAccepted()
                                     tr("<p>Could not create local folder <i>%1</i>.")
                                        .arg(QDir::toNativeSeparators(definition.localPath)));
                return;
-            } else {
-                FileSystem::setFolderMinimumPermissions(definition.localPath);
            }
+
        }
    }

@@ -475,7 +461,7 @@ void AccountSettings::slotEnableCurrentFolder()
    }
 }

-void AccountSettings::slotScheduleCurrentFolder()
+void AccountSettings::slotSyncCurrentFolderNow()
 {
    QModelIndex selected = ui->_folderList->selectionModel()->currentIndex();
    if( !selected.isValid() )
@@ -486,24 +472,6 @@ void AccountSettings::slotScheduleCurrentFolder()
    folderMan->scheduleFolder(folderMan->folder(alias));
 }

-void AccountSettings::slotForceSyncCurrentFolder()
-{
-    QModelIndex selected = ui->_folderList->selectionModel()->currentIndex();
-    if( !selected.isValid() )
-        return;
-    QString alias = _model->data( selected, FolderStatusDelegate::FolderAliasRole ).toString();
-    FolderMan *folderMan = FolderMan::instance();
-
-    // Terminate and reschedule any running sync
-    if (Folder* current = folderMan->currentSyncFolder()) {
-        folderMan->terminateSyncProcess();
-        folderMan->scheduleFolder(current);
-    }
-
-    // Insert the selected folder at the front of the queue
-    folderMan->scheduleFolderNext(folderMan->folder(alias));
-}
-
 void AccountSettings::slotOpenOC()
 {
  if( _OCUrl.isValid() )
@@ -71,8 +71,7 @@ public slots:
 protected slots:
    void slotAddFolder();
    void slotEnableCurrentFolder();
-    void slotScheduleCurrentFolder();
-    void slotForceSyncCurrentFolder();
+    void slotSyncCurrentFolderNow();
    void slotRemoveCurrentFolder();
    void slotOpenCurrentFolder();
    void slotFolderWizardAccepted();
@@ -617,7 +617,7 @@ void ActivitySettings::slotCopyToClipboard()
        message = tr("The sync activity list has been copied to the clipboard.");
    } else if(idx == 2 ) {
        // issues Widget
-        message = tr("The list of unsynced items has been copied to the clipboard.");
+        message = tr("The list of unsynched items has been copied to the clipboard.");
       _protocolWidget->storeSyncIssues(ts);
    }

@@ -10,7 +10,7 @@
    <x>0</x>
    <y>0</y>
    <width>462</width>
-    <height>188</height>
+    <height>186</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -32,7 +32,7 @@
     <item row="0" column="0">
      <widget class="QLabel" name="labelCertificateFile">
       <property name="text">
-        <string>Certificate &amp; Key (pkcs12) :</string>
+        <string>Certificate :</string>
       </property>
      </widget>
     </item>
@@ -347,6 +347,14 @@ void Application::slotownCloudWizardDone( int res )
    }
 }

+static void csyncLogCatcher(int /*verbosity*/,
+                        const char */*function*/,
+                        const char *buffer,
+                        void */*userdata*/)
+{
+    Logger::instance()->csyncLog( QString::fromUtf8(buffer) );
+}
+
 void Application::setupLogging()
 {
    // might be called from second instance
@@ -362,6 +370,10 @@ void Application::setupLogging()
                .arg(property("ui_lang").toString())
                .arg(_theme->version())
                .arg(Utility::platformName());
+
+    // Setup CSYNC logging to forward to our own logger
+    csync_set_log_callback( csyncLogCatcher );
+    csync_set_log_level( Logger::instance()->isNoop() ? 0 : 11 );
 }

 void Application::slotUseMonoIconsChanged(bool)
@@ -27,7 +27,7 @@ class HttpCredentialsGui : public HttpCredentials {
    Q_OBJECT
 public:
    explicit HttpCredentialsGui() : HttpCredentials() {}
-    HttpCredentialsGui(const QString& user, const QString& password, const QSslCertificate& certificate, const QSslKey& key) : HttpCredentials(user, password, certificate, key) {}
+    HttpCredentialsGui(const QString& user, const QString& password, const QString& certificatePath, const QString& certificatePasswd) : HttpCredentials(user, password, certificatePath, certificatePasswd) {}
    void askFromUser() Q_DECL_OVERRIDE;
    Q_INVOKABLE void askFromUserAsync();

@@ -46,7 +46,6 @@

 namespace OCC {

-const char oldJournalPath[] = ".csync_journal.db";

 Folder::Folder(const FolderDefinition& definition,
               AccountState* accountState,
@@ -61,10 +60,12 @@ Folder::Folder(const FolderDefinition& definition,
      , _lastSyncDuration(0)
      , _consecutiveFailingSyncs(0)
      , _consecutiveFollowUpSyncs(0)
-      , _journal(_definition.absoluteJournalPath())
+      , _journal(definition.localPath)
      , _fileLog(new SyncRunFileLog)
-      , _saveBackwardsCompatible(false)
 {
+    qRegisterMetaType<SyncFileItemVector>("SyncFileItemVector");
+    qRegisterMetaType<SyncFileItem::Direction>("SyncFileItem::Direction");
+
    qsrand(QTime::currentTime().msec());
    _timeSinceLastSyncStart.start();
    _timeSinceLastSyncDone.start();
@@ -80,7 +81,7 @@ Folder::Folder(const FolderDefinition& definition,

    _syncResult.setFolder(_definition.alias);

-    _engine.reset(new SyncEngine(_accountState->account(), path(), remotePath(), &_journal));
+    _engine.reset(new SyncEngine(_accountState->account(), path(), remoteUrl(), remotePath(), &_journal));
    // pass the setting if hidden files are to be ignored, will be read in csync_update
    _engine->setIgnoreHiddenFiles(_definition.ignoreHiddenFiles);

@@ -123,7 +124,6 @@ Folder::~Folder()
    _engine.reset();
 }

-
 void Folder::checkLocalPath()
 {
    const QFileInfo fi(_definition.localPath);
@@ -203,7 +203,7 @@ void Folder::setIgnoreHiddenFiles(bool ignore)
    _definition.ignoreHiddenFiles = ignore;
 }

-QString Folder::cleanPath() const
+QString Folder::cleanPath()
 {
    QString cleanedPath = QDir::cleanPath(_canonicalLocalPath);

@@ -584,33 +584,8 @@ void Folder::slotThreadTreeWalkResult(const SyncFileItemVector& items)

 void Folder::saveToSettings() const
 {
-    // Remove first to make sure we don't get duplicates
-    removeFromSettings();
-
    auto settings = _accountState->settings();
-
-    // The folder is saved to backwards-compatible "Folders"
-    // section only if it has the migrate flag set (i.e. was in
-    // there before) or if the folder is the only one for the
-    // given target path.
-    // This ensures that older clients will not read a configuration
-    // where two folders for different accounts point at the same
-    // local folders.
-    bool oneAccountOnly = true;
-    foreach (Folder* other, FolderMan::instance()->map()) {
-        if (other != this && other->cleanPath() == this->cleanPath()) {
-            oneAccountOnly = false;
-            break;
-        }
-    }
-
-    bool compatible = _saveBackwardsCompatible || oneAccountOnly;
-
-    if (compatible) {
-        settings->beginGroup(QLatin1String("Folders"));
-    } else {
-        settings->beginGroup(QLatin1String("Multifolders"));
-    }
+    settings->beginGroup(QLatin1String("Folders"));
    FolderDefinition::save(*settings, _definition);

    settings->sync();
@@ -619,12 +594,9 @@ void Folder::saveToSettings() const

 void Folder::removeFromSettings() const
 {
-    auto settings = _accountState->settings();
+    auto  settings = _accountState->settings();
    settings->beginGroup(QLatin1String("Folders"));
    settings->remove(FolderMan::escapeAlias(_definition.alias));
-    settings->endGroup();
-    settings->beginGroup(QLatin1String("Multifolders"));
-    settings->remove(FolderMan::escapeAlias(_definition.alias));
 }

 bool Folder::isFileExcludedAbsolute(const QString& fullPath) const
@@ -656,12 +628,12 @@ void Folder::slotTerminateSync()
 // local folder is synced to the same ownCloud.
 void Folder::wipe()
 {
-    QString stateDbFile = _engine->journal()->databaseFilePath();
+    QString stateDbFile = path()+QLatin1String(".csync_journal.db");

    // Delete files that have been partially downloaded.
    slotDiscardDownloadProgress();

-    //Unregister the socket API so it does not keep the ._sync_journal file open
+    //Unregister the socket API so it does not keep the .sync_journal file open
    FolderMan::instance()->socketApi()->slotUnregisterPath(alias());
    _journal.close(); // close the sync journal

@@ -823,7 +795,7 @@ void Folder::slotSyncFinished(bool success)
    _fileLog->finish();
    bubbleUpSyncResult();

-    auto anotherSyncNeeded = _engine->isAnotherSyncNeeded();
+    bool anotherSyncNeeded = _engine->isAnotherSyncNeeded();

    if (_csyncError) {
        _syncResult.setStatus(SyncResult::Error);
@@ -836,9 +808,6 @@ void Folder::slotSyncFinished(bool success)
    } else if( _syncResult.warnCount() > 0 ) {
        // there have been warnings on the way.
        _syncResult.setStatus(SyncResult::Problem);
-    } else if( _definition.paused ) {
-        // Maybe the sync was terminated because the user paused the folder
-        _syncResult.setStatus(SyncResult::Paused);
    } else {
        _syncResult.setStatus(SyncResult::Success);
    }
@@ -874,7 +843,7 @@ void Folder::slotSyncFinished(bool success)
    _timeSinceLastSyncDone.restart();

    // Increment the follow-up sync counter if necessary.
-    if (anotherSyncNeeded == ImmediateFollowUp) {
+    if (anotherSyncNeeded) {
        _consecutiveFollowUpSyncs++;
        qDebug() << "another sync was requested by the finished sync, this has"
                 << "happened" << _consecutiveFollowUpSyncs << "times";
@@ -883,7 +852,7 @@ void Folder::slotSyncFinished(bool success)
    }

    // Maybe force a follow-up sync to take place, but only a couple of times.
-    if (anotherSyncNeeded == ImmediateFollowUp && _consecutiveFollowUpSyncs <= 3)
+    if (anotherSyncNeeded && _consecutiveFollowUpSyncs <= 3)
    {
        // Sometimes another sync is requested because a local file is still
        // changing, so wait at least a small amount of time before syncing
@@ -981,11 +950,6 @@ void Folder::scheduleThisFolderSoon()
    }
 }

-void Folder::setSaveBackwardsCompatible(bool save)
-{
-    _saveBackwardsCompatible = save;
-}
-
 void Folder::slotAboutToRemoveAllFiles(SyncFileItem::Direction, bool *cancel)
 {
    ConfigFile cfgFile;
@@ -1038,7 +1002,6 @@ void FolderDefinition::save(QSettings& settings, const FolderDefinition& folder)
 {
    settings.beginGroup(FolderMan::escapeAlias(folder.alias));
    settings.setValue(QLatin1String("localPath"), folder.localPath);
-    settings.setValue(QLatin1String("journalPath"), folder.journalPath);
    settings.setValue(QLatin1String("targetPath"), folder.targetPath);
    settings.setValue(QLatin1String("paused"), folder.paused);
    settings.setValue(QLatin1String("ignoreHiddenFiles"), folder.ignoreHiddenFiles);
@@ -1051,7 +1014,6 @@ bool FolderDefinition::load(QSettings& settings, const QString& alias,
    settings.beginGroup(alias);
    folder->alias = FolderMan::unescapeAlias(alias);
    folder->localPath = settings.value(QLatin1String("localPath")).toString();
-    folder->journalPath = settings.value(QLatin1String("journalPath")).toString();
    folder->targetPath = settings.value(QLatin1String("targetPath")).toString();
    folder->paused = settings.value(QLatin1String("paused")).toBool();
    folder->ignoreHiddenFiles = settings.value(QLatin1String("ignoreHiddenFiles"), QVariant(true)).toBool();
@@ -1061,9 +1023,6 @@ bool FolderDefinition::load(QSettings& settings, const QString& alias,
    // code we assum /, so clean it up now.
    folder->localPath = prepareLocalPath(folder->localPath);

-    // Target paths also have a convention
-    folder->targetPath = prepareTargetPath(folder->targetPath);
-
    return true;
 }

@@ -1076,29 +1035,5 @@ QString FolderDefinition::prepareLocalPath(const QString& path)
    return p;
 }

-QString FolderDefinition::prepareTargetPath(const QString &path)
-{
-    QString p = path;
-    if (p.endsWith(QLatin1Char('/'))) {
-        p.chop(1);
-    }
-    // Doing this second ensures the empty string or "/" come
-    // out as "/".
-    if (!p.startsWith(QLatin1Char('/'))) {
-        p.prepend(QLatin1Char('/'));
-    }
-    return p;
-}
-
-QString FolderDefinition::absoluteJournalPath() const
-{
-    return QDir(localPath).filePath(journalPath);
-}
-
-QString FolderDefinition::defaultJournalPath(AccountPtr account)
-{
-    return SyncJournalDb::makeDbName(account->url(), targetPath, account->credentials()->user());
-}
-
 } // namespace OCC

@@ -53,8 +53,6 @@ public:
    QString alias;
    /// path on local machine
    QString localPath;
-    /// path to the journal, usually relative to localPath
-    QString journalPath;
    /// path on remote
    QString targetPath;
    /// whether the folder is paused
@@ -71,15 +69,6 @@ public:

    /// Ensure / as separator and trailing /.
    static QString prepareLocalPath(const QString& path);
-
-    /// Ensure starting / and no ending /.
-    static QString prepareTargetPath(const QString& path);
-
-    /// journalPath relative to localPath.
-    QString absoluteJournalPath() const;
-
-    /// Returns the relative journal path that's appropriate for this folder and account.
-    QString defaultJournalPath(AccountPtr account);
 };

 /**
@@ -122,7 +111,7 @@ public:
    /**
     * wrapper for QDir::cleanPath("Z:\\"), which returns "Z:\\", but we need "Z:" instead
     */
-    QString cleanPath() const;
+    QString cleanPath();

    /**
     * remote folder path
@@ -217,12 +206,6 @@ public:
      */
     void scheduleThisFolderSoon();

-     /**
-      * Migration: When this flag is true, this folder will save to
-      * the backwards-compatible 'Folders' section in the config file.
-      */
-     void setSaveBackwardsCompatible(bool save);
-
 signals:
    void syncStateChange();
    void syncStarted();
@@ -351,16 +334,6 @@ private:
    QScopedPointer<SyncRunFileLog> _fileLog;

    QTimer _scheduleSelfTimer;
-
-    /**
-     * When the same local path is synced to multiple accounts, only one
-     * of them can be stored in the settings in a way that's compatible
-     * with old clients that don't support it. This flag marks folders
-     * that shall be written in a backwards-compatible way, by being set
-     * on the *first* Folder instance that was configured for each local
-     * path.
-     */
-    bool _saveBackwardsCompatible;
 };

 }
@@ -148,7 +148,6 @@ int FolderMan::unloadAndDeleteAllFolders()
 void FolderMan::registerFolderMonitor( Folder *folder )
 {
    if( !folder ) return;
-    if( !QDir(folder->path()).exists() ) return;

    if( !_folderWatchers.contains(folder->alias() ) ) {
        FolderWatcher *fw = new FolderWatcher(folder->path(), folder);
@@ -210,16 +209,18 @@ int FolderMan::setupFolders()
            continue;
        }
        settings->beginGroup(id);
-
        settings->beginGroup(QLatin1String("Folders"));
-        setupFoldersHelper(*settings, account, true);
-        settings->endGroup();
-
-        // See Folder::saveToSettings for details about why this exists.
-        settings->beginGroup(QLatin1String("Multifolders"));
-        setupFoldersHelper(*settings, account, false);
-        settings->endGroup();
-
+        foreach (const auto& folderAlias, settings->childGroups()) {
+            FolderDefinition folderDefinition;
+            if (FolderDefinition::load(*settings, folderAlias, &folderDefinition)) {
+                Folder* f = addFolderInternal(std::move(folderDefinition), account.data());
+                if (f) {
+                    scheduleFolder(f);
+                    emit folderSyncStateChange(f);
+                }
+            }
+        }
+        settings->endGroup(); // Folders
        settings->endGroup(); // <account>
    }

@@ -228,34 +229,6 @@ int FolderMan::setupFolders()
    return _folderMap.size();
 }

-void FolderMan::setupFoldersHelper(QSettings &settings, AccountStatePtr account, bool backwardsCompatible)
-{
-    foreach (const auto& folderAlias, settings.childGroups()) {
-        FolderDefinition folderDefinition;
-        if (FolderDefinition::load(settings, folderAlias, &folderDefinition)) {
-            // Migration: Old settings don't have journalPath
-            if (folderDefinition.journalPath.isEmpty()) {
-                folderDefinition.journalPath = folderDefinition.defaultJournalPath(account->account());
-            }
-            folderDefinition.defaultJournalPath(account->account());
-            // Migration: If an old db is found, move it to the new name.
-            if (backwardsCompatible) {
-                SyncJournalDb::maybeMigrateDb(folderDefinition.localPath, folderDefinition.absoluteJournalPath());
-            }
-
-            Folder* f = addFolderInternal(std::move(folderDefinition), account.data());
-            if (f) {
-                // Migration: Mark folders that shall be saved in a backwards-compatible way
-                if (backwardsCompatible) {
-                    f->setSaveBackwardsCompatible(true);
-                }
-                scheduleFolder(f);
-                emit folderSyncStateChange(f);
-            }
-        }
-    }
-}
-
 int FolderMan::setupFoldersMigration()
 {
    ConfigFile cfg;
@@ -286,16 +259,18 @@ int FolderMan::setupFoldersMigration()
    return _folderMap.size();
 }

-bool FolderMan::ensureJournalGone( const QString& journalDbFile )
+bool FolderMan::ensureJournalGone(const QString &localPath)
 {
-    // remove the old journal file
-    while (QFile::exists(journalDbFile) && !QFile::remove(journalDbFile)) {
-        qDebug() << "Could not remove old db file at" << journalDbFile;
+	// FIXME move this to UI, not libowncloudsync
+    // remove old .csync_journal file
+    QString stateDbFile = localPath+QLatin1String("/.csync_journal.db");
+    while (QFile::exists(stateDbFile) && !QFile::remove(stateDbFile)) {
+        qDebug() << "Could not remove old db file at" << stateDbFile;
        int ret = QMessageBox::warning(0, tr("Could not reset folder state"),
                                       tr("An old sync journal '%1' was found, "
                                          "but could not be removed. Please make sure "
                                          "that no application is currently using it.")
-                                       .arg(QDir::fromNativeSeparators(QDir::cleanPath(journalDbFile))),
+                                       .arg(QDir::fromNativeSeparators(QDir::cleanPath(stateDbFile))),
                                       QMessageBox::Retry|QMessageBox::Abort);
        if (ret == QMessageBox::Abort) {
            return false;
@@ -545,26 +520,6 @@ void FolderMan::scheduleFolder( Folder *f )
    startScheduledSyncSoon();
 }

-void FolderMan::scheduleFolderNext(Folder* f)
-{
-    auto alias = f->alias();
-    qDebug() << "Schedule folder " << alias << " to sync! Front-of-queue.";
-
-    if( !f->canSync() ) {
-        qDebug() << "Folder is not ready to sync, not scheduled!";
-        return;
-    }
-
-    _scheduledFolders.removeAll(f);
-
-    f->prepareToSync();
-    emit folderSyncStateChange(f);
-    _scheduledFolders.prepend(f);
-    emit scheduleQueueChanged();
-
-    startScheduledSyncSoon();
-}
-
 void FolderMan::slotScheduleETagJob(const QString &/*alias*/, RequestEtagJob *job)
 {
    QObject::connect(job, SIGNAL(destroyed(QObject*)), this, SLOT(slotEtagJobDestroyed(QObject*)));
@@ -718,11 +673,12 @@ void FolderMan::slotStartScheduledFolderSync()
    }

    // Find the first folder in the queue that can be synced.
-    Folder* folder = 0;
+    Folder* f = 0;
    while( !_scheduledFolders.isEmpty() ) {
-        Folder* g = _scheduledFolders.dequeue();
-        if( g->canSync() ) {
-            folder = g;
+        f = _scheduledFolders.dequeue();
+        Q_ASSERT(f);
+
+        if( f->canSync() ) {
            break;
        }
    }
@@ -730,13 +686,9 @@ void FolderMan::slotStartScheduledFolderSync()
    emit scheduleQueueChanged();

    // Start syncing this folder!
-    if( folder ) {
-        // Safe to call several times, and necessary to try again if
-        // the folder path didn't exist previously.
-        registerFolderMonitor(folder);
-
-        _currentSyncFolder = folder;
-        folder->startSync( QStringList() );
+    if( f ) {
+        _currentSyncFolder = f;
+        f->startSync( QStringList() );
    }
 }

@@ -838,20 +790,18 @@ void FolderMan::slotScheduleFolderByTime()
            continue;
        }

-        // Retry a couple of times after failure; or regularly if requested
-        bool syncAgain =
-                (f->consecutiveFailingSyncs() > 0 && f->consecutiveFailingSyncs() < 3)
-                || f->syncEngine().isAnotherSyncNeeded() == DelayedFollowUp;
-        qint64 syncAgainDelay = 10 * 1000; // 10s for the first retry-after-fail
+        // Retry a couple of times after failure
+        bool syncAgainAfterFail = f->consecutiveFailingSyncs() > 0 && f->consecutiveFailingSyncs() < 3;
+        qint64 syncAgainAfterFailDelay = 10 * 1000; // 10s for the first retry-after-fail
        if (f->consecutiveFailingSyncs() > 1)
-            syncAgainDelay = 60 * 1000; // 60s for each further attempt
-        if (syncAgain
-                && msecsSinceSync > syncAgainDelay) {
+            syncAgainAfterFailDelay = 60 * 1000; // 60s for each further attempt
+        if (syncAgainAfterFail
+                && msecsSinceSync > syncAgainAfterFailDelay) {
            qDebug() << "** scheduling folder" << f->alias()
-                     << ", the last" << f->consecutiveFailingSyncs() << "syncs failed"
-                     << ", anotherSyncNeeded" << f->syncEngine().isAnotherSyncNeeded()
-                     << ", last status:" << f->syncResult().statusString()
-                     << ", time since last sync:" << msecsSinceSync;
+                     << "because the last"
+                     << f->consecutiveFailingSyncs() << "syncs failed, last status:"
+                     << f->syncResult().statusString()
+                     << "time since last sync:" << msecsSinceSync;

            scheduleFolder(f);
            continue;
@@ -884,27 +834,11 @@ void FolderMan::slotFolderSyncFinished( const SyncResult& )

 Folder* FolderMan::addFolder(AccountState* accountState, const FolderDefinition& folderDefinition)
 {
-    // Choose a db filename
-    auto definition = folderDefinition;
-    definition.journalPath = definition.defaultJournalPath(accountState->account());
-
-    if (!ensureJournalGone(definition.absoluteJournalPath())) {
+    if (!ensureJournalGone(folderDefinition.localPath)) {
        return 0;
    }

-    auto folder = addFolderInternal(definition, accountState);
-
-    // Migration: The first account that's configured for a local folder shall
-    // be saved in a backwards-compatible way.
-    bool oneAccountOnly = true;
-    foreach (Folder* other, FolderMan::instance()->map()) {
-        if (other != folder && other->cleanPath() == folder->cleanPath()) {
-            oneAccountOnly = false;
-            break;
-        }
-    }
-    folder->setSaveBackwardsCompatible(oneAccountOnly);
-
+    auto folder = addFolderInternal(folderDefinition, accountState);
    if(folder) {
        folder->saveToSettings();
        emit folderSyncStateChange(folder);
@@ -913,8 +847,7 @@ Folder* FolderMan::addFolder(AccountState* accountState, const FolderDefinition&
    return folder;
 }

-Folder* FolderMan::addFolderInternal(FolderDefinition folderDefinition,
-                                     AccountState* accountState)
+Folder* FolderMan::addFolderInternal(FolderDefinition folderDefinition, AccountState* accountState)
 {
    auto alias = folderDefinition.alias;
    int count = 0;
@@ -1277,16 +1210,17 @@ QString FolderMan::statusToString( SyncResult syncStatus, bool paused ) const
    return folderMessage;
 }

-QString FolderMan::checkPathValidityForNewFolder(const QString& path, const QUrl &serverUrl, bool forNewDirectory)
+QString FolderMan::checkPathValidityForNewFolder(const QString& path, bool forNewDirectory)
 {
    if (path.isEmpty()) {
        return tr("No valid folder selected!");
    }

    QFileInfo selFile( path );
+    QString userInput = selFile.canonicalFilePath();

    if (!selFile.exists()) {
-        return checkPathValidityForNewFolder(selFile.dir().path(), serverUrl, true);
+        return checkPathValidityForNewFolder(selFile.dir().path(), true);
    }

    if( !selFile.isDir() ) {
@@ -1298,10 +1232,6 @@ QString FolderMan::checkPathValidityForNewFolder(const QString& path, const QUrl
    }

    // check if the local directory isn't used yet in another ownCloud sync
-    Qt::CaseSensitivity cs = Qt::CaseSensitive;
-    if( Utility::fsCasePreserving() ) {
-        cs = Qt::CaseInsensitive;
-    }

    for (auto i = _folderMap.constBegin(); i != _folderMap.constEnd(); ++i ) {
        Folder *f = static_cast<Folder*>(i.value());
@@ -1309,60 +1239,39 @@ QString FolderMan::checkPathValidityForNewFolder(const QString& path, const QUrl
        if( folderDir.isEmpty() ) {
            continue;
        }
-        if( ! folderDir.endsWith(QLatin1Char('/'), cs) ) folderDir.append(QLatin1Char('/'));
+        if( ! folderDir.endsWith(QLatin1Char('/')) ) folderDir.append(QLatin1Char('/'));

-        const QString folderDirClean = QDir::cleanPath(folderDir)+'/';
-        const QString userDirClean = QDir::cleanPath(path)+'/';
-
-        // folderDir follows sym links, path not.
-        bool differentPathes = !Utility::fileNamesEqual(QDir::cleanPath(folderDir), QDir::cleanPath(path));
-
-        if (!forNewDirectory && differentPathes && folderDirClean.startsWith(userDirClean,cs)) {
+        if (QDir::cleanPath(f->path()) == QDir::cleanPath(userInput)
+                && QDir::cleanPath(QDir(f->path()).canonicalPath()) == QDir(userInput).canonicalPath()) {
+            return tr("The local folder %1 is already used in a folder sync connection. "
+                      "Please pick another one!")
+                .arg(QDir::toNativeSeparators(userInput));
+        }
+        if (!forNewDirectory && QDir::cleanPath(folderDir).startsWith(QDir::cleanPath(userInput)+'/')) {
            return tr("The local folder %1 already contains a folder used in a folder sync connection. "
                      "Please pick another one!")
-                    .arg(QDir::toNativeSeparators(path));
+                .arg(QDir::toNativeSeparators(userInput));
        }

-        // QDir::cleanPath keeps links
-        // canonicalPath() remove symlinks and uses the symlink targets.
-        QString absCleanUserFolder = QDir::cleanPath(QDir(path).canonicalPath())+'/';
+        QString absCleanUserFolder = QDir::cleanPath(QDir(userInput).canonicalPath())+'/';
+        if (!forNewDirectory && QDir::cleanPath(folderDir).startsWith(absCleanUserFolder) ) {
+            return tr("The local folder %1 is a symbolic link. "
+                      "The link target already contains a folder used in a folder sync connection. "
+                      "Please pick another one!")
+                .arg(QDir::toNativeSeparators(userInput));
+        }

-        if ( (forNewDirectory || differentPathes) && userDirClean.startsWith( folderDirClean, cs )) {
+        if (QDir::cleanPath(QString(userInput)).startsWith( QDir::cleanPath(folderDir)+'/')) {
            return tr("The local folder %1 is already contained in a folder used in a folder sync connection. "
                      "Please pick another one!")
-                    .arg(QDir::toNativeSeparators(path));
+                .arg(QDir::toNativeSeparators(userInput));
        }

-        // both follow symlinks.
-        bool cleanUserEqualsCleanFolder = Utility::fileNamesEqual(absCleanUserFolder, folderDirClean );
-        if (differentPathes && absCleanUserFolder.startsWith( folderDirClean, cs ) &&
-                ! cleanUserEqualsCleanFolder ) {
+        if (absCleanUserFolder.startsWith( QDir::cleanPath(folderDir)+'/')) {
            return tr("The local folder %1 is a symbolic link. "
                      "The link target is already contained in a folder used in a folder sync connection. "
                      "Please pick another one!")
-                    .arg(QDir::toNativeSeparators(path));
-        }
-
-        if (differentPathes && folderDirClean.startsWith(absCleanUserFolder, cs) &&
-                !cleanUserEqualsCleanFolder && !forNewDirectory ) {
-            return tr("The local folder %1 contains a symbolic link. "
-                      "The link target contains an already synced folder "
-                      "Please pick another one!")
-                    .arg(QDir::toNativeSeparators(path));
-        }
-
-        // if both pathes are equal, the server url needs to be different
-        // otherwise it would mean that a new connection from the same local folder
-        // to the same account is added which is not wanted. The account must differ.
-        if( serverUrl.isValid() && Utility::fileNamesEqual(absCleanUserFolder,folderDir ) ) {
-            QUrl folderUrl = f->accountState()->account()->url();
-            QString user = f->accountState()->account()->credentials()->user();
-            folderUrl.setUserName(user);
-
-            if( serverUrl == folderUrl ) {
-                return tr("There is already a sync from the server to this local folder. "
-                          "Please pick another local folder!");
-            }
+                .arg(QDir::toNativeSeparators(userInput));
        }
    }

@@ -97,11 +97,11 @@ public:
    Folder* setupFolderFromOldConfigFile(const QString &, AccountState *account );

    /**
-     * Ensures that a given directory does not contain a sync journal file.
+     * Ensures that a given directory does not contain a .csync_journal.
     *
     * @returns false if the journal could not be removed, true otherwise.
     */
-    static bool ensureJournalGone(const QString& journalDbFile);
+    static bool ensureJournalGone(const QString &path);

    /** Creates a new and empty local directory. */
    bool startFromScratch( const QString& );
@@ -128,7 +128,7 @@ public:
     *
     * @returns an empty string if it is allowed, or an error if it is not allowed
     */
-    QString checkPathValidityForNewFolder(const QString &path, const QUrl& serverUrl = QUrl(), bool forNewDirectory = false);
+    QString checkPathValidityForNewFolder(const QString &path, bool forNewDirectory = false);

    /**
     * While ignoring hidden files can theoretically be switched per folder,
@@ -161,22 +161,12 @@ public:
    /** Queues a folder for syncing. */
    void scheduleFolder(Folder*);

-    /** Puts a folder in the very front of the queue. */
-    void scheduleFolderNext(Folder*);
-
    /** Queues all folders for syncing. */
    void scheduleAllFolders();

    void setDirtyProxy(bool value = true);
    void setDirtyNetworkLimits();

-    /**
-     * Terminates the current folder sync.
-     *
-     * It does not switch the folder to paused state.
-     */
-    void terminateSyncProcess();
-
 signals:
    /**
      * signal to indicate a folder has changed its sync state.
@@ -257,12 +247,17 @@ private slots:
    void slotScheduleFolderByTime();

 private:
+    /**
+     * Terminates the current folder sync.
+     *
+     * It does not switch the folder to paused state.
+     */
+    void terminateSyncProcess();

    /** Adds a new folder, does not add it to the account settings and
     *  does not set an account on the new folder.
      */
-    Folder* addFolderInternal(FolderDefinition folderDefinition,
-                              AccountState* accountState);
+    Folder* addFolderInternal(FolderDefinition folderDefinition, AccountState* accountState);

    /* unloads a folder object, does not delete it */
    void unloadFolder( Folder * );
@@ -278,8 +273,6 @@ private:
    // restarts the application (Linux only)
    void restartApplication();

-    void setupFoldersHelper(QSettings& settings, AccountStatePtr account, bool backwardsCompatible);
-
    QSet<Folder*>  _disabledFolders;
    Folder::Map    _folderMap;
    QString        _folderConfigPath;
@@ -527,8 +527,10 @@ void FolderStatusModel::fetchMore(const QModelIndex& parent)

    if (!info || info->_fetched || info->_fetching)
        return;
-    info->resetSubs(this, parent);
+
+    info->_hasError = false;
    info->_fetching = true;
+    info->_fetchingLabel = false;
    QString path = info->_folder->remotePath();
    if (info->_path != QLatin1String("/")) {
        if (!path.endsWith(QLatin1Char('/'))) {
@@ -696,16 +698,17 @@ void FolderStatusModel::slotLscolFinishedWithError(QNetworkReply* r)
        qDebug() << r->errorString();
        parentInfo->_lastErrorString = r->errorString();

-        parentInfo->resetSubs(this, idx);
-
        if (r->error() == QNetworkReply::ContentNotFoundError) {
            parentInfo->_fetched = true;
        } else {
-            Q_ASSERT(!parentInfo->hasLabel());
-            beginInsertRows(idx, 0, 0);
+            if (!parentInfo->hasLabel()) {
+                beginInsertRows(idx, 0, 0);
+                endInsertRows();
+            }
            parentInfo->_hasError = true;
-            endInsertRows();
        }
+        parentInfo->_fetching = false;
+        parentInfo->_fetchingLabel = false;
    }
 }

@@ -803,6 +806,25 @@ void FolderStatusModel::slotApplySelectiveSync()
    resetFolders();
 }

+static QString shortenFilename( Folder *f, const QString& file )
+{
+    // strip off the server prefix from the file name
+    QString shortFile(file);
+    if( shortFile.isEmpty() ) {
+        return QString::null;
+    }
+
+    if(shortFile.startsWith(QLatin1String("ownclouds://")) ||
+            shortFile.startsWith(QLatin1String("owncloud://")) ) {
+        // rip off the whole ownCloud URL.
+        if( f ) {
+            QString remotePathUrl = f->remoteUrl().toString();
+            shortFile.remove(Utility::toCSyncScheme(remotePathUrl));
+        }
+    }
+    return shortFile;
+}
+
 void FolderStatusModel::slotSetProgress(const ProgressInfo &progress)
 {
    auto par = qobject_cast<QWidget*>(QObject::parent());
@@ -876,7 +898,7 @@ void FolderStatusModel::slotSetProgress(const ProgressInfo &progress)
        curItemProgress = curItem._size;
    }

-    QString itemFileName = curItem._file;
+    QString itemFileName = shortenFilename(f, curItem._file);
    QString kindString = Progress::asActionString(curItem);

    QString fileProgressString;
@@ -169,8 +169,7 @@ void FolderWatcherPrivate::slotReceivedNotification(int fd)
        if (event->len > 0 && event->wd > -1) {
            QByteArray fileName(event->name);
            // qDebug() << Q_FUNC_INFO << event->name;
-            if (fileName.startsWith("._sync_") ||
-                    fileName.startsWith(".csync_journal.db") ||
+            if (fileName.startsWith(".csync_journal.db") ||
                    fileName.startsWith(".owncloudsync.log")) {
                // qDebug() << "ignore journal";
            } else {
@@ -56,9 +56,8 @@ QString FormatWarningsWizardPage::formatWarnings(const QStringList &warnings) co
    return ret;
 }

-FolderWizardLocalPath::FolderWizardLocalPath(const AccountPtr& account)
-    : FormatWarningsWizardPage(),
-      _account(account)
+FolderWizardLocalPath::FolderWizardLocalPath()
+    : FormatWarningsWizardPage()
 {
    _ui.setupUi(this);
    registerField(QLatin1String("sourceFolder*"), _ui.localFolderLineEdit);
@@ -90,13 +89,8 @@ void FolderWizardLocalPath::cleanupPage()

 bool FolderWizardLocalPath::isComplete() const
 {
-    QUrl serverUrl = _account->url();
-    serverUrl.setUserName( _account->credentials()->user() );
-
    QString errorStr = FolderMan::instance()->checkPathValidityForNewFolder(
-        QDir::fromNativeSeparators(_ui.localFolderLineEdit->text()), serverUrl);
-
-
+        QDir::fromNativeSeparators(_ui.localFolderLineEdit->text()));

    bool isOk = errorStr.isEmpty();
    QStringList warnStrings;
@@ -139,7 +133,7 @@ void FolderWizardLocalPath::slotChooseLocalFolder()
 }

 // =================================================================================
-FolderWizardRemotePath::FolderWizardRemotePath(const AccountPtr& account)
+FolderWizardRemotePath::FolderWizardRemotePath(AccountPtr account)
    : FormatWarningsWizardPage()
    ,_warnWasVisible(false)
    ,_account(account)
@@ -479,11 +473,12 @@ void FolderWizardRemotePath::showWarn( const QString& msg ) const

 // ====================================================================================

-FolderWizardSelectiveSync::FolderWizardSelectiveSync(const AccountPtr& account)
+FolderWizardSelectiveSync::FolderWizardSelectiveSync(AccountPtr account)
 {
    QVBoxLayout *layout = new QVBoxLayout(this);
-    _selectiveSync = new SelectiveSyncWidget(account, this);
-    layout->addWidget(_selectiveSync);
+    _treeView = new SelectiveSyncTreeView(account, this);
+    layout->addWidget(new QLabel(tr("Choose What to Sync: You can optionally deselect remote subfolders you do not wish to synchronize.")));
+    layout->addWidget(_treeView);
 }

 FolderWizardSelectiveSync::~FolderWizardSelectiveSync()
@@ -500,17 +495,13 @@ void FolderWizardSelectiveSync::initializePage()
    QString alias        = QFileInfo(targetPath).fileName();
    if (alias.isEmpty())
        alias = Theme::instance()->appName();
-    QStringList initialBlacklist;
-    if (Theme::instance()->wizardSelectiveSyncDefaultNothing()) {
-        initialBlacklist = QStringList("/");
-    }
-    _selectiveSync->setFolderInfo(targetPath, alias, initialBlacklist);
+    _treeView->setFolderInfo(targetPath, alias);
    QWizardPage::initializePage();
 }

 bool FolderWizardSelectiveSync::validatePage()
 {
-    wizard()->setProperty("selectiveSyncBlackList", QVariant(_selectiveSync->createBlackList()));
+    wizard()->setProperty("selectiveSyncBlackList", QVariant(_treeView->createBlackList()));
    return true;
 }

@@ -520,7 +511,7 @@ void FolderWizardSelectiveSync::cleanupPage()
    QString alias        = QFileInfo(targetPath).fileName();
    if (alias.isEmpty())
        alias = Theme::instance()->appName();
-    _selectiveSync->setFolderInfo(targetPath, alias);
+    _treeView->setFolderInfo(targetPath, alias);
    QWizardPage::cleanupPage();
 }

@@ -536,7 +527,7 @@ void FolderWizardSelectiveSync::cleanupPage()

 FolderWizard::FolderWizard(AccountPtr account, QWidget *parent)
    : QWizard(parent),
-    _folderWizardSourcePage(new FolderWizardLocalPath(account)),
+    _folderWizardSourcePage(new FolderWizardLocalPath),
    _folderWizardTargetPage(0),
    _folderWizardSelectiveSyncPage(new FolderWizardSelectiveSync(account))
 {
@@ -27,7 +27,7 @@

 namespace OCC {

-class SelectiveSyncWidget;
+class SelectiveSyncTreeView;

 class ownCloudInfo;

@@ -49,7 +49,7 @@ class FolderWizardLocalPath : public FormatWarningsWizardPage
 {
    Q_OBJECT
 public:
-    explicit FolderWizardLocalPath(const AccountPtr& account);
+    FolderWizardLocalPath();
    ~FolderWizardLocalPath();

    virtual bool isComplete() const Q_DECL_OVERRIDE;
@@ -63,7 +63,6 @@ protected slots:
 private:
    Ui_FolderWizardSourcePage _ui;
    Folder::Map _folderMap;
-    AccountPtr _account;
 };


@@ -76,7 +75,7 @@ class FolderWizardRemotePath : public FormatWarningsWizardPage
 {
    Q_OBJECT
 public:
-    explicit FolderWizardRemotePath(const AccountPtr& account);
+    explicit FolderWizardRemotePath(AccountPtr account);
    ~FolderWizardRemotePath();

    virtual bool isComplete() const Q_DECL_OVERRIDE;
@@ -118,7 +117,7 @@ class FolderWizardSelectiveSync : public QWizardPage
 {
    Q_OBJECT
 public:
-    explicit FolderWizardSelectiveSync(const AccountPtr& account);
+    explicit FolderWizardSelectiveSync(AccountPtr account);
    ~FolderWizardSelectiveSync();

    virtual bool validatePage() Q_DECL_OVERRIDE;
@@ -127,7 +126,7 @@ public:
    virtual void cleanupPage() Q_DECL_OVERRIDE;

 private:
-    SelectiveSyncWidget *_selectiveSync;
+    SelectiveSyncTreeView *_treeView;

 };

@@ -110,9 +110,8 @@ LogBrowser::LogBrowser(QWidget *parent) :

    setModal(false);

-    Logger::instance()->setLogWindowActivated(true);
    // Direct connection for log coming from this thread, and queued for the one in a different thread
-    connect(Logger::instance(), SIGNAL(logWindowLog(QString)),this,SLOT(slotNewLog(QString)), Qt::AutoConnection);
+    connect(Logger::instance(), SIGNAL(newLog(QString)),this,SLOT(slotNewLog(QString)), Qt::AutoConnection);

    QAction *showLogWindow = new QAction(this);
    showLogWindow->setShortcut(QKeySequence("F12"));
@@ -31,7 +31,6 @@
 #include "sslerrordialog.h"
 #include "accountmanager.h"
 #include "clientproxy.h"
-#include "filesystem.h"

 #include "creds/credentialsfactory.h"
 #include "creds/abstractcredentials.h"
@@ -203,39 +202,10 @@ void OwncloudSetupWizard::slotOwnCloudFoundAuth(const QUrl& url, const QVariantM

 void OwncloudSetupWizard::slotNoOwnCloudFoundAuth(QNetworkReply *reply)
 {
-    int resultCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    QString contentType = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-
-    // Do this early because reply might be deleted in message box event loop
-    QString msg;
-    if (!_ocWizard->account()->url().isValid()) {
-        msg = tr("Invalid URL");
-    } else {
-        msg = tr("Failed to connect to %1 at %2:<br/>%3")
-            .arg(Theme::instance()->appNameGUI(),
-                 reply->url().toString(),
-                 reply->errorString());
-    }
-    bool isDowngradeAdvised = checkDowngradeAdvised(reply);
-
-    // If a client cert is needed, nginx sends:
-    // 400 "<html>\r\n<head><title>400 No required SSL certificate was sent</title></head>\r\n<body bgcolor=\"white\">\r\n<center><h1>400 Bad Request</h1></center>\r\n<center>No required SSL certificate was sent</center>\r\n<hr><center>nginx/1.10.0</center>\r\n</body>\r\n</html>\r\n"
-    // If the IP needs to be added as "trusted domain" in oC, oC sends:
-    // https://gist.github.com/guruz/ab6d11df1873c2ad3932180de92e7d82
-    if (resultCode != 200 && contentType.startsWith("text/")) {
-        // FIXME: Synchronous dialogs are not so nice because of event loop recursion
-        // (we already create a dialog further below)
-        QString serverError = reply->peek(1024*20);
-        qDebug() << serverError;
-        QMessageBox messageBox(_ocWizard);
-        messageBox.setText(serverError);
-        messageBox.addButton(QMessageBox::Ok);
-        messageBox.setTextFormat(Qt::RichText);
-        messageBox.exec();
-    }
-
-    // Displays message inside wizard and possibly also another message box
-    _ocWizard->displayError(msg, isDowngradeAdvised);
+    _ocWizard->displayError(tr("Failed to connect to %1 at %2:<br/>%3")
+                            .arg(Theme::instance()->appNameGUI(),
+                                 reply->url().toString(),
+                                 reply->errorString()), checkDowngradeAdvised(reply));

    // Allow the credentials dialog to pop up again for the same URL.
    // Maybe the user just clicked 'Cancel' by accident or changed his mind.
@@ -370,8 +340,8 @@ void OwncloudSetupWizard::slotCreateLocalAndRemoteFolders(const QString& localFo
    } else {
        QString res = tr("Creating local sync folder %1...").arg(localFolder);
        if( fi.mkpath( localFolder ) ) {
-            FileSystem::setFolderMinimumPermissions(localFolder);
            Utility::setupFavLink( localFolder );
+            // FIXME: Create a local sync folder.
            res += tr("ok");
        } else {
            res += tr("failed.");
@@ -526,7 +496,7 @@ void OwncloudSetupWizard::slotAssistantFinished( int result )
            qDebug() << "Adding folder definition for" << localFolder << _remoteFolder;
            FolderDefinition folderDefinition;
            folderDefinition.localPath = localFolder;
-            folderDefinition.targetPath = FolderDefinition::prepareTargetPath(_remoteFolder);
+            folderDefinition.targetPath = _remoteFolder;
            folderDefinition.ignoreHiddenFiles = folderMan->ignoreHiddenFiles();

            auto f = folderMan->addFolder(account, folderDefinition);
@@ -558,13 +528,6 @@ void OwncloudSetupWizard::slotSkipFolderConfiguration()
 AccountState *OwncloudSetupWizard::applyAccountChanges()
 {
    AccountPtr newAccount = _ocWizard->account();
-
-    // Detach the account that is going to be saved from the
-    // wizard to ensure it doesn't accidentally get modified
-    // later (such as from running cleanup such as
-    // AbstractCredentialsWizardPage::cleanupPage())
-    _ocWizard->setAccount(AccountManager::createAccount());
-
    auto manager = AccountManager::instance();

    auto newState = manager->addAccount(newAccount);
@@ -18,7 +18,6 @@
 #include "networkjobs.h"
 #include "theme.h"
 #include "folderman.h"
-#include "configfile.h"
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QTreeWidget>
@@ -30,7 +29,6 @@
 #include <QScopedValueRollback>
 #include <QTreeWidgetItem>
 #include <QLabel>
-#include <QVBoxLayout>

 namespace OCC {

@@ -56,48 +54,32 @@ private:
    }
 };

-SelectiveSyncWidget::SelectiveSyncWidget(AccountPtr account, QWidget *parent)
-    : QWidget(parent)
-    , _account(account)
-    , _inserting(false)
-    , _folderTree(new QTreeWidget(this))
+SelectiveSyncTreeView::SelectiveSyncTreeView(AccountPtr account, QWidget* parent)
+    : QTreeWidget(parent), _inserting(false), _account(account)
 {
-    _loading = new QLabel(tr("Loading ..."), _folderTree);
-
-    auto layout = new QVBoxLayout(this);
-    layout->setContentsMargins(0, 0, 0, 0);
-
-    auto header = new QLabel(this);
-    header->setText(tr("Deselect remote folders you do not wish to synchronize."));
-    header->setWordWrap(true);
-    layout->addWidget(header);
-
-    layout->addWidget(_folderTree);
-
-    connect(_folderTree, SIGNAL(itemExpanded(QTreeWidgetItem*)),
-            SLOT(slotItemExpanded(QTreeWidgetItem*)));
-    connect(_folderTree, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
-            SLOT(slotItemChanged(QTreeWidgetItem*,int)));
-    _folderTree->setSortingEnabled(true);
-    _folderTree->sortByColumn(0, Qt::AscendingOrder);
-    _folderTree->setColumnCount(2);
+    _loading = new QLabel(tr("Loading ..."), this);
+    connect(this, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(slotItemExpanded(QTreeWidgetItem*)));
+    connect(this, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(slotItemChanged(QTreeWidgetItem*,int)));
+    setSortingEnabled(true);
+    sortByColumn(0, Qt::AscendingOrder);
+    setColumnCount(2);
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
-    _folderTree->header()->setSectionResizeMode(0, QHeaderView::QHeaderView::ResizeToContents);
-    _folderTree->header()->setSectionResizeMode(1, QHeaderView::QHeaderView::ResizeToContents);
+    header()->setSectionResizeMode(0, QHeaderView::QHeaderView::ResizeToContents);
+    header()->setSectionResizeMode(1, QHeaderView::QHeaderView::ResizeToContents);
 #else
-    _folderTree->header()->resizeSection(0, sizeHint().width()/2);
+    header()->resizeSection(0, sizeHint().width()/2);
 #endif
-    _folderTree->header()->setStretchLastSection(true);
-    _folderTree->headerItem()->setText(0, tr("Name"));
-    _folderTree->headerItem()->setText(1, tr("Size"));
+    header()->setStretchLastSection(true);
+    headerItem()->setText(0, tr("Name"));
+    headerItem()->setText(1, tr("Size"));
 }

-QSize SelectiveSyncWidget::sizeHint() const
+QSize SelectiveSyncTreeView::sizeHint() const
 {
-    return QWidget::sizeHint().expandedTo(QSize(600, 600));
+    return QTreeView::sizeHint().expandedTo(QSize(400, 400));
 }

-void SelectiveSyncWidget::refreshFolders()
+void SelectiveSyncTreeView::refreshFolders()
 {
    LsColJob *job = new LsColJob(_account, _folderPath, this);
    job->setProperties(QList<QByteArray>() << "resourcetype" << "http://owncloud.org/ns:size");
@@ -106,12 +88,12 @@ void SelectiveSyncWidget::refreshFolders()
    connect(job, SIGNAL(finishedWithError(QNetworkReply*)),
            this, SLOT(slotLscolFinishedWithError(QNetworkReply*)));
    job->start();
-    _folderTree->clear();
+    clear();
    _loading->show();
-    _loading->move(10, _folderTree->header()->height() + 10);
+    _loading->move(10,header()->height() + 10);
 }

-void SelectiveSyncWidget::setFolderInfo(const QString& folderPath, const QString& rootName, const QStringList& oldBlackList)
+void SelectiveSyncTreeView::setFolderInfo(const QString& folderPath, const QString& rootName, const QStringList& oldBlackList)
 {
    _folderPath = folderPath;
    if (_folderPath.startsWith(QLatin1Char('/'))) {
@@ -134,7 +116,7 @@ static QTreeWidgetItem* findFirstChild(QTreeWidgetItem *parent, const QString& t
    return 0;
 }

-void SelectiveSyncWidget::recursiveInsert(QTreeWidgetItem* parent, QStringList pathTrail, QString path, qint64 size)
+void SelectiveSyncTreeView::recursiveInsert(QTreeWidgetItem* parent, QStringList pathTrail, QString path, qint64 size)
 {
    QFileIconProvider prov;
    QIcon folderIcon = prov.icon(QFileIconProvider::Folder);
@@ -177,13 +159,13 @@ void SelectiveSyncWidget::recursiveInsert(QTreeWidgetItem* parent, QStringList p
    }
 }

-void SelectiveSyncWidget::slotUpdateDirectories(QStringList list)
+void SelectiveSyncTreeView::slotUpdateDirectories(QStringList list)
 {
    auto job = qobject_cast<LsColJob *>(sender());
    QScopedValueRollback<bool> isInserting(_inserting);
    _inserting = true;

-    SelectiveSyncTreeViewItem *root = static_cast<SelectiveSyncTreeViewItem*>(_folderTree->topLevelItem(0));
+    SelectiveSyncTreeViewItem *root = static_cast<SelectiveSyncTreeViewItem*>(topLevelItem(0));

    QUrl url = _account->davUrl();
    QString pathToRemove = url.path();
@@ -224,11 +206,15 @@ void SelectiveSyncWidget::slotUpdateDirectories(QStringList list)
    }

    if (!root) {
-        root = new SelectiveSyncTreeViewItem(_folderTree);
+        root = new SelectiveSyncTreeViewItem(this);
        root->setText(0, _rootName);
        root->setIcon(0, Theme::instance()->applicationIcon());
        root->setData(0, Qt::UserRole, QString());
-        root->setCheckState(0, Qt::Checked);
+        if (_oldBlackList.isEmpty()) {
+            root->setCheckState(0, Qt::Checked);
+        } else {
+            root->setCheckState(0, Qt::PartiallyChecked);
+        }
        qint64 size = job ? job->_sizes.value(pathToRemove, -1) : -1;
        if (size >= 0) {
            root->setText(1, Utility::octetsToString(size));
@@ -250,19 +236,10 @@ void SelectiveSyncWidget::slotUpdateDirectories(QStringList list)
        recursiveInsert(root, paths, path, size);
    }

-    // Root is partially checked if any children are not checked
-    for (int i = 0; i < root->childCount(); ++i) {
-        const auto child = root->child(i);
-        if (child->checkState(0) != Qt::Checked) {
-            root->setCheckState(0, Qt::PartiallyChecked);
-            break;
-        }
-    }
-
    root->setExpanded(true);
 }

-void SelectiveSyncWidget::slotLscolFinishedWithError(QNetworkReply *r)
+void SelectiveSyncTreeView::slotLscolFinishedWithError(QNetworkReply *r)
 {
    if (r->error() == QNetworkReply::ContentNotFoundError) {
        _loading->setText(tr("No subfolders currently on the server."));
@@ -272,7 +249,7 @@ void SelectiveSyncWidget::slotLscolFinishedWithError(QNetworkReply *r)
    _loading->resize(_loading->sizeHint()); // because it's not in a layout
 }

-void SelectiveSyncWidget::slotItemExpanded(QTreeWidgetItem *item)
+void SelectiveSyncTreeView::slotItemExpanded(QTreeWidgetItem *item)
 {
    QString dir = item->data(0, Qt::UserRole).toString();
    if (dir.isEmpty()) return;
@@ -287,7 +264,7 @@ void SelectiveSyncWidget::slotItemExpanded(QTreeWidgetItem *item)
    job->start();
 }

-void SelectiveSyncWidget::slotItemChanged(QTreeWidgetItem *item, int col)
+void SelectiveSyncTreeView::slotItemChanged(QTreeWidgetItem *item, int col)
 {
    if (col != 0 || _inserting)
        return;
@@ -345,10 +322,10 @@ void SelectiveSyncWidget::slotItemChanged(QTreeWidgetItem *item, int col)
    }
 }

-QStringList SelectiveSyncWidget::createBlackList(QTreeWidgetItem* root) const
+QStringList SelectiveSyncTreeView::createBlackList(QTreeWidgetItem* root) const
 {
    if (!root) {
-        root = _folderTree->topLevelItem(0);
+        root = topLevelItem(0);
    }
    if (!root) return QStringList();

@@ -377,15 +354,15 @@ QStringList SelectiveSyncWidget::createBlackList(QTreeWidgetItem* root) const
    return result;
 }

-QStringList SelectiveSyncWidget::oldBlackList() const
+QStringList SelectiveSyncTreeView::oldBlackList() const
 {
    return _oldBlackList;
 }

-qint64 SelectiveSyncWidget::estimatedSize(QTreeWidgetItem* root)
+qint64 SelectiveSyncTreeView::estimatedSize(QTreeWidgetItem* root)
 {
    if (!root) {
-        root = _folderTree->topLevelItem(0);
+        root = topLevelItem(0);
    }
    if (!root) return -1;

@@ -419,10 +396,10 @@ SelectiveSyncDialog::SelectiveSyncDialog(AccountPtr account, Folder* folder, QWi
      _okButton(0) // defined in init()
 {
    bool ok;
-    init(account);
+    init(account, tr("Unchecked folders will be <b>removed</b> from your local file system and will not be synchronized to this computer anymore"));
    QStringList selectiveSyncList = _folder->journalDb()->getSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, &ok);
    if( ok ) {
-        _selectiveSync->setFolderInfo(_folder->remotePath(), _folder->alias(),selectiveSyncList);
+        _treeView->setFolderInfo(_folder->remotePath(), _folder->alias(),selectiveSyncList);
    } else {
        _okButton->setEnabled(false);
    }
@@ -434,16 +411,22 @@ SelectiveSyncDialog::SelectiveSyncDialog(AccountPtr account, const QString &fold
                                         const QStringList& blacklist, QWidget* parent, Qt::WindowFlags f)
    : QDialog(parent, f), _folder(0)
 {
-    init(account);
-    _selectiveSync->setFolderInfo(folder, folder, blacklist);
+    init(account,
+         Theme::instance()->wizardSelectiveSyncDefaultNothing() ?
+            tr("Choose What to Sync: Select remote subfolders you wish to synchronize.") :
+            tr("Choose What to Sync: Deselect remote subfolders you do not wish to synchronize."));
+    _treeView->setFolderInfo(folder, folder, blacklist);
 }

-void SelectiveSyncDialog::init(const AccountPtr &account)
+void SelectiveSyncDialog::init(const AccountPtr &account, const QString &labelText)
 {
    setWindowTitle(tr("Choose What to Sync"));
    QVBoxLayout *layout = new QVBoxLayout(this);
-    _selectiveSync = new SelectiveSyncWidget(account, this);
-    layout->addWidget(_selectiveSync);
+    _treeView = new SelectiveSyncTreeView(account, this);
+    auto label = new QLabel(labelText);
+    label->setWordWrap(true);
+    layout->addWidget(label);
+    layout->addWidget(_treeView);
    QDialogButtonBox *buttonBox = new QDialogButtonBox(Qt::Horizontal);
    _okButton = buttonBox->addButton(QDialogButtonBox::Ok);
    connect(_okButton, SIGNAL(clicked()), this, SLOT(accept()));
@@ -461,7 +444,7 @@ void SelectiveSyncDialog::accept()
        if( ! ok ) {
            return;
        }
-        QStringList blackList = _selectiveSync->createBlackList();
+        QStringList blackList = _treeView->createBlackList();
        _folder->journalDb()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, blackList);

        FolderMan *folderMan = FolderMan::instance();
@@ -484,18 +467,19 @@ void SelectiveSyncDialog::accept()

 QStringList SelectiveSyncDialog::createBlackList() const
 {
-    return _selectiveSync->createBlackList();
+    return _treeView->createBlackList();
 }

 QStringList SelectiveSyncDialog::oldBlackList() const
 {
-    return _selectiveSync->oldBlackList();
+    return _treeView->oldBlackList();
 }

 qint64 SelectiveSyncDialog::estimatedSize()
 {
-    return _selectiveSync->estimatedSize();
+    return _treeView->estimatedSize();
 }

+
 }

@@ -26,50 +26,40 @@ namespace OCC {
 class Folder;

 /**
- * @brief The SelectiveSyncWidget contains a folder tree with labels
+ * @brief The SelectiveSyncTreeView class
 * @ingroup gui
 */
-class SelectiveSyncWidget : public QWidget {
+class SelectiveSyncTreeView : public QTreeWidget {
    Q_OBJECT
 public:
-    explicit SelectiveSyncWidget(AccountPtr account, QWidget* parent = 0);
+    explicit SelectiveSyncTreeView(AccountPtr account, QWidget* parent = 0);

    /// Returns a list of blacklisted paths, each including the trailing /
    QStringList createBlackList(QTreeWidgetItem* root = 0) const;
-
-    /** Returns the oldBlackList passed into setFolderInfo(), except that
-     *  a "/" entry is expanded to all top-level folder names.
-     */
    QStringList oldBlackList() const;

    // Estimates the total size of checked items (recursively)
    qint64 estimatedSize(QTreeWidgetItem *root = 0);
+    void refreshFolders();

    // oldBlackList is a list of excluded paths, each including a trailing /
    void setFolderInfo(const QString &folderPath, const QString &rootName,
                       const QStringList &oldBlackList = QStringList());

    QSize sizeHint() const Q_DECL_OVERRIDE;
-
 private slots:
    void slotUpdateDirectories(QStringList);
    void slotItemExpanded(QTreeWidgetItem *);
    void slotItemChanged(QTreeWidgetItem*,int);
    void slotLscolFinishedWithError(QNetworkReply*);
 private:
-    void refreshFolders();
    void recursiveInsert(QTreeWidgetItem* parent, QStringList pathTrail, QString path, qint64 size);
-
-    AccountPtr _account;
-
    QString _folderPath;
    QString _rootName;
    QStringList _oldBlackList;
-
    bool _inserting; // set to true when we are inserting new items on the list
+    AccountPtr _account;
    QLabel *_loading;
-
-    QTreeWidget *_folderTree;
 };

 /**
@@ -95,9 +85,9 @@ public:

 private:

-    void init(const AccountPtr &account);
+    void init(const AccountPtr &account, const QString &label);

-    SelectiveSyncWidget *_selectiveSync;
+    SelectiveSyncTreeView *_treeView;

    Folder *_folder;
    QPushButton *_okButton;
@@ -125,13 +125,8 @@ void OwncloudAdvancedSetupPage::initializePage()
 void OwncloudAdvancedSetupPage::updateStatus()
 {
    const QString locFolder = localFolder();
-    const QString url = static_cast<OwncloudWizard *>(wizard())->ocUrl();
-    const QString user = static_cast<OwncloudWizard *>(wizard())->getCredentials()->user();
-
-    QUrl serverUrl(url);
-    serverUrl.setUserName(user);
    // check if the local folder exists. If so, and if its not empty, show a warning.
-    QString errorStr = FolderMan::instance()->checkPathValidityForNewFolder(locFolder, serverUrl);
+    QString errorStr = FolderMan::instance()->checkPathValidityForNewFolder(locFolder);
    _localFolderValid = errorStr.isEmpty();

    QString t;
@@ -29,11 +29,8 @@ OwncloudConnectionMethodDialog::OwncloudConnectionMethodDialog(QWidget *parent)
    connect(ui->btnClientSideTLS, SIGNAL(clicked(bool)), this, SLOT(returnClientSideTLS()));
    connect(ui->btnBack, SIGNAL(clicked(bool)), this, SLOT(returnBack()));

-
-#if QT_VERSION < QT_VERSION_CHECK(5, 4, 0)
-    // We support only from Qt 5.4.x because of https://doc.qt.io/qt-5/qsslcertificate.html#importPkcs12
+    // DM: TLS Client Cert GUI support disabled for now
    ui->btnClientSideTLS->hide();
-#endif
 }

 void OwncloudConnectionMethodDialog::setUrl(const QUrl &url)
@@ -192,7 +192,7 @@ void OwncloudHttpCredsPage::setErrorString(const QString& err)

 AbstractCredentials* OwncloudHttpCredsPage::getCredentials() const
 {
-    return new HttpCredentialsGui(_ui.leUsername->text(), _ui.lePassword->text(), _ocWizard->_clientSslCertificate, _ocWizard->_clientSslKey);
+    return new HttpCredentialsGui(_ui.leUsername->text(), _ui.lePassword->text(), _ocWizard->ownCloudCertificatePath, _ocWizard->ownCloudCertificatePasswd);
 }


@@ -21,13 +21,13 @@
 #include <QMessageBox>
 #include <QSsl>
 #include <QSslCertificate>
-#include <QNetworkAccessManager>

 #include "QProgressIndicator.h"

 #include "wizard/owncloudwizardcommon.h"
 #include "wizard/owncloudsetuppage.h"
 #include "wizard/owncloudconnectionmethoddialog.h"
+#include "../3rdparty/certificates/p12topem.h"
 #include "theme.h"
 #include "account.h"

@@ -71,6 +71,7 @@ OwncloudSetupPage::OwncloudSetupPage(QWidget *parent)
    connect(_ui.leUrl, SIGNAL(editingFinished()), SLOT(slotUrlEditFinished()));

    addCertDial = new AddCertificateDialog(this);
+    connect(_ocWizard,SIGNAL(needCertificate()),this,SLOT(slotAskSSLClientCertificate()));
 }

 void OwncloudSetupPage::setServerUrl( const QString& newUrl )
@@ -138,7 +139,7 @@ void OwncloudSetupPage::slotUrlChanged(const QString& url)
 void OwncloudSetupPage::slotUrlEditFinished()
 {
    QString url = _ui.leUrl->fullText();
-    if (QUrl(url).isRelative() && !url.isEmpty()) {
+    if (QUrl(url).isRelative()) {
        // no scheme defined, set one
        url.prepend("https://");
    }
@@ -255,7 +256,6 @@ void OwncloudSetupPage::setErrorString( const QString& err, bool retryHTTPonly )

                OwncloudConnectionMethodDialog dialog;
                dialog.setUrl(url);
-                // FIXME: Synchronous dialogs are not so nice because of event loop recursion
                int retVal = dialog.exec();

                switch (retVal) {
@@ -268,10 +268,7 @@ void OwncloudSetupPage::setErrorString( const QString& err, bool retryHTTPonly )
                    }
                    break;
                case OwncloudConnectionMethodDialog::Client_Side_TLS:
-#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
-                    addCertDial->show();
-                    connect(addCertDial, SIGNAL(accepted()),this,SLOT(slotCertificateAccepted()));
-#endif
+                    slotAskSSLClientCertificate();
                    break;
                case OwncloudConnectionMethodDialog::Closed:
                case OwncloudConnectionMethodDialog::Back:
@@ -304,6 +301,12 @@ void OwncloudSetupPage::stopSpinner()
    _progressIndi->stopAnimation();
 }

+void OwncloudSetupPage::slotAskSSLClientCertificate()
+{
+    addCertDial->show();
+    connect(addCertDial, SIGNAL(accepted()),this,SLOT(slotCertificateAccepted()));
+}
+
 QString subjectInfoHelper(const QSslCertificate& cert, const QByteArray &qa)
 {
 #if QT_VERSION < QT_VERSION_CHECK(5,0,0)
@@ -316,40 +319,36 @@ QString subjectInfoHelper(const QSslCertificate& cert, const QByteArray &qa)
 //called during the validation of the client certificate.
 void OwncloudSetupPage::slotCertificateAccepted()
 {
-#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
-    QList<QSslCertificate> clientCaCertificates;
-    QFile certFile(addCertDial->getCertificatePath());
-    certFile.open(QFile::ReadOnly);
-    if(QSslCertificate::importPkcs12(&certFile,
-                                         &_ocWizard->_clientSslKey, &_ocWizard->_clientSslCertificate,
-                                            &clientCaCertificates,
-                                            addCertDial->getCertificatePasswd().toLocal8Bit())){
+    QSslCertificate sslCertificate;
+
+    resultP12ToPem certif = p12ToPem(addCertDial->getCertificatePath().toStdString() , addCertDial->getCertificatePasswd().toStdString());
+    if(certif.ReturnCode){
+        QString s = QString::fromStdString(certif.Certificate);
+        QByteArray ba = s.toLocal8Bit();
+
+        QList<QSslCertificate> sslCertificateList = QSslCertificate::fromData(ba, QSsl::Pem);
+        sslCertificate = sslCertificateList.takeAt(0);
+
+        _ocWizard->ownCloudCertificate = ba;
+        _ocWizard->ownCloudPrivateKey = certif.PrivateKey.c_str();
+        _ocWizard->ownCloudCertificatePath = addCertDial->getCertificatePath();
+        _ocWizard->ownCloudCertificatePasswd = addCertDial->getCertificatePasswd();
+
        AccountPtr acc = _ocWizard->account();
-
-        // to re-create the session ticket because we added a key/cert
-        acc->setSslConfiguration(QSslConfiguration());
-        QSslConfiguration sslConfiguration = acc->getOrCreateSslConfig();
-
-        // We're stuffing the certificate into the configuration form here. Later the
-        // cert will come via the HttpCredentials
-        sslConfiguration.setLocalCertificate(_ocWizard->_clientSslCertificate);
-        sslConfiguration.setPrivateKey(_ocWizard->_clientSslKey);
-        acc->setSslConfiguration(sslConfiguration);
-
-        // Make sure TCP connections get re-established
-        acc->networkAccessManager()->clearAccessCache();
-
-        addCertDial->reinit(); // FIXME: Why not just have this only created on use?
+        acc->setCertificate(_ocWizard->ownCloudCertificate, _ocWizard->ownCloudPrivateKey);
+        addCertDial->reinit();
        validatePage();
    } else {
-        addCertDial->showErrorMessage("Could not load certificate");
+        QString message;
+        message = certif.Comment.c_str();
+        addCertDial->showErrorMessage(message);
        addCertDial->show();
    }
-#endif
 }

 OwncloudSetupPage::~OwncloudSetupPage()
 {
+    delete addCertDial;
 }

 } // namespace OCC
@@ -59,6 +59,7 @@ public slots:
  void setErrorString( const QString&, bool retryHTTPonly );
  void startSpinner();
  void stopSpinner();
+  void slotAskSSLClientCertificate();
  void slotCertificateAccepted();

 protected slots:
@@ -224,4 +224,11 @@ AbstractCredentials* OwncloudWizard::getCredentials() const
  return 0;
 }

+// outputs the signal needed to authenticate a certificate
+void OwncloudWizard::raiseCertificatePopup()
+{
+    emit needCertificate();
+}
+
+
 } // end namespace
@@ -17,8 +17,6 @@
 #define MIRALL_OWNCLOUD_WIZARD_H

 #include <QWizard>
-#include <QSslKey>
-#include <QSslCertificate>

 #include "wizard/owncloudwizardcommon.h"
 #include "accountfwd.h"
@@ -65,10 +63,11 @@ public:
    void displayError( const QString&, bool retryHTTPonly);
    AbstractCredentials* getCredentials() const;

-    // FIXME: Can those be local variables?
-    // Set from the OwncloudSetupPage, later used from OwncloudHttpCredsPage
-    QSslKey _clientSslKey;
-    QSslCertificate _clientSslCertificate;
+    void raiseCertificatePopup();
+    QByteArray ownCloudCertificate;
+    QString ownCloudPrivateKey;
+    QString ownCloudCertificatePath;
+    QString ownCloudCertificatePasswd;

 public slots:
    void setAuthType(WizardCommon::AuthType type);
@@ -70,6 +70,7 @@ set(libsync_SRCS
    creds/abstractcredentials.cpp
    creds/credentialscommon.cpp
    ../3rdparty/qjson/json.cpp
+    ../3rdparty/certificates/p12topem.cpp
 )

 if(TOKEN_AUTH_ONLY)
@@ -18,6 +18,7 @@
 #include "configfile.h"
 #include "accessmanager.h"
 #include "creds/abstractcredentials.h"
+#include "../3rdparty/certificates/p12topem.h"
 #include "capabilities.h"
 #include "theme.h"

@@ -56,11 +57,6 @@ Account::~Account()

 QString Account::davPath() const
 {
-    if (capabilities().chunkingNg()) {
-        // The chunking-ng means the server prefer to use the new webdav URL
-        return QLatin1String("/remote.php/dav/files/") + davUser() + QLatin1Char('/');
-    }
-
    // make sure to have a trailing slash
    if( !_davPath.endsWith('/') ) {
        QString dp(_davPath);
@@ -80,19 +76,19 @@ AccountPtr Account::sharedFromThis()
    return _sharedThis.toStrongRef();
 }

-QString Account::davUser() const
+QString Account::user() const
 {
-    return _davUser.isEmpty() ? _credentials->user() : _davUser;
+    return _user.isEmpty() ? _credentials->user() : _user;
 }

-void Account::setDavUser(const QString &newDavUser)
+void Account::setUser(const QString &user)
 {
-    _davUser = newDavUser;
+    _user = user;
 }

 QString Account::displayName() const
 {
-    QString dn = QString("%1@%2").arg(_credentials->user(), _url.host());
+    QString dn = QString("%1@%2").arg(user(), _url.host());
    int port = url().port();
    if (port > 0 && port != 80 && port != 443) {
        dn.append(QLatin1Char(':'));
@@ -148,14 +144,10 @@ QUrl Account::davUrl() const
    return Utility::concatUrlPath(url(), davPath());
 }

-/**
- * clear all cookies. (Session cookies or not)
- */
 void Account::clearCookieJar()
 {
    Q_ASSERT(qobject_cast<CookieJar*>(_am->cookieJar()));
-    static_cast<CookieJar*>(_am->cookieJar())->setAllCookies(QList<QNetworkCookie>());
-    emit wantsAccountSaved(this);
+    static_cast<CookieJar*>(_am->cookieJar())->clearSessionCookies();
 }

 /*! This shares our official cookie jar (containing all the tasty
@@ -245,6 +237,12 @@ QNetworkReply *Account::davRequest(const QByteArray &verb, const QUrl &url, QNet
    return _am->sendCustomRequest(req, verb, data);
 }

+void Account::setCertificate(const QByteArray certficate, const QString privateKey)
+{
+    _pemCertificate=certficate;
+    _pemPrivateKey=privateKey;
+}
+
 void Account::setSslConfiguration(const QSslConfiguration &config)
 {
    _sslConfiguration = config;
@@ -261,7 +259,31 @@ QSslConfiguration Account::getOrCreateSslConfig()
    // if setting the client certificate fails, you will probably get an error similar to this:
    //  "An internal error number 1060 happened. SSL handshake failed, client certificate was requested: SSL error: sslv3 alert handshake failure"
    QSslConfiguration sslConfig = QSslConfiguration::defaultConfiguration();
+    QSslCertificate sslClientCertificate;
    
+    ConfigFile cfgFile;
+    if(!cfgFile.certificatePath().isEmpty() && !cfgFile.certificatePasswd().isEmpty()) {
+        resultP12ToPem certif = p12ToPem(cfgFile.certificatePath().toStdString(), cfgFile.certificatePasswd().toStdString());
+        QString s = QString::fromStdString(certif.Certificate);
+        QByteArray ba = s.toLocal8Bit();
+        this->setCertificate(ba, QString::fromStdString(certif.PrivateKey));
+    }
+    if((!_pemCertificate.isEmpty())&&(!_pemPrivateKey.isEmpty())) {
+        // Read certificates
+        QList<QSslCertificate> sslCertificateList = QSslCertificate::fromData(_pemCertificate, QSsl::Pem);
+        if(sslCertificateList.length() != 0) {
+            sslClientCertificate = sslCertificateList.takeAt(0);
+        }
+        // Read key from file
+        QSslKey privateKey(_pemPrivateKey.toLocal8Bit(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey , "");
+
+        // SSL configuration
+        sslConfig.setCaCertificates(QSslSocket::systemCaCertificates());
+        sslConfig.setLocalCertificate(sslClientCertificate);
+        sslConfig.setPrivateKey(privateKey);
+        qDebug() << "Added SSL client certificate to the query";
+    }
+
 #if QT_VERSION > QT_VERSION_CHECK(5, 2, 0)
    // Try hard to re-use session for different requests
    sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, false);
@@ -352,11 +374,8 @@ void Account::slotHandleSslErrors(QNetworkReply *reply , QList<QSslError> errors
    // Keep a ref here on our stackframe to make sure that it doesn't get deleted before
    // handleErrors returns.
    QSharedPointer<QNetworkAccessManager> qnamLock = _am;
-    QPointer<QObject> guard = reply;

    if (_sslErrorHandler->handleErrors(errors, reply->sslConfiguration(), &approvedCerts, sharedFromThis())) {
-        if (!guard) return;
-
        QSslSocket::addDefaultCaCertificates(approvedCerts);
        addApprovedCerts(approvedCerts);
        emit wantsAccountSaved(this);
@@ -368,8 +387,6 @@ void Account::slotHandleSslErrors(QNetworkReply *reply , QList<QSslError> errors
        // certificate changes.
        reply->ignoreSslErrors(errors);
    } else {
-        if (!guard) return;
-
        // Mark all involved certificates as rejected, so we don't ask the user again.
        foreach (const QSslError &error, errors) {
            if (!_rejectedCertificates.contains(error.certificate())) {
@@ -69,14 +69,9 @@ public:

    AccountPtr sharedFromThis();

-    /**
-     * The user that can be used in dav url.
-     *
-     * This can very well be different frome the login user that's
-     * stored in credentials()->user().
-     */
-    QString davUser() const;
-    void setDavUser(const QString &newDavUser);
+    /// The user that can be used in dav url
+    QString user() const;
+    void setUser(const QString &user);

    /// The name of the account as shown in the toolbar
    QString displayName() const;
@@ -208,7 +203,7 @@ private:

    QWeakPointer<Account> _sharedThis;
    QString _id;
-    QString _davUser;
+    QString _user;
    QMap<QString, QVariant> _settingsMap;
    QUrl _url;
    QList<QSslCertificate> _approvedCerts;
@@ -224,7 +219,8 @@ private:
    QList<QSslCertificate> _rejectedCertificates;

    static QString _configFileName;
-
+    QByteArray _pemCertificate; 
+    QString _pemPrivateKey;  
    QString _davPath; // defaults to value from theme, might be overwritten in brandings
    friend class AccountManager;
 };
@@ -110,15 +110,8 @@ QByteArray Capabilities::uploadChecksumType() const

 bool Capabilities::chunkingNg() const
 {
-    static const auto chunkng = qgetenv("OWNCLOUD_CHUNKING_NG");
-    if (chunkng == "0") return false;
-    if (chunkng == "1") return true;
    return _capabilities["dav"].toMap()["chunking"].toByteArray() >= "1.0";
 }

-bool Capabilities::chunkingParallelUploadDisabled() const
-{
-    return _capabilities["dav"].toMap()["chunkingParallelUploadDisabled"].toBool();
-}

 }
@@ -42,9 +42,6 @@ public:
    bool shareResharing() const;
    bool chunkingNg() const;

-    /// disable parallel upload in chunking
-    bool chunkingParallelUploadDisabled() const;
-
    /// returns true if the capabilities report notifications
    bool notificationsAvailable() const;

@@ -144,12 +144,7 @@ void ConnectionValidator::slotStatusFound(const QUrl&url, const QVariantMap &inf
 // status.php could not be loaded (network or server issue!).
 void ConnectionValidator::slotNoStatusFound(QNetworkReply *reply)
 {
-    qDebug() << Q_FUNC_INFO << reply->error() << reply->errorString() << reply->peek(1024);
-    if (reply && !_account->credentials()->ready()) {
-        // This could be needed for SSL client certificates
-        // We need to load them from keychain and try
-        reportResult( CredentialsMissingOrWrong );
-    } else
+    qDebug() << Q_FUNC_INFO << reply->error() << reply->errorString();
    if( reply && ! _account->credentials()->stillValid(reply)) {
        _errors.append(tr("Authentication error: Either username or password are wrong."));
    }  else {
@@ -251,7 +246,7 @@ void ConnectionValidator::slotUserFetched(const QVariantMap &json)
 {
    QString user = json.value("ocs").toMap().value("data").toMap().value("id").toString();
    if (!user.isEmpty()) {
-        _account->setDavUser(user);
+        _account->setUser(user);
    }
    reportResult(Connected);
 }
@@ -17,7 +17,6 @@
 #include <QDebug>
 #include <QNetworkReply>
 #include <QSettings>
-#include <QSslKey>

 #include <keychain.h>

@@ -37,8 +36,8 @@ namespace OCC
 namespace
 {
 const char userC[] = "user";
-const char clientCertificatePEMC[] = "_clientCertificatePEM";
-const char clientKeyPEMC[] = "_clientKeyPEM";
+const char certifPathC[] = "certificatePath";
+const char certifPasswdC[] = "certificatePasswd";
 const char authenticationFailedC[] = "owncloud-authentication-failed";
 } // ns

@@ -51,47 +50,24 @@ protected:
        QByteArray credHash = QByteArray(_cred->user().toUtf8()+":"+_cred->password().toUtf8()).toBase64();
        QNetworkRequest req(request);
        req.setRawHeader(QByteArray("Authorization"), QByteArray("Basic ") + credHash);
-        //qDebug() << "Request for " << req.url() << "with authorization"
-        //         << QByteArray::fromBase64(credHash)
-        //         << _cred->_clientSslKey << _cred->_clientSslCertificate
-        //         << _cred->_clientSslKey.isNull() << _cred->_clientSslCertificate.isNull();
-
-        if (!_cred->_clientSslKey.isNull() && !_cred->_clientSslCertificate.isNull()) {
-            // SSL configuration
-            QSslConfiguration sslConfiguration = req.sslConfiguration();
-            sslConfiguration.setLocalCertificate(_cred->_clientSslCertificate);
-            sslConfiguration.setPrivateKey(_cred->_clientSslKey);
-            req.setSslConfiguration(sslConfiguration);
-        }
-
-
+        //qDebug() << "Request for " << req.url() << "with authorization" << QByteArray::fromBase64(credHash);
        return AccessManager::createRequest(op, req, outgoingData);
    }
 private:
    const HttpCredentials *_cred;
 };

-
-static void addSettingsToJob(Account *account, QKeychain::Job *job)
-{
-    Q_UNUSED(account);
-    auto settings = Utility::settingsWithGroup(Theme::instance()->appName());
-    settings->setParent(job); // make the job parent to make setting deleted properly
-    job->setSettings(settings.release());
-}
-
 HttpCredentials::HttpCredentials()
    : _ready(false)
 {
 }

-// From wizard
-HttpCredentials::HttpCredentials(const QString& user, const QString& password, const QSslCertificate& certificate, const QSslKey& key)
+HttpCredentials::HttpCredentials(const QString& user, const QString& password, const QString& certificatePath, const QString& certificatePasswd)
    : _user(user),
      _password(password),
      _ready(true),
-      _clientSslKey(key),
-      _clientSslCertificate(certificate)
+      _certificatePath(certificatePath),
+      _certificatePasswd(certificatePasswd)
 {
 }

@@ -110,6 +86,16 @@ QString HttpCredentials::password() const
    return _password;
 }

+QString HttpCredentials::certificatePath() const
+{
+    return _certificatePath;
+}
+
+QString HttpCredentials::certificatePasswd() const
+{
+    return _certificatePasswd;
+}
+
 void HttpCredentials::setAccount(Account* account)
 {
    AbstractCredentials::setAccount(account);
@@ -143,83 +129,35 @@ void HttpCredentials::fetchFromKeychain()
 {
    // User must be fetched from config file
    fetchUser();
+    _certificatePath = _account->credentialSetting(QLatin1String(certifPathC)).toString();
+    _certificatePasswd = _account->credentialSetting(QLatin1String(certifPasswdC)).toString();

+    auto settings = Utility::settingsWithGroup(Theme::instance()->appName());
    const QString kck = keychainKey(_account->url().toString(), _user );

+    QString key = QString::fromLatin1( "%1/data" ).arg( kck );
+    if( settings && settings->contains(key) ) {
+        // Clean the password from the config file if it is in there.
+        // we do not want a security problem.
+        settings->remove(key);
+        key = QString::fromLatin1( "%1/type" ).arg( kck );
+        settings->remove(key);
+        settings->sync();
+    }
+
    if (_ready) {
        Q_EMIT fetched();
    } else {
-        // Read client cert from keychain
-        const QString kck = keychainKey(_account->url().toString(), _user + clientCertificatePEMC);
        ReadPasswordJob *job = new ReadPasswordJob(Theme::instance()->appName());
-        addSettingsToJob(_account, job);
+        settings->setParent(job); // make the job parent to make setting deleted properly
+        job->setSettings(settings.release());
+
        job->setInsecureFallback(false);
        job->setKey(kck);
-        qDebug() << "-------- ----->" << _clientSslCertificate << _clientSslKey;
-
-        connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotReadClientCertPEMJobDone(QKeychain::Job*)));
+        connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotReadJobDone(QKeychain::Job*)));
        job->start();
    }
 }
-
-void HttpCredentials::slotReadClientCertPEMJobDone(QKeychain::Job* incoming)
-{
-    // Store PEM in memory
-    ReadPasswordJob *readJob = static_cast<ReadPasswordJob*>(incoming);
-    if (readJob->error() == NoError && readJob->binaryData().length() > 0) {
-        QList<QSslCertificate> sslCertificateList = QSslCertificate::fromData(readJob->binaryData(), QSsl::Pem);
-        if(sslCertificateList.length() >= 1) {
-            _clientSslCertificate = sslCertificateList.at(0);
-        }
-    }
-
-    // Load key too
-    const QString kck = keychainKey(_account->url().toString(), _user + clientKeyPEMC);
-    ReadPasswordJob *job = new ReadPasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
-    job->setInsecureFallback(false);
-    job->setKey(kck);
-
-    connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotReadClientKeyPEMJobDone(QKeychain::Job*)));
-    job->start();
-}
-
-void HttpCredentials::slotReadClientKeyPEMJobDone(QKeychain::Job* incoming)
-{
-    // Store key in memory
-    ReadPasswordJob *readJob = static_cast<ReadPasswordJob*>(incoming);
-
-    if (readJob->error() == NoError && readJob->binaryData().length() > 0) {
-        QByteArray clientKeyPEM = readJob->binaryData();
-        // FIXME Unfortunately Qt has a bug and we can't just use QSsl::Opaque to let it
-        // load whatever we have. So we try until it works.
-        _clientSslKey = QSslKey(clientKeyPEM, QSsl::Rsa);
-        if (_clientSslKey.isNull()) {
-            _clientSslKey = QSslKey(clientKeyPEM, QSsl::Dsa);
-        }
-#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
-        // ec keys are Qt 5.5
-        if (_clientSslKey.isNull()) {
-            _clientSslKey = QSslKey(clientKeyPEM, QSsl::Ec);
-        }
-#endif
-        if (_clientSslKey.isNull()) {
-            qDebug() << "Warning: Could not load SSL key into Qt!";
-        }
-    }
-
-    // Now fetch the actual server password
-    const QString kck = keychainKey(_account->url().toString(), _user );
-    ReadPasswordJob *job = new ReadPasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
-    job->setInsecureFallback(false);
-    job->setKey(kck);
-
-    connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotReadJobDone(QKeychain::Job*)));
-    job->start();
-}
-
-
 bool HttpCredentials::stillValid(QNetworkReply *reply)
 {
    return ((reply->error() != QNetworkReply::AuthenticationRequiredError)
@@ -228,10 +166,10 @@ bool HttpCredentials::stillValid(QNetworkReply *reply)
                || !reply->property(authenticationFailedC).toBool()));
 }

-void HttpCredentials::slotReadJobDone(QKeychain::Job *incomingJob)
+void HttpCredentials::slotReadJobDone(QKeychain::Job *job)
 {
-    QKeychain::ReadPasswordJob *job = static_cast<ReadPasswordJob*>(incomingJob);
-    _password = job->textData();
+    ReadPasswordJob *readJob = static_cast<ReadPasswordJob*>(job);
+    _password = readJob->textData();

    if( _user.isEmpty()) {
        qDebug() << "Strange: User is empty!";
@@ -240,6 +178,7 @@ void HttpCredentials::slotReadJobDone(QKeychain::Job *incomingJob)
    QKeychain::Error error = job->error();

    if( !_password.isEmpty() && error == NoError ) {
+
        // All cool, the keychain did not come back with error.
        // Still, the password can be empty which indicates a problem and
        // the password dialog has to be opened.
@@ -275,7 +214,9 @@ void HttpCredentials::invalidateToken()
    }

    DeletePasswordJob *job = new DeletePasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
+    auto settings = Utility::settingsWithGroup(Theme::instance()->appName());
+    settings->setParent(job); // make the job parent to make setting deleted properly
+    job->setSettings(settings.release());
    job->setInsecureFallback(true);
    job->setKey(kck);
    job->start();
@@ -320,37 +261,14 @@ void HttpCredentials::persist()
        // We never connected or fetched the user, there is nothing to save.
        return;
    }
-
    _account->setCredentialSetting(QLatin1String(userC), _user);
-
-    // write cert
+    _account->setCredentialSetting(QLatin1String(certifPathC), _certificatePath);
+    _account->setCredentialSetting(QLatin1String(certifPasswdC), _certificatePasswd);
    WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
-    job->setInsecureFallback(false);
-    connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotWriteClientCertPEMJobDone(QKeychain::Job*)));
-    job->setKey(keychainKey(_account->url().toString(), _user + clientCertificatePEMC));
-    job->setBinaryData(_clientSslCertificate.toPem());
-    job->start();
-}
+    auto settings = Utility::settingsWithGroup(Theme::instance()->appName());
+    settings->setParent(job); // make the job parent to make setting deleted properly
+    job->setSettings(settings.release());

-void HttpCredentials::slotWriteClientCertPEMJobDone(Job *incomingJob)
-{
-    Q_UNUSED(incomingJob);
-    // write ssl key
-    WritePasswordJob* job = new WritePasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
-    job->setInsecureFallback(false);
-    connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotWriteClientKeyPEMJobDone(QKeychain::Job*)));
-    job->setKey(keychainKey(_account->url().toString(), _user + clientKeyPEMC));
-    job->setBinaryData(_clientSslKey.toPem());
-    job->start();
-}
-
-void HttpCredentials::slotWriteClientKeyPEMJobDone(Job *incomingJob)
-{
-    Q_UNUSED(incomingJob);
-    WritePasswordJob* job = new WritePasswordJob(Theme::instance()->appName());
-    addSettingsToJob(_account, job);
    job->setInsecureFallback(false);
    connect(job, SIGNAL(finished(QKeychain::Job*)), SLOT(slotWriteJobDone(QKeychain::Job*)));
    job->setKey(keychainKey(_account->url().toString(), _user));
@@ -17,8 +17,7 @@
 #define MIRALL_CREDS_HTTP_CREDENTIALS_H

 #include <QMap>
-#include <QSslCertificate>
-#include <QSslKey>
+
 #include "creds/abstractcredentials.h"

 class QNetworkReply;
@@ -26,8 +25,6 @@ class QAuthenticator;

 namespace QKeychain {
 class Job;
-class WritePasswordJob;
-class ReadPasswordJob;
 }

 namespace OCC
@@ -36,10 +33,10 @@ namespace OCC
 class OWNCLOUDSYNC_EXPORT HttpCredentials : public AbstractCredentials
 {
    Q_OBJECT
-    friend class HttpCredentialsAccessManager;
+
 public:
    explicit HttpCredentials();
-    HttpCredentials(const QString& user, const QString& password, const QSslCertificate& certificate = QSslCertificate(), const QSslKey& key = QSslKey());
+    HttpCredentials(const QString& user, const QString& password, const QString& certificatePath,  const QString& certificatePasswd);

    QString authType() const Q_DECL_OVERRIDE;
    QNetworkAccessManager* getQNAM() const Q_DECL_OVERRIDE;
@@ -53,19 +50,15 @@ public:
    void forgetSensitiveData() Q_DECL_OVERRIDE;
    QString fetchUser();
    virtual bool sslIsTrusted() { return false; }
+    QString certificatePath() const;
+    QString certificatePasswd() const;

    // To fetch the user name as early as possible
    void setAccount(Account* account) Q_DECL_OVERRIDE;

 private Q_SLOTS:
    void slotAuthentication(QNetworkReply*, QAuthenticator*);
-
-    void slotReadClientCertPEMJobDone(QKeychain::Job*);
-    void slotReadClientKeyPEMJobDone(QKeychain::Job*);
    void slotReadJobDone(QKeychain::Job*);
-
-    void slotWriteClientCertPEMJobDone(QKeychain::Job*);
-    void slotWriteClientKeyPEMJobDone(QKeychain::Job*);
    void slotWriteJobDone(QKeychain::Job*);
    void clearQNAMCache();

@@ -73,11 +66,12 @@ protected:
    QString _user;
    QString _password;
    QString _previousPassword;
-
    QString _fetchErrorString;
    bool _ready;
-    QSslKey _clientSslKey;
-    QSslCertificate _clientSslCertificate;
+
+private:
+    QString _certificatePath;
+    QString _certificatePasswd;
 };

 } // namespace OCC
@@ -146,17 +146,6 @@ void FileSystem::setFileReadOnly(const QString& filename, bool readonly)
    file.setPermissions(permissions);
 }

-void FileSystem::setFolderMinimumPermissions(const QString& filename)
-{
-#ifdef Q_OS_MAC
-    QFile::Permissions perm = QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner;
-    QFile file(filename);
-    file.setPermissions(perm);
-#else
-    Q_UNUSED(filename);
-#endif
-}
-

 void FileSystem::setFileReadOnlyWeak(const QString& filename, bool readonly)
 {
@@ -67,12 +67,6 @@ void OWNCLOUDSYNC_EXPORT setFileReadOnly(const QString& filename, bool readonly)
 */
 void OWNCLOUDSYNC_EXPORT setFileReadOnlyWeak(const QString& filename, bool readonly);

-/**
- * @brief Try to set permissions so that other users on the local machine can not
- * go into the folder.
- */
-void OWNCLOUDSYNC_EXPORT setFolderMinimumPermissions(const QString& filename);
-
 /** convert a "normal" windows path into a path that can be 32k chars long. */
 QString OWNCLOUDSYNC_EXPORT longWinPath( const QString& inpath );

@@ -19,8 +19,6 @@
 #include <QThread>
 #include <qmetaobject.h>

-#include "csync.h"
-
 namespace OCC {

 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
@@ -50,14 +48,6 @@ static void mirallLogCatcher(QtMsgType type, const QMessageLogContext &ctx, cons
 }
 #endif

-static void csyncLogCatcher(int /*verbosity*/,
-                        const char * /*function*/,
-                        const char *buffer,
-                        void * /*userdata*/)
-{
-    Logger::instance()->csyncLog( QString::fromUtf8(buffer) );
-}
-
 Logger *Logger::instance()
 {
    static Logger log;
@@ -65,7 +55,7 @@ Logger *Logger::instance()
 }

 Logger::Logger( QObject* parent) : QObject(parent),
-  _showTime(true), _logWindowActivated(false), _doFileFlush(false), _logExpire(0)
+  _showTime(true), _doLogging(false), _doFileFlush(false), _logExpire(0)
 {
 #ifndef NO_MSG_HANDLER
 #if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
@@ -127,8 +117,12 @@ bool Logger::isNoop() const
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
    return false;
 #else
+    static auto signal = QMetaMethod::fromSignal(&Logger::newLog);
+    if (isSignalConnected(signal)) {
+        return false;
+    }
    QMutexLocker lock(const_cast<QMutex *>(&_mutex));
-    return !_logstream && !_logWindowActivated;
+    return !_logstream;
 #endif
 }

@@ -142,7 +136,7 @@ void Logger::doLog(const QString& msg)
            if( _doFileFlush ) _logstream->flush();
        }
    }
-    emit logWindowLog(msg);
+    emit newLog(msg);
 }

 void Logger::csyncLog( const QString& message )
@@ -170,25 +164,10 @@ void Logger::mirallLog( const QString& message )
    Logger::instance()->log( log_ );
 }

-void Logger::setLogWindowActivated(bool activated)
-{
-    QMutexLocker locker(&_mutex);
-
-    // Setup CSYNC logging to forward to our own logger
-    csync_set_log_callback(csyncLogCatcher);
-    csync_set_log_level(11);
-
-    _logWindowActivated = activated;
-}
-
 void Logger::setLogFile(const QString & name)
 {
    QMutexLocker locker(&_mutex);

-    // Setup CSYNC logging to forward to our own logger
-    csync_set_log_callback(csyncLogCatcher);
-    csync_set_log_level(11);
-
    if( _logstream ) {
        _logstream.reset(0);
        _logFile.close();
@@ -61,15 +61,13 @@ public:
  void postOptionalGuiLog(const QString& title, const QString& message);
  void postGuiMessage(const QString& title, const QString& message);

-  void setLogWindowActivated(bool activated);
  void setLogFile( const QString & name );
  void setLogExpire( int expire );
  void setLogDir( const QString& dir );
  void setLogFlush( bool flush );

 signals:
-  void logWindowLog(const QString&);
-
+  void newLog(const QString&);
  void guiLog(const QString&, const QString&);
  void guiMessage(const QString&, const QString&);
  void optionalGuiLog(const QString&, const QString&);
@@ -82,7 +80,7 @@ private:
  ~Logger();
  QList<Log> _logs;
  bool       _showTime;
-  bool       _logWindowActivated;
+  bool       _doLogging;
  QFile       _logFile;
  bool        _doFileFlush;
  int         _logExpire;
@@ -463,7 +463,7 @@ bool CheckServerJob::finished()
    }

    bool success = false;
-    QByteArray body = reply()->peek(4*1024);
+    QByteArray body = reply()->readAll();
    int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    if( body.isEmpty() || httpStatus != 200) {
        qDebug() << "error: status.php replied " << httpStatus << body;
@@ -472,7 +472,7 @@ bool CheckServerJob::finished()
        QVariantMap status = QtJson::parse(QString::fromUtf8(body), success).toMap();
        // empty or invalid response
        if (!success || status.isEmpty()) {
-            qDebug() << "status.php from server is not valid JSON!" << body << reply()->request().url();
+            qDebug() << "status.php from server is not valid JSON!";
        }

        qDebug() << "status.php returns: " << status << " " << reply()->error() << " Reply: " << reply();
@@ -108,11 +108,6 @@ static bool blacklistCheck(SyncJournalDb* journal, const SyncFileItem& item)

    if (newEntry.isValid()) {
        journal->updateErrorBlacklistEntry(newEntry);
-        // Also clear upload info if any so we don't resume from the same transfer-id if there was too many failures (#5344)
-        // (maybe the reason is that the state for this transfer id is broken on the server.)
-        if (newEntry._retryCount > 3) {
-            journal->setUploadInfo(item._file, SyncJournalDb::UploadInfo());
-        }
    } else if (oldEntry.isValid()) {
        journal->wipeErrorBlacklistEntry(item._file);
    }
@@ -276,7 +271,9 @@ PropagateItemJob* OwncloudPropagator::createJob(const SyncFileItemPtr &item) {
                return job;
            } else {
                PropagateUploadFileCommon *job = 0;
-                if (item->_size > chunkSize() && account()->capabilities().chunkingNg()) {
+                static const auto chunkng = qgetenv("OWNCLOUD_CHUNKING_NG");
+                if (item->_size > chunkSize()
+                        && (account()->capabilities().chunkingNg() || chunkng == "1") && chunkng != "0") {
                    job = new PropagateUploadFileNG(this, item);
                } else {
                    job = new PropagateUploadFileV1(this, item);
@@ -317,7 +314,7 @@ void OwncloudPropagator::start(const SyncFileItemVector& items)

        if (!removedDirectory.isEmpty() && item->_file.startsWith(removedDirectory)) {
            // this is an item in a directory which is going to be removed.
-            PropagateDirectory *delDirJob = qobject_cast<PropagateDirectory*>(directoriesToRemove.first());
+            PropagateDirectory *delDirJob = dynamic_cast<PropagateDirectory*>(directoriesToRemove.first());

            if (item->_instruction == CSYNC_INSTRUCTION_REMOVE) {
                // already taken care of. (by the removal of the parent directory)
@@ -415,12 +412,10 @@ void OwncloudPropagator::start(const SyncFileItemVector& items)
    QTimer::singleShot(0, this, SLOT(scheduleNextJob()));
 }

-// ownCloud server  < 7.0 did not had permissions so we need some other euristics
-// to detect wrong doing in a Shared directory
 bool OwncloudPropagator::isInSharedDirectory(const QString& file)
 {
    bool re = false;
-    if( _remoteFolder.startsWith( QLatin1String("Shared") ) ) {
+    if( _remoteDir.contains( _account->davPath() + QLatin1String("Shared") ) ) {
        // The Shared directory is synced as its own sync connection
        re = true;
    } else {
@@ -267,7 +267,8 @@ class OwncloudPropagator : public QObject {

 public:
    const QString _localDir; // absolute path to the local directory. ends with '/'
-    const QString _remoteFolder; // remote folder, ends with '/'
+    const QString _remoteDir; // path to the root of the remote. ends with '/'  (include WebDAV path)
+    const QString _remoteFolder; // folder. (same as remoteDir but without the WebDAV path)

    SyncJournalDb * const _journal;
    bool _finishedEmited; // used to ensure that finished is only emitted once
@@ -275,8 +276,10 @@ public:

 public:
    OwncloudPropagator(AccountPtr account, const QString &localDir,
-                       const QString &remoteFolder, SyncJournalDb *progressDb)
+                       const QString &remoteDir, const QString &remoteFolder,
+                       SyncJournalDb *progressDb)
            : _localDir((localDir.endsWith(QChar('/'))) ? localDir : localDir+'/' )
+            , _remoteDir((remoteDir.endsWith(QChar('/'))) ? remoteDir : remoteDir+'/' )
            , _remoteFolder((remoteFolder.endsWith(QChar('/'))) ? remoteFolder : remoteFolder+'/' )
            , _journal(progressDb)
            , _finishedEmited(false)
@@ -70,9 +70,7 @@ bool SqlDatabase::openHelper( const QString& filename, int sqliteFlags )

 bool SqlDatabase::checkDb()
 {
-    // quick_check can fail with a disk IO error when diskspace is low
-    SqlQuery quick_check(*this);
-    quick_check.prepare("PRAGMA quick_check;", /*allow_failure=*/true);
+    SqlQuery quick_check("PRAGMA quick_check;", *this);
    if( !quick_check.exec() ) {
        qDebug() << "Error running quick_check on database";
        return false;
@@ -99,14 +97,6 @@ bool SqlDatabase::openOrCreateReadWrite( const QString& filename )
    }

    if( !checkDb() ) {
-        // When disk space is low, checking the db may fail even though it's fine.
-        qint64 freeSpace = Utility::freeDiskSpace(filename);
-        if (freeSpace < 1000000) {
-            qDebug() << "Consistency check failed, disk space is low, aborting" << freeSpace;
-            close();
-            return false;
-        }
-
        qDebug() << "Consistency check failed, removing broken db" << filename;
        close();
        QFile::remove(filename);
@@ -201,7 +191,7 @@ SqlQuery::SqlQuery(const QString& sql, SqlDatabase& db)
    prepare(sql);
 }

-int SqlQuery::prepare( const QString& sql, bool allow_failure )
+int SqlQuery::prepare( const QString& sql)
 {
    QString s(sql);
    _sql = s.trimmed();
@@ -223,7 +213,7 @@ int SqlQuery::prepare( const QString& sql, bool allow_failure )
        if( _errId != SQLITE_OK ) {
            _error = QString::fromUtf8(sqlite3_errmsg(_db));
            qWarning() << "Sqlite prepare statement error:" << _error << "in" <<_sql;
-            Q_ASSERT(allow_failure || !"SQLITE Prepare error");
+            Q_ASSERT(!"SQLITE Prepare error");
        }
    }
    return _errId;
@@ -80,7 +80,7 @@ public:
    bool isSelect();
    bool isPragma();
    bool exec();
-    int  prepare( const QString& sql, bool allow_failure = false );
+    int  prepare( const QString& sql );
    bool next();
    void bindValue(int pos, const QVariant& value);
    QString lastQuery() const;
@@ -145,12 +145,8 @@ void ProgressInfo::reset()
    _sizeProgress = Progress();
    _fileProgress = Progress();
    _totalSizeOfCompletedJobs = 0;
-
-    // Historically, these starting estimates were way lower, but that lead
-    // to gross overestimation of ETA when a good estimate wasn't available.
-    _maxBytesPerSecond = 2000000.0; // 2 MB/s
-    _maxFilesPerSecond = 10.0;
-
+    _maxBytesPerSecond = 100000.0;
+    _maxFilesPerSecond = 2.0;
    _updateEstimatesTimer.stop();
    _lastCompletedItem = SyncFileItem();
 }
@@ -401,7 +401,7 @@ void PropagateDownloadFile::start()
        // Normal job, download from oC instance
        _job = new GETFileJob(_propagator->account(),
                            _propagator->_remoteFolder + _item->_file,
-                            &_tmpFile, headers, expectedEtagForResume, _resumeStart, this);
+                            &_tmpFile, headers, expectedEtagForResume, _resumeStart);
    } else {
        // We were provided a direct URL, use that one
        qDebug() << Q_FUNC_INFO << "directDownloadUrl given for " << _item->_file << _item->_directDownloadUrl;
@@ -413,7 +413,7 @@ void PropagateDownloadFile::start()
        QUrl url = QUrl::fromUserInput(_item->_directDownloadUrl);
        _job = new GETFileJob(_propagator->account(),
                              url,
-                              &_tmpFile, headers, expectedEtagForResume, _resumeStart, this);
+                              &_tmpFile, headers, expectedEtagForResume, _resumeStart);
    }
    _job->setBandwidthManager(&_propagator->_bandwidthManager);
    connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotGetFinished()));
@@ -20,7 +20,6 @@
 #include "filesystem.h"
 #include <QFile>
 #include <QStringList>
-#include <QDir>

 namespace OCC {

@@ -102,11 +101,10 @@ void PropagateRemoteMove::start()
        }
    }

-    QString destination = QDir::cleanPath(_propagator->account()->url().path() + QLatin1Char('/')
-            + _propagator->account()->davPath() + _propagator->_remoteFolder + _item->_renameTarget);
    _job = new MoveJob(_propagator->account(),
                        _propagator->_remoteFolder + _item->_file,
-                        destination, this);
+                        _propagator->_remoteDir + _item->_renameTarget,
+                        this);
    connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotMoveJobFinished()));
    _propagator->_activeJobList.append(this);
    _job->start();
@@ -177,7 +175,7 @@ void PropagateRemoteMove::finalize()
        record._contentChecksum = oldRecord._contentChecksum;
        record._contentChecksumType = oldRecord._contentChecksumType;
        if (record._fileSize != oldRecord._fileSize) {
-            qDebug() << "Warning: file sizes differ on server vs sync journal: " << record._fileSize << oldRecord._fileSize;
+            qDebug() << "Warning: file sizes differ on server vs csync_journal: " << record._fileSize << oldRecord._fileSize;
            record._fileSize = oldRecord._fileSize; // server might have claimed different size, we take the old one from the DB
        }
    }
--- a/Mostrar Mais
+++ b/Mostrar Mais