VERSION.cmake: 2.4.0 alpha1

2026-04-09 06:13:05 +02:00 · 2017-10-05 17:43:32 +02:00
124 changed files with 9655 additions and 13376 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -199,7 +199,7 @@ if(BUILD_CLIENT)
        endif()
    endif()

-   find_package(ZLIB REQUIRED)
+   find_package(ZLIB)
 endif()

 if (NOT DEFINED APPLICATION_ICON_NAME)
--- a/90
+++ b/90
@@ -1,103 +1,75 @@
 ChangeLog
 =========

-version 2.4.0 (2017-11-XX)
-* If you're using 2.4.0 alpha1, please upgrade as the alpha1 had an issue with hidden files!
-* OAuth2 authentication support by opening external browser (#5668)
+version 2.4.0 (2017-1X-XX)
+* OAuth2 authentication support by opening external browser
+* Sync Issues: More functional error view including filters and conflicts (#5516)
 * Sharing: Add support for multiple public link shares (#5655)
-* Sharing: Add option to copy/email private links (#5023, #5627)
+* Sharing: Add option to copy/email private links (#5627, #5023)
 * Sharing: Add option "show file listing" (#5837)
-* Sharing: Show warning that links are public (#5747)
-* Sharing: Sharing dialog redesign: multiple share links support (#5695)
+* Sharing: Show warning that links are public
+* Sharing: Many UI improvements
 * Sharing: Make "can edit" partially checked sometimes (#5642)
-* Sharing: Trigger a sync for folder affected by a change of sharing (#6098)
 * Wizard: Never propose an existing folder for syncing (#5597)
 * Wizard: Don't show last page anymore, go to settings directly (#5726)
-* Wizard: Handle url-shortener redirects (#5954)
-* Wizard: Resolve url/ redirects only if url/status.php not found (#5954)
-* Wizard: Add explanation text when server error is shown (#6157)
-* Wizard: Update the window size on high dpi screen (#6156)
-* Wizard: Don't report confusing error message (#6116)
-* Gui: Display the user server avatar (#5482)
-* Gui: Use display name of user, not internal name
+* Wizard: Handle url-shortener redirects #5954
+* Gui: Display the user server avatar
 * Server URL: Update configuration in case of permanent redirection (#5972)
-* Gui: Allow to add multiple sync folder connection of the same folder (#6032)
-* Tray Menu: More detailed status messages
-* Tray Menu: Shibboleth: raise the browser when clicking on the tray (#6105)
-* Activity: Link errors from the account tab, allow filtering by account/folder (#5861)
-* Activity: Present conflicts more prominently (#5894)
-* Activity: Allow sorting the columns in issues and protocol tabs (#6093, #6086)
+* Gui: Allow to add multiple sync folder connection of the same folder
 * Selective Sync: Open sub folder context menu (#5596)
-* Selective Sync: Skip excluded folders when reading db (#5772)
+* Selective Sync: Skip excluded folders when reading db
 * Selective Sync: Remove local files of unselected folder despite other modified files (#5783)
-* Excludes: Remove .htaccess form list of excluded files (#5701)
+* Excludes: remove .htaccess form list of excluded files
 * Excludes: Hardcode desktop.ini
 * Excludes: Allow escaping "#" (#6012)
-* Excludes: Use faster matching via QRegularExpression (#6063)
-* Discovery: Increase the MAX_DEPTH and show deep folders as ignored (#1067)
+* Excludes: Use faster matching via QRegularExpression
+* Discovery: Increase the MAX_DEPTH and show deep folders as ignored
 * Discovery: General speed improvements
 * Downloads: Remove empty temporary if disk space full (#5746)
-* Downloads: Read Content-MD5 header for object store setups
-* Checksums: Add global disable environment variable (#5017)
-* Quota: PropagateUpload: Model of remote quota, avoid some uploads (#5537)
+* Downloads: Re-trigger folder discovery on 404
+* Quota:  PropagateUpload: Model of remote quota, avoid some uploads (#5537)
+* When creating explorer favorite use more specific windows functions (#5690)
 * Create favorite also in folder wizard (#455)
-* Windows: Use the application icon for the Windows 8 sidebar favorite (#2446, #5690)
+* Windows: Use the application icon for the Windows 8 sidebar favorite (#2446)
 * macOS: Finder sidebar icon (#296)
 * Overlay Icons: Consider also the "shared by me" as shared (#4788)
-* Overlay Icons: Update right after sharing (#6115)
 * Overlay Icons: Fix different case paths not matching (#5257)
-* Overlay Icons: Detect changes in the shared flag (#6098)
 * Windows Overlay Icons: Potential hang fixes
 * Linux Overlay Icons: fix branded nemo and caja shell integration (#5966)
-* Credentials: Fix behavior for bad password (#5989)
-* Credentials: Don't create empty client cert keychain entries (#5752)
-* Credentials: Namespace windows cred keys (#6125)
-* Credentials: Use per-account keychain entries (#5830, #6126)
+* Http credentials: Fix behavior for bad password (#5989)
+* Credentials: Use per-account keychain entries (#5830)
 * AccountSettings: Triggering log in re-ask about previously rejected certificates (#5819)
-* owncloudcmd: Added bandwidth limit parameter (#5707)
-* owncloudcmd: Fix timestamps, Fix --logdebug
+* Added owncloudcmd bandwidth limit parameter (#5707)
 * AccountSettings: Sync with clean discovery on Ctrl-F6 (#5666)
-* Sync: Dynamic sizing of chunks in chunked uploads for improved big file upload performance (#5852)
+* Sync: Dynamic sizing of chunks in chunked uploads for improved big file upload performance
 * Sync: Introduce overall errors that are not tied to a file (#5746)
 * Sync: Better messaging for 507 Insufficient Storage (#5537)
 * Sync: Create conflicts by comparing the hash of files with identical mtime/size (#5589)
-* Sync: Upload conflict files if OWNCLOUD_UPLOAD_CONFLICT_FILES environment variable is set (#6038)
 * Sync: Blacklist: Don't let errors become warnings (#5516)
 * Sync: Check etag again after active sync (#4116)
-* Sync: Rename handling fixes: duplicate file ids (#6096)
-* Sync: Rename handling fixes: File size must be equal
-* Sync: Rename handling: Fix duplicate files on abort/resume sync (#5949)
-* Sync: Add capability for invalid filename regexes (#6092)
 * SyncJournalDB: Fall back to DELETE journal mode if WAL mode does not seem to work (#5723)
-* SyncJournalDB: Don't crash if the db file is readonly (#6050)
-* SyncJournalDB: DB close error is not fatal
 * Fix at least one memory leak
 * Documentation improvements
-* Logging improvements (With Qt logging categories) (#5671)
-* Logging filtering per account (#5672)
+* Logging improvements (with Qt logging categories), new --logdebug parameter
 * Crash fixes
 * Test improvements
 * Small UI layout fixes
 * Maintenance Mode: Detect maintenance mode (#4485)
 * Maintenance Mode: Add a 1 to 5 min reconnection delay (#5872)
 * HTTP: Send a unique X-Request-ID with each request (#5853)
-* HTTP: Support HTTP2 when built and running with Qt 5.9.x (Official packages still on Qt 5.6.x) (#5659)
+* HTTP: Support HTTP2 when built and running with Qt 5.9.x (Official packages still on Qt 5.6.x)
 * owncloudcmd: Don't start if connection or auth fails (#5692)
-* csync: Switch build from C to C++ (#6033)
+* csync: Switch build from C to C++
 * csync: Refactor a lot to use common data structures to save memory and memory copying
 * csync: Switch some data structures to Qt data structures
-* csync: Switch to using upper layer SyncJournalDB (#6087)
+* csync: Switch to using upper layer SyncJournalDB
 * Switch 3rdparty/json usage to Qt5's QJson (#5710)
-* OpenSSL: Don't require directly, only via Qt (#5833)
-* Remove iconv dependency, use Qt for file system locale encoding/decoding (emoji filename support on macOS) (#5875)
-* Compilation: Remove Qt 4 code (#6025, #5702, #5505)
-* Harmonize source code style with clang-format (#5732)
-* Switch over to Qt 5 function pointer signal/slot syntax (#6041)
-* Updater: Rudimentary support for beta channel (#6048)
-
-version 2.3.4 (2017-11-02)
-* Checksums: Use addData function to avoid endless loop CPU load issues with Office files
-* Packaging: Require ZLIB
+* OpenSSL: Don't require directly, only via Qt
+* Remove iconv dependency, use Qt for file system locale encoding/decoding (emoji filename support on macOS)
+* Compilation: Remove Qt 4 code
+* Harmonize source code style with clang-format
+* Switch over to Qt 5 function pointer signal/slot syntax
+* Updater: Rudimentary support for beta channel

 version 2.3.3 (2017-08-29)
 * Chunking NG: Don't use old chunking on new DAV endpoint (#5855)
--- a/VERSION.cmake
+++ b/VERSION.cmake
@@ -5,7 +5,7 @@ set( MIRALL_VERSION_YEAR  2017 )
 set( MIRALL_SOVERSION 0 )

 if ( NOT DEFINED MIRALL_VERSION_SUFFIX )
-    set( MIRALL_VERSION_SUFFIX "beta1") #e.g. beta1, beta2, rc1
+    set( MIRALL_VERSION_SUFFIX "alpha1") #e.g. beta1, beta2, rc1
 endif( NOT DEFINED MIRALL_VERSION_SUFFIX )

 if( NOT DEFINED MIRALL_VERSION_BUILD )
--- a/admin/win/nsi/l10n/Norwegian.nsh
+++ b/admin/win/nsi/l10n/Norwegian.nsh
@@ -3,7 +3,7 @@ StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Vis versjonsmerknader"
 StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "Fant ${APPLICATION_EXECUTABLE}-prosess(er) som må stoppes.$\nVil du at installasjonsprogrammet skal stoppe dem for deg?"
 StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Terminerer ${APPLICATION_EXECUTABLE}-prosesser."
 StrCpy $ConfirmEndProcess_KILL_NOT_FOUND_TEXT "Fant ikke prosess som skulle termineres!"
-StrCpy $PageReinstall_NEW_Field_1 "En eldre versjon av ${APPLICATION_NAME} er installert på systemet ditt. Det anbefales at du avinstallerer den versjonen før installering av ny versjon. Velg hva du vil gjøre og klikk Neste for å fortsette."
+StrCpy $PageReinstall_NEW_Field_1 "En eldre versjon av ${APPLICATION_NAME} er installert på systemet ditt. Det anbefales at du avnistallerer den versjonen før installering av ny versjon. Velg hva du vil gjøre og klikk Neste for å fortsette."
 StrCpy $PageReinstall_NEW_Field_2 "Avinstaller før installering"
 StrCpy $PageReinstall_NEW_Field_3 "Ikke avinstaller"
 StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_TITLE "Allerede installert"
--- a/admin/win/nsi/l10n/Spanish.nsh
+++ b/admin/win/nsi/l10n/Spanish.nsh
@@ -1,9 +1,9 @@
 # Auto-generated - do not modify
 StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Mostrar las notas de la versión"
-StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "El/los proceso(s) ${APPLICATION_EXECUTABLE} debe(n) ser detenido(s).$\n¿Quiere que el instalador lo haga por usted?"
-StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Deteniendo el/los proceso(s) ${APPLICATION_EXECUTABLE}."
+StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "El/los proceso/s ${APPLICATION_EXECUTABLE} debe/n ser detenidos.$\n¿Quiere que el instalador lo haga por usted?"
+StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Deteniendo el/los proceso/s ${APPLICATION_EXECUTABLE}."
 StrCpy $ConfirmEndProcess_KILL_NOT_FOUND_TEXT "¡Proceso a finalizar no encontrado!"
-StrCpy $PageReinstall_NEW_Field_1 "Una versión anterior de ${APPLICATION_NAME} se encuentra instalada en el sistema. Se recomienda desinstalar la versión actual antes de instalar la nueva. Seleccione la operacion deseada y haga click en Siguiente para continuar."
+StrCpy $PageReinstall_NEW_Field_1 "Una versión anterior de ${APPLICATION_NAME} se encuentra instalada en el sistema. Se recomienda de instalar la versión actual antes de instalar la nueva. Seleccione la operacion deseada y haga click en Siguiente para continuar."
 StrCpy $PageReinstall_NEW_Field_2 "Desinstalar antes de instalar"
 StrCpy $PageReinstall_NEW_Field_3 "No desinstalar"
 StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_TITLE "Ya está instalado"
@@ -17,13 +17,13 @@ StrCpy $PageReinstall_SAME_MUI_HEADER_TEXT_SUBTITLE "Elija la opcion de mantenim
 StrCpy $SEC_APPLICATION_DETAILS "Instalando  ${APPLICATION_NAME} esenciales."
 StrCpy $OPTION_SECTION_SC_SHELL_EXT_SECTION "Integración para Windows Explorer"
 StrCpy $OPTION_SECTION_SC_SHELL_EXT_DetailPrint "Instalando la integración para Windows Explorer"
-StrCpy $OPTION_SECTION_SC_START_MENU_SECTION "Acceso directo al programa en Menú de Inicio"
+StrCpy $OPTION_SECTION_SC_START_MENU_SECTION "Acceso directo al programa Menú de Inicio"
 StrCpy $OPTION_SECTION_SC_START_MENU_DetailPrint "Añadiendo accesos directos para ${APPLICATION_NAME} en el Menú de Inicio."
 StrCpy $OPTION_SECTION_SC_DESKTOP_SECTION "Acceso directo de Escritorio"
 StrCpy $OPTION_SECTION_SC_DESKTOP_DetailPrint "Creando accesos directos de escritorio"
-StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_SECTION "Atajo de acceso rápido"
+StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_SECTION "Atajo de accceso rápido"
 StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_DetailPrint "Creando un Acceso Directo al Lanzador Rápido"
-StrCpy $OPTION_SECTION_SC_APPLICATION_Desc "${APPLICATION_NAME} esenciales."
+StrCpy $OPTION_SECTION_SC_APPLICATION_Desc "${APPLICATION_NAME} esencial."
 StrCpy $OPTION_SECTION_SC_START_MENU_Desc "Acceso Directo de ${APPLICATION_NAME}"
 StrCpy $OPTION_SECTION_SC_DESKTOP_Desc "Acceso Directo de Escritorio para ${APPLICATION_NAME}"
 StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_Desc "Lanzador Rápido de Accesos Director para ${APPLICATION_NAME}."
--- a/doc/advancedusage.rst
+++ b/doc/advancedusage.rst
@@ -15,7 +15,7 @@ Configuration File
 .. include:: conffile.rst

 Environment Variables
---------------------
+------------------
 .. index:: env vars
 .. include:: envvars.rst

--- a/doc/conffile.rst
+++ b/doc/conffile.rst
@@ -62,4 +62,4 @@ Some interesting values that can be set on the configuration file are:
 |                                 |               | ``2`` for No Proxy.                                                                                    |
 +                                 +               +--------------------------------------------------------------------------------------------------------+
 |                                 |               | ``3`` for HTTP(S) Proxy.                                                                               |
-+---------------------------------+---------------+--------------------------------------------------------------------------------------------------------+
+---------------------------------+---------------+--------------------------------------------------------------------------------------------------------+
--- a/doc/faq.rst
+++ b/doc/faq.rst
@@ -1,7 +1,7 @@
 FAQ
 ===

-Some Files Are Continuously Uploaded to the Server, Even When They Are Not Modified.
+Some files are continuously uploaded to the server, even when they are not modified.
 ------------------------------------------------------------------------------------

 It is possible that another program is changing the modification date of the file.
@@ -11,17 +11,15 @@ continually changes all files, unless you remove
 from the windows registry.
 See http://petersteier.wordpress.com/2011/10/22/windows-indexer-changes-modification-dates-of-eml-files/ for more information.

-Syncing Stops When Attempting To Sync Deeper Than 100 Sub-directories.
----------------------------------------------------------------------
+Syncing breaks when attempting to sync deeper than 50 sub-directories, but the sync client does not report an error (RC=0)
+--------------------------------------------------------------------------------------------------------------------------

-The sync client has been intentionally limited to sync no deeper than 100
-sub-directories. The hard limit exists to guard against bugs with cycles
-like symbolic link loops.
-When a deeply nested directory is excluded from synchronization it will be
-listed with other ignored files and directories in the "Not synced" tab of
-the "Activity" pane.
+The sync client has been intentionally limited to sync no deeper than
+fifty sub-directories, to help prevent memory problems. 
+Unfortunately, it, *currently*, does not report an error when this occurs. 
+However, a UI notification is planned for a future release of ownCloud.

-I Want To Move My Local Sync Folder
+I want to move my local sync folder
 -----------------------------------

 The ownCloud desktop client does not provide a way to change the local sync directory. 
@@ -31,20 +29,20 @@ Specifically, you have to:
 1. Remove the existing connection which syncs to the wrong directory
 2. Add a new connection which syncs to the desired directory

-.. figure:: images/setup/ownCloud-remove_existing_connection.png
+.. image:: images/setup/ownCloud-remove_existing_connection.png
   :alt: Remove an existing connection

 To do so, in the client UI, which you can see above, click the "**Account**" drop-down menu and then click "Remove". 
 This will display a "**Confirm Account Removal**" dialog window.

-.. figure:: images/setup/ownCloud-remove_existing_connection_confirmation_dialog.png
+.. image:: images/setup/ownCloud-remove_existing_connection_confirmation_dialog.png
   :alt: Remove existing connection confirmation dialog

 If you're sure, click "**Remove connection**".

 Then, click the Account drop-down menu again, and this time click "**Add new**".

-.. figure:: images/setup/ownCloud-replacement_connection_wizard.png
+.. image:: images/setup/ownCloud-replacement_connection_wizard.png
   :alt: Replacement connection wizard

 This opens the ownCloud Connection Wizard, which you can see above, *but* with an extra option.
--- a/doc/installing.rst
+++ b/doc/installing.rst
@@ -3,7 +3,7 @@ Installing the Desktop Synchronization Client
 =============================================

 You can download the  latest version of the ownCloud Desktop Synchronization 
-Client from the `ownCloud download page`_. 
+Client from the `ownCloud download page <https://owncloud.org/install/>`_. 
 There are clients for Linux, Mac OS X, and Microsoft Windows.

 Installation on Mac OS X and Windows is the same as for any software 
@@ -58,7 +58,3 @@ synchronizing your files.
    Web GUI, and one to open your local ownCloud folder

 Click the Finish button, and you're all done. 
-
-.. Links
-   
-.. _ownCloud download page: https://owncloud.com/download/#desktop-clients
--- a/mirall.desktop.in
+++ b/mirall.desktop.in
@@ -183,135 +183,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
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
 # Translations
 Comment[oc]=@APPLICATION_NAME@ sincronizacion del client
 GenericName[oc]=Dorsièr de Sincronizacion
--- a/src/3rdparty/sqlite3/sqlite3.c
+++ b/src/3rdparty/sqlite3/sqlite3.c
--- a/src/3rdparty/sqlite3/sqlite3.h
+++ b/src/3rdparty/sqlite3/sqlite3.h
@@ -115,17 +115,15 @@ extern "C" {
 ** a string which identifies a particular check-in of SQLite
 ** within its configuration management system.  ^The SQLITE_SOURCE_ID
 ** string contains the date and time of the check-in (UTC) and a SHA1
-** or SHA3-256 hash of the entire source tree.  If the source code has
-** been edited in any way since it was last checked in, then the last
-** four hexadecimal digits of the hash may be modified.
+** or SHA3-256 hash of the entire source tree.
 **
 ** See also: [sqlite3_libversion()],
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.21.0"
-#define SQLITE_VERSION_NUMBER 3021000
-#define SQLITE_SOURCE_ID      "2017-10-24 18:55:49 1a584e499906b5c87ec7d43d4abce641fdf017c42125b083109bc77c4de48827"
+#define SQLITE_VERSION        "3.20.1"
+#define SQLITE_VERSION_NUMBER 3020001
+#define SQLITE_SOURCE_ID      "2017-08-24 16:21:36 8d3a7ea6c5690d6b7c3767558f4f01b511c55463e3f9e64506801fe9b74dce34"

 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -141,7 +139,7 @@ extern "C" {
 **
 ** <blockquote><pre>
 ** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
+** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
 ** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
 ** </pre></blockquote>)^
 **
@@ -151,11 +149,9 @@ extern "C" {
 ** function is provided for use in DLLs since DLL users usually do not have
 ** direct access to string constants within the DLL.  ^The
 ** sqlite3_libversion_number() function returns an integer equal to
-** [SQLITE_VERSION_NUMBER].  ^(The sqlite3_sourceid() function returns 
+** [SQLITE_VERSION_NUMBER].  ^The sqlite3_sourceid() function returns 
 ** a pointer to a string constant whose value is the same as the 
-** [SQLITE_SOURCE_ID] C preprocessor macro.  Except if SQLite is built
-** using an edited copy of [the amalgamation], then the last four characters
-** of the hash might be different from [SQLITE_SOURCE_ID].)^
+** [SQLITE_SOURCE_ID] C preprocessor macro.
 **
 ** See also: [sqlite_version()] and [sqlite_source_id()].
 */
@@ -436,7 +432,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_FULL        13   /* Insertion failed because database is full */
 #define SQLITE_CANTOPEN    14   /* Unable to open the database file */
 #define SQLITE_PROTOCOL    15   /* Database lock protocol error */
-#define SQLITE_EMPTY       16   /* Internal use only */
+#define SQLITE_EMPTY       16   /* Not used */
 #define SQLITE_SCHEMA      17   /* The database schema changed */
 #define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
 #define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
@@ -498,9 +494,6 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
 #define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
 #define SQLITE_IOERR_AUTH              (SQLITE_IOERR | (28<<8))
-#define SQLITE_IOERR_BEGIN_ATOMIC      (SQLITE_IOERR | (29<<8))
-#define SQLITE_IOERR_COMMIT_ATOMIC     (SQLITE_IOERR | (30<<8))
-#define SQLITE_IOERR_ROLLBACK_ATOMIC   (SQLITE_IOERR | (31<<8))
 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
 #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
 #define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
@@ -587,11 +580,6 @@ SQLITE_API int sqlite3_exec(
 ** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on
 ** read-only media and cannot be changed even by processes with
 ** elevated privileges.
-**
-** The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying
-** filesystem supports doing multiple write operations atomically when those
-** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and
-** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE].
 */
 #define SQLITE_IOCAP_ATOMIC                 0x00000001
 #define SQLITE_IOCAP_ATOMIC512              0x00000002
@@ -607,7 +595,6 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
 #define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
 #define SQLITE_IOCAP_IMMUTABLE              0x00002000
-#define SQLITE_IOCAP_BATCH_ATOMIC           0x00004000

 /*
 ** CAPI3REF: File Locking Levels
@@ -742,7 +729,6 @@ struct sqlite3_file {
 ** <li> [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN]
 ** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
 ** <li> [SQLITE_IOCAP_IMMUTABLE]
-** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
 ** </ul>
 **
 ** The SQLITE_IOCAP_ATOMIC property means that all writes of
@@ -1026,40 +1012,6 @@ struct sqlite3_io_methods {
 ** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by
 ** the RBU extension only.  All other VFS should return SQLITE_NOTFOUND for
 ** this opcode.  
-**
-** <li>[[SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]]
-** If the [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] opcode returns SQLITE_OK, then
-** the file descriptor is placed in "batch write mode", which
-** means all subsequent write operations will be deferred and done
-** atomically at the next [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE].  Systems
-** that do not support batch atomic writes will return SQLITE_NOTFOUND.
-** ^Following a successful SQLITE_FCNTL_BEGIN_ATOMIC_WRITE and prior to
-** the closing [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] or
-** [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE], SQLite will make
-** no VFS interface calls on the same [sqlite3_file] file descriptor
-** except for calls to the xWrite method and the xFileControl method
-** with [SQLITE_FCNTL_SIZE_HINT].
-**
-** <li>[[SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]]
-** The [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] opcode causes all write
-** operations since the previous successful call to 
-** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be performed atomically.
-** This file control returns [SQLITE_OK] if and only if the writes were
-** all performed successfully and have been committed to persistent storage.
-** ^Regardless of whether or not it is successful, this file control takes
-** the file descriptor out of batch write mode so that all subsequent
-** write operations are independent.
-** ^SQLite will never invoke SQLITE_FCNTL_COMMIT_ATOMIC_WRITE without
-** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE].
-**
-** <li>[[SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE]]
-** The [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE] opcode causes all write
-** operations since the previous successful call to 
-** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be rolled back.
-** ^This file control takes the file descriptor out of batch write mode
-** so that all subsequent write operations are independent.
-** ^SQLite will never invoke SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE without
-** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE].
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
@@ -1091,9 +1043,6 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_JOURNAL_POINTER        28
 #define SQLITE_FCNTL_WIN32_GET_HANDLE       29
 #define SQLITE_FCNTL_PDB                    30
-#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE     31
-#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE    32
-#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE  33

 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -1664,16 +1613,6 @@ struct sqlite3_mem_methods {
 ** routines with a wrapper that simulations memory allocation failure or
 ** tracks memory usage, for example. </dd>
 **
-** [[SQLITE_CONFIG_SMALL_MALLOC]] <dt>SQLITE_CONFIG_SMALL_MALLOC</dt>
-** <dd> ^The SQLITE_CONFIG_SMALL_MALLOC option takes single argument of
-** type int, interpreted as a boolean, which if true provides a hint to
-** SQLite that it should avoid large memory allocations if possible.
-** SQLite will run faster if it is free to make large memory allocations,
-** but some application might prefer to run slower in exchange for
-** guarantees about memory fragmentation that are possible if large
-** allocations are avoided.  This hint is normally off.
-** </dd>
-**
 ** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
 ** <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int,
 ** interpreted as a boolean, which enables or disables the collection of
@@ -1691,7 +1630,25 @@ struct sqlite3_mem_methods {
 ** </dd>
 **
 ** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
-** <dd> The SQLITE_CONFIG_SCRATCH option is no longer used.
+** <dd> ^The SQLITE_CONFIG_SCRATCH option specifies a static memory buffer
+** that SQLite can use for scratch memory.  ^(There are three arguments
+** to SQLITE_CONFIG_SCRATCH:  A pointer an 8-byte
+** aligned memory buffer from which the scratch allocations will be
+** drawn, the size of each scratch allocation (sz),
+** and the maximum number of scratch allocations (N).)^
+** The first argument must be a pointer to an 8-byte aligned buffer
+** of at least sz*N bytes of memory.
+** ^SQLite will not use more than one scratch buffers per thread.
+** ^SQLite will never request a scratch buffer that is more than 6
+** times the database page size.
+** ^If SQLite needs needs additional
+** scratch memory beyond what is provided by this configuration option, then 
+** [sqlite3_malloc()] will be used to obtain the memory needed.<p>
+** ^When the application provides any amount of scratch memory using
+** SQLITE_CONFIG_SCRATCH, SQLite avoids unnecessary large
+** [sqlite3_malloc|heap allocations].
+** This can help [Robson proof|prevent memory allocation failures] due to heap
+** fragmentation in low-memory embedded systems.
 ** </dd>
 **
 ** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
@@ -1727,7 +1684,8 @@ struct sqlite3_mem_methods {
 ** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
 ** <dd> ^The SQLITE_CONFIG_HEAP option specifies a static memory buffer 
 ** that SQLite will use for all of its dynamic memory allocation needs
-** beyond those provided for by [SQLITE_CONFIG_PAGECACHE].
+** beyond those provided for by [SQLITE_CONFIG_SCRATCH] and
+** [SQLITE_CONFIG_PAGECACHE].
 ** ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled
 ** with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns
 ** [SQLITE_ERROR] if invoked otherwise.
@@ -1920,7 +1878,7 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_SERIALIZED    3  /* nil */
 #define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */
 #define SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */
-#define SQLITE_CONFIG_SCRATCH       6  /* No longer used */
+#define SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */
 #define SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */
 #define SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */
 #define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */
@@ -1941,7 +1899,6 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_PCACHE_HDRSZ        24  /* int *psz */
 #define SQLITE_CONFIG_PMASZ               25  /* unsigned int szPma */
 #define SQLITE_CONFIG_STMTJRNL_SPILL      26  /* int nByte */
-#define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */

 /*
 ** CAPI3REF: Database Connection Configuration Options
@@ -3142,10 +3099,10 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** ^If [URI filename] interpretation is enabled, and the filename argument
 ** begins with "file:", then the filename is interpreted as a URI. ^URI
 ** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
-** set in the third argument to sqlite3_open_v2(), or if it has
+** set in the fourth argument to sqlite3_open_v2(), or if it has
 ** been enabled globally using the [SQLITE_CONFIG_URI] option with the
 ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
-** URI filename interpretation is turned off
+** As of SQLite version 3.7.7, URI filename interpretation is turned off
 ** by default, but future releases of SQLite might enable URI filename
 ** interpretation by default.  See "[URI filenames]" for additional
 ** information.
@@ -3819,9 +3776,8 @@ SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
 ** implementation of [application-defined SQL functions] are protected.
 ** ^The sqlite3_value object returned by
 ** [sqlite3_column_value()] is unprotected.
-** Unprotected sqlite3_value objects may only be used as arguments
-** to [sqlite3_result_value()], [sqlite3_bind_value()], and
-** [sqlite3_value_dup()].
+** Unprotected sqlite3_value objects may only be used with
+** [sqlite3_result_value()] and [sqlite3_bind_value()].
 ** The [sqlite3_value_blob | sqlite3_value_type()] family of
 ** interfaces require protected sqlite3_value objects.
 */
@@ -4243,7 +4199,7 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
 ** other than [SQLITE_ROW] before any subsequent invocation of
 ** sqlite3_step().  Failure to reset the prepared statement using 
 ** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
-** sqlite3_step().  But after [version 3.6.23.1] ([dateof:3.6.23.1],
+** sqlite3_step().  But after [version 3.6.23.1] ([dateof:3.6.23.1]),
 ** sqlite3_step() began
 ** calling [sqlite3_reset()] automatically in this circumstance rather
 ** than returning [SQLITE_MISUSE].  This is not considered a compatibility
@@ -6247,20 +6203,15 @@ struct sqlite3_index_info {
 ** an operator that is part of a constraint term in the wHERE clause of
 ** a query that uses a [virtual table].
 */
-#define SQLITE_INDEX_CONSTRAINT_EQ         2
-#define SQLITE_INDEX_CONSTRAINT_GT         4
-#define SQLITE_INDEX_CONSTRAINT_LE         8
-#define SQLITE_INDEX_CONSTRAINT_LT        16
-#define SQLITE_INDEX_CONSTRAINT_GE        32
-#define SQLITE_INDEX_CONSTRAINT_MATCH     64
-#define SQLITE_INDEX_CONSTRAINT_LIKE      65
-#define SQLITE_INDEX_CONSTRAINT_GLOB      66
-#define SQLITE_INDEX_CONSTRAINT_REGEXP    67
-#define SQLITE_INDEX_CONSTRAINT_NE        68
-#define SQLITE_INDEX_CONSTRAINT_ISNOT     69
-#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70
-#define SQLITE_INDEX_CONSTRAINT_ISNULL    71
-#define SQLITE_INDEX_CONSTRAINT_IS        72
+#define SQLITE_INDEX_CONSTRAINT_EQ      2
+#define SQLITE_INDEX_CONSTRAINT_GT      4
+#define SQLITE_INDEX_CONSTRAINT_LE      8
+#define SQLITE_INDEX_CONSTRAINT_LT     16
+#define SQLITE_INDEX_CONSTRAINT_GE     32
+#define SQLITE_INDEX_CONSTRAINT_MATCH  64
+#define SQLITE_INDEX_CONSTRAINT_LIKE   65
+#define SQLITE_INDEX_CONSTRAINT_GLOB   66
+#define SQLITE_INDEX_CONSTRAINT_REGEXP 67

 /*
 ** CAPI3REF: Register A Virtual Table Implementation
@@ -7012,7 +6963,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_RESERVE                 14
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
 #define SQLITE_TESTCTRL_ISKEYWORD               16
-#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
+#define SQLITE_TESTCTRL_SCRATCHMALLOC           17
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
 #define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
 #define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
@@ -7071,7 +7022,8 @@ SQLITE_API int sqlite3_status64(
 ** <dd>This parameter is the current amount of memory checked out
 ** using [sqlite3_malloc()], either directly or indirectly.  The
 ** figure includes calls made to [sqlite3_malloc()] by the application
-** and internal memory usage by the SQLite library.  Auxiliary page-cache
+** and internal memory usage by the SQLite library.  Scratch memory
+** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
 ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
 ** this parameter.  The amount returned is the sum of the allocation
 ** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
@@ -7109,14 +7061,29 @@ SQLITE_API int sqlite3_status64(
 ** *pHighwater parameter to [sqlite3_status()] is of interest.  
 ** The value written into the *pCurrent parameter is undefined.</dd>)^
 **
-** [[SQLITE_STATUS_SCRATCH_USED]] <dt>SQLITE_STATUS_SCRATCH_USED</dt>
-** <dd>No longer used.</dd>
+** [[SQLITE_STATUS_SCRATCH_USED]] ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
+** <dd>This parameter returns the number of allocations used out of the
+** [scratch memory allocator] configured using
+** [SQLITE_CONFIG_SCRATCH].  The value returned is in allocations, not
+** in bytes.  Since a single thread may only have one scratch allocation
+** outstanding at time, this parameter also reports the number of threads
+** using scratch memory at the same time.</dd>)^
 **
 ** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
-** <dd>No longer used.</dd>
+** <dd>This parameter returns the number of bytes of scratch memory
+** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
+** buffer and where forced to overflow to [sqlite3_malloc()].  The values
+** returned include overflows because the requested allocation was too
+** larger (that is, because the requested allocation was larger than the
+** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
+** slots were available.
+** </dd>)^
 **
-** [[SQLITE_STATUS_SCRATCH_SIZE]] <dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
-** <dd>No longer used.</dd>
+** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
+** <dd>This parameter records the largest memory allocation request
+** handed to [scratch memory allocator].  Only the value returned in the
+** *pHighwater parameter to [sqlite3_status()] is of interest.  
+** The value written into the *pCurrent parameter is undefined.</dd>)^
 **
 ** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
 ** <dd>The *pHighwater parameter records the deepest parser stack. 
@@ -7129,12 +7096,12 @@ SQLITE_API int sqlite3_status64(
 #define SQLITE_STATUS_MEMORY_USED          0
 #define SQLITE_STATUS_PAGECACHE_USED       1
 #define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
-#define SQLITE_STATUS_SCRATCH_USED         3  /* NOT USED */
-#define SQLITE_STATUS_SCRATCH_OVERFLOW     4  /* NOT USED */
+#define SQLITE_STATUS_SCRATCH_USED         3
+#define SQLITE_STATUS_SCRATCH_OVERFLOW     4
 #define SQLITE_STATUS_MALLOC_SIZE          5
 #define SQLITE_STATUS_PARSER_STACK         6
 #define SQLITE_STATUS_PAGECACHE_SIZE       7
-#define SQLITE_STATUS_SCRATCH_SIZE         8  /* NOT USED */
+#define SQLITE_STATUS_SCRATCH_SIZE         8
 #define SQLITE_STATUS_MALLOC_COUNT         9

 /*
@@ -9231,8 +9198,8 @@ SQLITE_API int sqlite3session_diff(
 */
 SQLITE_API int sqlite3session_patchset(
  sqlite3_session *pSession,      /* Session object */
-  int *pnPatchset,                /* OUT: Size of buffer at *ppPatchset */
-  void **ppPatchset               /* OUT: Buffer containing patchset */
+  int *pnPatchset,                /* OUT: Size of buffer at *ppChangeset */
+  void **ppPatchset               /* OUT: Buffer containing changeset */
 );

 /*
@@ -9999,12 +9966,12 @@ SQLITE_API int sqlite3changeset_apply(
 **
 ** <table border=1 style="margin-left:8ex;margin-right:8ex">
 **   <tr><th>Streaming function<th>Non-streaming equivalent</th>
-**   <tr><td>sqlite3changeset_apply_strm<td>[sqlite3changeset_apply] 
-**   <tr><td>sqlite3changeset_concat_strm<td>[sqlite3changeset_concat] 
-**   <tr><td>sqlite3changeset_invert_strm<td>[sqlite3changeset_invert] 
-**   <tr><td>sqlite3changeset_start_strm<td>[sqlite3changeset_start] 
-**   <tr><td>sqlite3session_changeset_strm<td>[sqlite3session_changeset] 
-**   <tr><td>sqlite3session_patchset_strm<td>[sqlite3session_patchset] 
+**   <tr><td>sqlite3changeset_apply_str<td>[sqlite3changeset_apply] 
+**   <tr><td>sqlite3changeset_concat_str<td>[sqlite3changeset_concat] 
+**   <tr><td>sqlite3changeset_invert_str<td>[sqlite3changeset_invert] 
+**   <tr><td>sqlite3changeset_start_str<td>[sqlite3changeset_start] 
+**   <tr><td>sqlite3session_changeset_str<td>[sqlite3session_changeset] 
+**   <tr><td>sqlite3session_patchset_str<td>[sqlite3session_patchset] 
 ** </table>
 **
 ** Non-streaming functions that accept changesets (or patchsets) as input
--- a/src/cmd/CMakeLists.txt
+++ b/src/cmd/CMakeLists.txt
@@ -20,9 +20,8 @@ include_directories(${CMAKE_SOURCE_DIR}/src/csync
 include_directories(${CMAKE_SOURCE_DIR}/src/3rdparty/qtokenizer)

 if(UNIX AND NOT APPLE)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pie -fPIE")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pie -fPIE")
 endif()

 if(NOT BUILD_LIBRARIES_ONLY)
--- a/src/cmd/cmd.cpp
+++ b/src/cmd/cmd.cpp
@@ -39,7 +39,6 @@

 #include "theme.h"
 #include "netrcparser.h"
-#include "libsync/logger.h"

 #include "config.h"

@@ -190,7 +189,7 @@ void help()
    std::cout << "  --downlimit [n]        Limit the download speed of files to n KB/s" << std::endl;
    std::cout << "  -h                     Sync hidden files,do not ignore them" << std::endl;
    std::cout << "  --version, -v          Display version and exit" << std::endl;
-    std::cout << "  --logdebug             More verbose logging" << std::endl;
+    std::cout << "  --debug                More verbose logging" << std::endl;
    std::cout << "" << std::endl;
    exit(0);
 }
@@ -268,9 +267,6 @@ void parseOptions(const QStringList &app_args, CmdOptions *options)
            options->uplimit = it.next().toInt() * 1000;
        } else if (option == "--downlimit" && !it.peekNext().startsWith("-")) {
            options->downlimit = it.next().toInt() * 1000;
-        } else if (option == "--logdebug") {
-            Logger::instance()->setLogFile("-");
-            Logger::instance()->setLogDebug(true);
        } else {
            help();
        }
@@ -334,8 +330,6 @@ int main(int argc, char **argv)
    csync_set_log_level(options.silent ? 1 : 11);
    if (options.silent) {
        qInstallMsgHandler(nullMessageHandler);
-    } else {
-        qSetMessagePattern("%{time MM-dd hh:mm:ss:zzz} [ %{type} %{category} ]%{if-debug}\t[ %{function} ]%{endif}:\t%{message}");
    }

    AccountPtr account = Account::create();
--- a/src/common/checksums.cpp
+++ b/src/common/checksums.cpp
@@ -120,7 +120,7 @@ QByteArray parseChecksumHeaderType(const QByteArray &header)

 bool uploadChecksumEnabled()
 {
-    static bool enabled = qEnvironmentVariableIsEmpty("OWNCLOUD_DISABLE_CHECKSUM_UPLOAD");
+    static bool enabled = qgetenv("OWNCLOUD_DISABLE_CHECKSUM_UPLOAD").isEmpty();
    return enabled;
 }

@@ -133,12 +133,6 @@ QByteArray contentChecksumType()
    return type;
 }

-static bool checksumComputationEnabled()
-{
-    static bool enabled = qgetenv("OWNCLOUD_DISABLE_CHECKSUM_COMPUTATIONS").isEmpty();
-    return enabled;
-}
-
 ComputeChecksum::ComputeChecksum(QObject *parent)
    : QObject(parent)
 {
@@ -156,8 +150,6 @@ QByteArray ComputeChecksum::checksumType() const

 void ComputeChecksum::start(const QString &filePath)
 {
-    qCInfo(lcChecksums) << "Computing" << checksumType() << "checksum of" << filePath << "in a thread";
-
    // Calculate the checksum in a different thread first.
    connect(&_watcher, &QFutureWatcherBase::finished,
        this, &ComputeChecksum::slotCalculationDone,
@@ -167,11 +159,6 @@ void ComputeChecksum::start(const QString &filePath)

 QByteArray ComputeChecksum::computeNow(const QString &filePath, const QByteArray &checksumType)
 {
-    if (!checksumComputationEnabled()) {
-        qCWarning(lcChecksums) << "Checksum computation disabled by environment variable";
-        return QByteArray();
-    }
-
    if (checksumType == checkSumMD5C) {
        return FileSystem::calcMd5(filePath);
    } else if (checksumType == checkSumSHA1C) {
@@ -250,7 +237,6 @@ QByteArray CSyncChecksumHook::hook(const QByteArray &path, const QByteArray &oth
    if (type.isEmpty())
        return NULL;

-    qCInfo(lcChecksums) << "Computing" << type << "checksum of" << path << "in the csync hook";
    QByteArray checksum = ComputeChecksum::computeNow(QString::fromUtf8(path), type);
    if (checksum.isNull()) {
        qCWarning(lcChecksums) << "Failed to compute checksum" << type << "for" << path;
--- a/src/common/filesystembase.cpp
+++ b/src/common/filesystembase.cpp
@@ -358,19 +358,26 @@ QString FileSystem::fileSystemForPath(const QString &path)

 #define BUFSIZE qint64(500 * 1024) // 500 KiB

-static QByteArray readToCrypto( const QString& filename, QCryptographicHash::Algorithm algo )
- {
-     QFile file(filename);
-     QByteArray arr;
-     QCryptographicHash crypto( algo );
+static QByteArray readToCrypto(const QString &filename, QCryptographicHash::Algorithm algo)
+{
+    QFile file(filename);
+    const qint64 bufSize = qMin(BUFSIZE, file.size() + 1);
+    QByteArray buf(bufSize, Qt::Uninitialized);
+    QByteArray arr;
+    QCryptographicHash crypto(algo);

-     if (file.open(QIODevice::ReadOnly)) {
-         if (crypto.addData(&file)) {
-             arr = crypto.result().toHex();
-         }
-     }
-     return arr;
- }
+    if (file.open(QIODevice::ReadOnly)) {
+        qint64 size;
+        while (!file.atEnd()) {
+            size = file.read(buf.data(), bufSize);
+            if (size > 0) {
+                crypto.addData(buf.data(), size);
+            }
+        }
+        arr = crypto.result().toHex();
+    }
+    return arr;
+}

 QByteArray FileSystem::calcMd5(const QString &filename)
 {
--- a/src/common/ownsql.cpp
+++ b/src/common/ownsql.cpp
@@ -85,32 +85,24 @@ bool SqlDatabase::openHelper(const QString &filename, int sqliteFlags)
    return true;
 }

-SqlDatabase::CheckDbResult SqlDatabase::checkDb()
+bool SqlDatabase::checkDb()
 {
    // quick_check can fail with a disk IO error when diskspace is low
    SqlQuery quick_check(*this);
-
-    if (quick_check.prepare("PRAGMA quick_check;", /*allow_failure=*/true) != SQLITE_OK) {
-        qCWarning(lcSql) << "Error preparing quick_check on database";
-        _errId = quick_check.errorId();
-        _error = quick_check.error();
-        return CheckDbResult::CantPrepare;
-    }
+    quick_check.prepare("PRAGMA quick_check;", /*allow_failure=*/true);
    if (!quick_check.exec()) {
        qCWarning(lcSql) << "Error running quick_check on database";
-        _errId = quick_check.errorId();
-        _error = quick_check.error();
-        return CheckDbResult::CantExec;
+        return false;
    }

    quick_check.next();
    QString result = quick_check.stringValue(0);
    if (result != "ok") {
        qCWarning(lcSql) << "quick_check returned failure:" << result;
-        return CheckDbResult::NotOk;
+        return false;
    }

-    return CheckDbResult::Ok;
+    return true;
 }

 bool SqlDatabase::openOrCreateReadWrite(const QString &filename)
@@ -123,25 +115,13 @@ bool SqlDatabase::openOrCreateReadWrite(const QString &filename)
        return false;
    }

-    auto checkResult = checkDb();
-    if (checkResult != CheckDbResult::Ok) {
-        if (checkResult == CheckDbResult::CantPrepare) {
-            // When disk space is low, preparing may fail even though the db is fine.
-            // Typically CANTOPEN or IOERR.
-            qint64 freeSpace = Utility::freeDiskSpace(QFileInfo(filename).dir().absolutePath());
-            if (freeSpace != -1 && freeSpace < 1000000) {
-                qCWarning(lcSql) << "Can't prepare consistency check and disk space is low:" << freeSpace;
-                close();
-                return false;
-            }
-
-            // Even when there's enough disk space, it might very well be that the
-            // file is on a read-only filesystem and can't be opened because of that.
-            if (_errId == SQLITE_CANTOPEN) {
-                qCWarning(lcSql) << "Can't open db to prepare consistency check, aborting";
-                close();
-                return false;
-            }
+    if (!checkDb()) {
+        // When disk space is low, checking the db may fail even though it's fine.
+        qint64 freeSpace = Utility::freeDiskSpace(QFileInfo(filename).dir().absolutePath());
+        if (freeSpace != -1 && freeSpace < 1000000) {
+            qCWarning(lcSql) << "Consistency check failed, disk space is low, aborting" << freeSpace;
+            close();
+            return false;
        }

        qCCritical(lcSql) << "Consistency check failed, removing broken db" << filename;
@@ -164,7 +144,7 @@ bool SqlDatabase::openReadOnly(const QString &filename)
        return false;
    }

-    if (checkDb() != CheckDbResult::Ok) {
+    if (!checkDb()) {
        qCWarning(lcSql) << "Consistency check failed in readonly mode, giving up" << filename;
        close();
        return false;
@@ -184,8 +164,8 @@ void SqlDatabase::close()
 {
    if (_db) {
        SQLITE_DO(sqlite3_close(_db));
-        if (_errId != SQLITE_OK)
-            qCWarning(lcSql) << "Closing database failed" << _error;
+        // Fatal because reopening an unclosed db might be problematic.
+        ENFORCE(_errId == SQLITE_OK, "Error when closing DB");
        _db = 0;
    }
 }
--- a/src/common/ownsql.h
+++ b/src/common/ownsql.h
@@ -48,15 +48,8 @@ public:
    sqlite3 *sqliteDb();

 private:
-    enum class CheckDbResult {
-        Ok,
-        CantPrepare,
-        CantExec,
-        NotOk,
-    };
-
    bool openHelper(const QString &filename, int sqliteFlags);
-    CheckDbResult checkDb();
+    bool checkDb();

    sqlite3 *_db;
    QString _error; // last error string
--- a/src/common/syncjournaldb.cpp
+++ b/src/common/syncjournaldb.cpp
@@ -1094,10 +1094,15 @@ bool SyncJournalDb::getFileRecordByInode(quint64 inode, SyncJournalFileRecord *r
    return true;
 }

-bool SyncJournalDb::getFileRecordsByFileId(const QByteArray &fileId, const std::function<void(const SyncJournalFileRecord &)> &rowCallback)
+bool SyncJournalDb::getFileRecordByFileId(const QByteArray &fileId, SyncJournalFileRecord *rec)
 {
    QMutexLocker locker(&_mutex);

+    // Reset the output var in case the caller is reusing it.
+    Q_ASSERT(rec);
+    rec->_path.clear();
+    Q_ASSERT(!rec->isValid());
+
    if (fileId.isEmpty() || _metadataTableIsEmpty)
        return true; // no error, yet nothing found (rec->isValid() == false)

@@ -1111,10 +1116,8 @@ bool SyncJournalDb::getFileRecordsByFileId(const QByteArray &fileId, const std::
        return false;
    }

-    while (_getFileRecordQueryByFileId->next()) {
-        SyncJournalFileRecord rec;
-        fillFileRecordFromGetQuery(rec, *_getFileRecordQueryByFileId);
-        rowCallback(rec);
+    if (_getFileRecordQueryByFileId->next()) {
+        fillFileRecordFromGetQuery(*rec, *_getFileRecordQueryByFileId);
    }

    return true;
--- a/src/common/syncjournaldb.h
+++ b/src/common/syncjournaldb.h
@@ -58,7 +58,7 @@ public:
    bool getFileRecord(const QString &filename, SyncJournalFileRecord *rec) { return getFileRecord(filename.toUtf8(), rec); }
    bool getFileRecord(const QByteArray &filename, SyncJournalFileRecord *rec);
    bool getFileRecordByInode(quint64 inode, SyncJournalFileRecord *rec);
-    bool getFileRecordsByFileId(const QByteArray &fileId, const std::function<void(const SyncJournalFileRecord &)> &rowCallback);
+    bool getFileRecordByFileId(const QByteArray &fileId, SyncJournalFileRecord *rec);
    bool getFilesBelowPath(const QByteArray &path, const std::function<void(const SyncJournalFileRecord&)> &rowCallback);
    bool setFileRecord(const SyncJournalFileRecord &record);

--- a/src/common/utility.cpp
+++ b/src/common/utility.cpp
@@ -579,7 +579,7 @@ bool Utility::isConflictFile(const char *name)

 bool Utility::shouldUploadConflictFiles()
 {
-    static bool uploadConflictFiles = qEnvironmentVariableIntValue("OWNCLOUD_UPLOAD_CONFLICT_FILES") != 0;
+    static bool uploadConflictFiles = qgetenv("OWNCLOUD_UPLOAD_CONFLICT_FILES").toInt() != 0;
    return uploadConflictFiles;
 }

--- a/src/csync/csync_reconcile.cpp
+++ b/src/csync/csync_reconcile.cpp
@@ -63,6 +63,18 @@ static csync_file_stat_t *_csync_check_ignored(csync_s::FileMap *tree, const Byt
    }
 }

+/* Returns true if we're reasonably certain that hash equality
+ * for the header means content equality.
+ *
+ * Cryptographic safety is not required - this is mainly
+ * intended to rule out checksums like Adler32 that are not intended for
+ * hashing and have high likelihood of collision with particular inputs.
+ */
+static bool _csync_is_collision_safe_hash(const char *checksum_header)
+{
+    return strncmp(checksum_header, "SHA1:", 5) == 0
+        || strncmp(checksum_header, "MD5:", 4) == 0;
+}

 /**
 * The main function in the reconcile pass.
@@ -92,17 +104,14 @@ static csync_file_stat_t *_csync_check_ignored(csync_s::FileMap *tree, const Byt
 * source and the destination, have been changed, the newer file wins.
 */
 static int _csync_merge_algorithm_visitor(csync_file_stat_t *cur, CSYNC * ctx) {
-    csync_s::FileMap *our_tree = nullptr;
    csync_s::FileMap *other_tree = nullptr;

    /* we need the opposite tree! */
    switch (ctx->current) {
    case LOCAL_REPLICA:
-        our_tree = &ctx->local.files;
        other_tree = &ctx->remote.files;
        break;
    case REMOTE_REPLICA:
-        our_tree = &ctx->remote.files;
        other_tree = &ctx->local.files;
        break;
    default:
@@ -143,51 +152,40 @@ static int _csync_merge_algorithm_visitor(csync_file_stat_t *cur, CSYNC * ctx) {
            cur->instruction = CSYNC_INSTRUCTION_REMOVE;
            break;
        case CSYNC_INSTRUCTION_EVAL_RENAME: {
-            // By default, the EVAL_RENAME decays into a NEW
-            cur->instruction = CSYNC_INSTRUCTION_NEW;
-
-            bool processedRename = false;
-            auto renameCandidateProcessing = [&](const OCC::SyncJournalFileRecord &base) {
-                if (processedRename)
-                    return;
-                if (!base.isValid())
-                    return;
+            OCC::SyncJournalFileRecord base;
+            if(ctx->current == LOCAL_REPLICA ) {
+                /* use the old name to find the "other" node */
+                ctx->statedb->getFileRecordByInode(cur->inode, &base);
+                qCDebug(lcReconcile, "Finding opposite temp through inode %" PRIu64 ": %s",
+                          cur->inode, base.isValid() ? "true":"false");
+            } else {
+                ASSERT( ctx->current == REMOTE_REPLICA );
+                ctx->statedb->getFileRecordByFileId(cur->file_id, &base);
+                qCDebug(lcReconcile, "Finding opposite temp through file ID %s: %s",
+                          cur->file_id.constData(), base.isValid() ? "true":"false");
+            }

+            if( base.isValid() ) {
                /* First, check that the file is NOT in our tree (another file with the same name was added) */
-                if (our_tree->findFile(base._path)) {
-                    qCDebug(lcReconcile, "Origin found in our tree : %s", base._path.constData());
+                csync_s::FileMap *our_tree = ctx->current == REMOTE_REPLICA ? &ctx->remote.files : &ctx->local.files;
+	                if (our_tree->findFile(base._path)) {
+                        qCDebug(lcReconcile, "Origin found in our tree : %s", base._path.constData());
                } else {
-                    /* Find the potential rename source file in the other tree.
+                    /* Find the temporar file in the other tree.
                    * If the renamed file could not be found in the opposite tree, that is because it
                    * is not longer existing there, maybe because it was renamed or deleted.
                    * The journal is cleaned up later after propagation.
                    */
                    other = other_tree->findFile(base._path);
-                    qCDebug(lcReconcile, "Rename origin in other tree (%s) %s",
-                        base._path.constData(), other ? "found" : "not found");
+                    qCDebug(lcReconcile, "Temporary opposite (%s) %s",
+                            base._path.constData() , other ? "found": "not found" );
                }

                if(!other) {
-                    // Stick with the NEW
-                    return;
-                } else if (other->instruction == CSYNC_INSTRUCTION_RENAME) {
-                    // Some other EVAL_RENAME already claimed other.
-                    // We do nothing: maybe a different candidate for
-                    // other is found as well?
-                    qCDebug(lcReconcile, "Other has already been renamed to %s",
-                        other->rename_path.constData());
-                } else if (cur->type == CSYNC_FTW_TYPE_DIR
-                    // The local replica is reconciled first, so the remote tree would
-                    // have either NONE or UPDATE_METADATA if the remote file is safe to
-                    // move.
-                    // In the remote replica, REMOVE is also valid (local has already
-                    // been reconciled). NONE can still happen if the whole parent dir
-                    // was set to REMOVE by the local reconcile.
-                    || other->instruction == CSYNC_INSTRUCTION_NONE
-                    || other->instruction == CSYNC_INSTRUCTION_UPDATE_METADATA
-                    || other->instruction == CSYNC_INSTRUCTION_REMOVE) {
-                    qCDebug(lcReconcile, "Switching %s to RENAME to %s",
-                        other->path.constData(), cur->path.constData());
+                    cur->instruction = CSYNC_INSTRUCTION_NEW;
+                } else if (other->instruction == CSYNC_INSTRUCTION_NONE
+                           || other->instruction == CSYNC_INSTRUCTION_UPDATE_METADATA
+                           || cur->type == CSYNC_FTW_TYPE_DIR) {
                    other->instruction = CSYNC_INSTRUCTION_RENAME;
                    other->rename_path = cur->path;
                    if( !cur->file_id.isEmpty() ) {
@@ -195,44 +193,24 @@ static int _csync_merge_algorithm_visitor(csync_file_stat_t *cur, CSYNC * ctx) {
                    }
                    other->inode = cur->inode;
                    cur->instruction = CSYNC_INSTRUCTION_NONE;
-                    // We have consumed 'other': exit this loop to not consume another one.
-                    processedRename = true;
-                } else if (our_tree->findFile(csync_rename_adjust_path(ctx, other->path)) == cur) {
-                    // If we're here, that means that the other side's reconcile will be able
-                    // to work against cur: The filename itself didn't change, only a parent
-                    // directory was renamed! In that case it's safe to ignore the rename
-                    // since the parent directory rename will already deal with it.
+                } else if (other->instruction == CSYNC_INSTRUCTION_REMOVE) {
+                    other->instruction = CSYNC_INSTRUCTION_RENAME;
+                    other->rename_path = cur->path;

-                    // Local: The remote reconcile will be able to deal with this.
-                    // Remote: The local replica has already dealt with this.
-                    //         See the EVAL_RENAME case when other was found directly.
-                    qCDebug(lcReconcile, "File in a renamed directory, other side's instruction: %d",
-                        other->instruction);
+                    if( !cur->file_id.isEmpty() ) {
+                        other->file_id = cur->file_id;
+                    }
+                    other->inode = cur->inode;
                    cur->instruction = CSYNC_INSTRUCTION_NONE;
+                } else if (other->instruction == CSYNC_INSTRUCTION_NEW) {
+                    qCDebug(lcReconcile, "OOOO=> NEW detected in other tree!");
+                    cur->instruction = CSYNC_INSTRUCTION_CONFLICT;
                } else {
-                    // This can, for instance, happen when there was a local change in other
-                    // and the instruction in the local tree is NEW while cur has EVAL_RENAME
-                    // due to a remote move of the same file. In these scenarios we just
-                    // want the instruction to stay NEW.
-                    qCDebug(lcReconcile, "Other already has instruction %d",
-                        other->instruction);
+                    assert(other->type != CSYNC_FTW_TYPE_DIR);
+                    cur->instruction = CSYNC_INSTRUCTION_NONE;
+                    other->instruction = CSYNC_INSTRUCTION_SYNC;
                }
-            };
-
-            if (ctx->current == LOCAL_REPLICA) {
-                /* use the old name to find the "other" node */
-                OCC::SyncJournalFileRecord base;
-                qCDebug(lcReconcile, "Finding rename origin through inode %" PRIu64 "",
-                    cur->inode);
-                ctx->statedb->getFileRecordByInode(cur->inode, &base);
-                renameCandidateProcessing(base);
-            } else {
-                ASSERT(ctx->current == REMOTE_REPLICA);
-                qCDebug(lcReconcile, "Finding rename origin through file ID %s",
-                    cur->file_id.constData());
-                ctx->statedb->getFileRecordsByFileId(cur->file_id, renameCandidateProcessing);
            }
-
            break;
        }
        default:
@@ -285,14 +263,14 @@ static int _csync_merge_algorithm_visitor(csync_file_stat_t *cur, CSYNC * ctx) {
                    //
                    // In older client versions we always treated these cases as a
                    // non-conflict. This behavior is preserved in case the server
-                    // doesn't provide a content checksum.
+                    // doesn't provide a suitable content hash.
                    //
                    // When it does have one, however, we do create a job, but the job
-                    // will compare hashes and avoid the download if possible.
-                    QByteArray remoteChecksumHeader =
+                    // will compare hashes and avoid the download if they are equal.
+                    const char *remoteChecksumHeader =
                        (ctx->current == REMOTE_REPLICA ? cur->checksumHeader : other->checksumHeader);
-                    if (!remoteChecksumHeader.isEmpty()) {
-                        is_conflict = true;
+                    if (remoteChecksumHeader) {
+                        is_conflict |= _csync_is_collision_safe_hash(remoteChecksumHeader);
                    }

                    // SO: If there is no checksum, we can have !is_conflict here
@@ -332,19 +310,10 @@ static int _csync_merge_algorithm_visitor(csync_file_stat_t *cur, CSYNC * ctx) {
                break;
            case CSYNC_INSTRUCTION_IGNORE:
                cur->instruction = CSYNC_INSTRUCTION_IGNORE;
-                break;
+            break;
            default:
                break;
            }
-            // Ensure we're not leaving discovery-only instructions
-            // in place. This can happen, for instance, when other's
-            // instruction is EVAL_RENAME because the parent dir was renamed.
-            // NEW is safer than EVAL because it will end up with
-            // propagation unless it's changed by something, and EVAL and
-            // NEW are treated equivalently during reconcile.
-            if (cur->instruction == CSYNC_INSTRUCTION_EVAL)
-                cur->instruction = CSYNC_INSTRUCTION_NEW;
-            break;
        default:
            break;
        }
--- a/src/csync/csync_update.cpp
+++ b/src/csync/csync_update.cpp
@@ -265,8 +265,8 @@ static int _csync_detect_update(CSYNC *ctx, std::unique_ptr<csync_file_stat_t> f
          fs->instruction = CSYNC_INSTRUCTION_NEW;

          bool isRename =
-              base.isValid() && base._type == fs->type
-                  && ((base._modtime == fs->modtime && base._fileSize == fs->size) || fs->type == CSYNC_FTW_TYPE_DIR)
+              base.isValid() && base._inode == fs->inode && base._type == fs->type
+                  && (base._modtime == fs->modtime || fs->type == CSYNC_FTW_TYPE_DIR)
 #ifdef NO_RENAME_EXTENSION
                  && _csync_sameextension(base._path, fs->path)
 #endif
@@ -297,60 +297,41 @@ static int _csync_detect_update(CSYNC *ctx, std::unique_ptr<csync_file_stat_t> f

      } else {
          /* Remote Replica Rename check */
-          fs->instruction = CSYNC_INSTRUCTION_NEW;
-
-          bool done = false;
-          auto renameCandidateProcessing = [&](const OCC::SyncJournalFileRecord &base) {
-              if (done)
-                  return;
-              if (!base.isValid())
-                  return;
-
-              // Some things prohibit rename detection entirely.
-              // Since we don't do the same checks again in reconcile, we can't
-              // just skip the candidate, but have to give up completely.
-              if (base._type != fs->type) {
-                  qCWarning(lcUpdate, "file types different, not a rename");
-                  done = true;
-                  return;
-              }
-              if (fs->type != CSYNC_FTW_TYPE_DIR && base._etag != fs->etag) {
-                  /* File with different etag, don't do a rename, but download the file again */
-                  qCWarning(lcUpdate, "file etag different, not a rename");
-                  done = true;
-                  return;
-              }
-
-              // Record directory renames
-              if (fs->type == CSYNC_FTW_TYPE_DIR) {
-                  // If the same folder was already renamed by a different entry,
-                  // skip to the next candidate
-                  if (ctx->renames.folder_renamed_to.count(base._path) > 0) {
-                      qCWarning(lcUpdate, "folder already has a rename entry, skipping");
-                      return;
-                  }
-                  csync_rename_record(ctx, base._path, fs->path);
-              }
-
-              qCDebug(lcUpdate, "remote rename detected based on fileid %s --> %s", base._path.constData(), fs->path.constData());
-              fs->instruction = CSYNC_INSTRUCTION_EVAL_RENAME;
-              done = true;
-          };
-
-          if (!ctx->statedb->getFileRecordsByFileId(fs->file_id, renameCandidateProcessing)) {
+          OCC::SyncJournalFileRecord base;
+          if(!ctx->statedb->getFileRecordByFileId(fs->file_id, &base)) {
              ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
              return -1;
          }
-
-          if (fs->instruction == CSYNC_INSTRUCTION_NEW
-              && fs->type == CSYNC_FTW_TYPE_DIR
-              && ctx->current == REMOTE_REPLICA
-              && ctx->callbacks.checkSelectiveSyncNewFolderHook) {
-              if (ctx->callbacks.checkSelectiveSyncNewFolderHook(ctx->callbacks.update_callback_userdata, fs->path, fs->remotePerm)) {
-                  return 1;
+          if (base.isValid()) {                           /* tmp existing at all */
+              if (base._type != fs->type) {
+                  qCWarning(lcUpdate, "file types different is not!");
+                  fs->instruction = CSYNC_INSTRUCTION_NEW;
+                  goto out;
              }
+              qCDebug(lcUpdate, "remote rename detected based on fileid %s --> %s", base._path.constData(), fs->path.constData());
+              fs->instruction = CSYNC_INSTRUCTION_EVAL_RENAME;
+              if (fs->type == CSYNC_FTW_TYPE_DIR) {
+                  csync_rename_record(ctx, base._path, fs->path);
+              } else {
+                  if( base._etag != fs->etag ) {
+                      /* CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "ETags are different!"); */
+                      /* File with different etag, don't do a rename, but download the file again */
+                      fs->instruction = CSYNC_INSTRUCTION_NEW;
+                  }
+              }
+              goto out;
+
+          } else {
+              /* file not found in statedb */
+              fs->instruction = CSYNC_INSTRUCTION_NEW;
+
+              if (fs->type == CSYNC_FTW_TYPE_DIR && ctx->current == REMOTE_REPLICA && ctx->callbacks.checkSelectiveSyncNewFolderHook) {
+                  if (ctx->callbacks.checkSelectiveSyncNewFolderHook(ctx->callbacks.update_callback_userdata, fs->path, fs->remotePerm)) {
+                      return 1;
+                  }
+              }
+              goto out;
          }
-          goto out;
      }
  }

@@ -635,7 +616,7 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
     * local stat function.
     */
    if( filename[0] == '.' ) {
-        if (filename != ".sys.admin#recall#") { /* recall file shall not be ignored (#4420) */
+        if (filename == ".sys.admin#recall#") { /* recall file shall not be ignored (#4420) */
            dirent->is_hidden = true;
        }
    }
--- a/src/csync/csync_util.cpp
+++ b/src/csync/csync_util.cpp
@@ -211,10 +211,3 @@ time_t oc_httpdate_parse( const char *date ) {
    result = timegm(&gmt);
    return result;
 }
-
-
-bool csync_is_collision_safe_hash(const QByteArray &checksum_header)
-{
-    return checksum_header.startsWith("SHA1:")
-        || checksum_header.startsWith("MD5:");
-}
--- a/src/csync/csync_util.h
+++ b/src/csync/csync_util.h
@@ -31,14 +31,4 @@ const char OCSYNC_EXPORT *csync_instruction_str(enum csync_instructions_e instr)
 void OCSYNC_EXPORT csync_memstat_check(void);

 bool OCSYNC_EXPORT csync_file_locked_or_open( const char *dir, const char *fname);
-
-/* Returns true if we're reasonably certain that hash equality
- * for the header means content equality.
- *
- * Cryptographic safety is not required - this is mainly
- * intended to rule out checksums like Adler32 that are not intended for
- * hashing and have high likelihood of collision with particular inputs.
- */
-bool OCSYNC_EXPORT csync_is_collision_safe_hash(const QByteArray &checksum_header);
-
 #endif /* _CSYNC_UTIL_H */
--- a/src/gui/CMakeLists.txt
+++ b/src/gui/CMakeLists.txt
@@ -129,7 +129,6 @@ set(updater_SRCS
 IF( APPLE )
    list(APPEND client_SRCS cocoainitializer_mac.mm)
    list(APPEND client_SRCS settingsdialogmac.cpp)
-    list(REMOVE_ITEM client_SRCS settingsdialog.cpp)
    list(APPEND client_SRCS socketapisocket_mac.mm)
    list(APPEND client_SRCS systray.mm)

@@ -243,9 +242,8 @@ if (NOT NO_SHIBBOLETH)
 endif()

 if(UNIX AND NOT APPLE)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pie -fPIE")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pie -fPIE")
 endif()

 if(NOT BUILD_OWNCLOUD_OSX_BUNDLE)
--- a/src/gui/accountsettings.cpp
+++ b/src/gui/accountsettings.cpp
@@ -638,11 +638,7 @@ void AccountSettings::slotAccountStateChanged()
                                 Utility::escape(safeUrl.toString()));
        QString serverWithUser = server;
        if (AbstractCredentials *cred = account->credentials()) {
-            QString user = account->davDisplayName();
-            if (user.isEmpty()) {
-                user = cred->user();
-            }
-            serverWithUser = tr("%1 as <i>%2</i>").arg(server, Utility::escape(user));
+            serverWithUser = tr("%1 as <i>%2</i>").arg(server, Utility::escape(cred->user()));
        }

        if (state == AccountState::Connected) {
--- a/src/gui/accountstate.cpp
+++ b/src/gui/accountstate.cpp
@@ -361,4 +361,23 @@ std::unique_ptr<QSettings> AccountState::settings()
    return s;
 }

+QString AccountState::shortDisplayNameForSettings(int width) const
+{
+    QString user = account()->credentials()->user();
+    QString host = account()->url().host();
+    int port = account()->url().port();
+    if (port > 0 && port != 80 && port != 443) {
+        host.append(QLatin1Char(':'));
+        host.append(QString::number(port));
+    }
+    if (width > 0) {
+        QFont f;
+        QFontMetrics fm(f);
+        host = fm.elidedText(host, Qt::ElideMiddle, width);
+        user = fm.elidedText(user, Qt::ElideRight, width);
+    }
+    return user + QLatin1String("\n") + host;
+}
+
+
 } // namespace OCC
--- a/src/gui/accountstate.h
+++ b/src/gui/accountstate.h
@@ -113,6 +113,11 @@ public:
    /** Returns a new settings object for this account, already in the right groups. */
    std::unique_ptr<QSettings> settings();

+    /** display name with two lines that is displayed in the settings
+     * If width is bigger than 0, the string will be ellided so it does not exceed that width
+     */
+    QString shortDisplayNameForSettings(int width = 0) const;
+
    /** Mark the timestamp when the last successful ETag check happened for
     *  this account.
     *  The checkConnectivity() method uses the timestamp to save a call to
--- a/src/gui/creds/httpcredentialsgui.cpp
+++ b/src/gui/creds/httpcredentialsgui.cpp
@@ -30,21 +30,19 @@ using namespace QKeychain;

 namespace OCC {

-Q_LOGGING_CATEGORY(lcHttpCredentialsGui, "sync.credentials.http.gui", QtInfoMsg)
-
 void HttpCredentialsGui::askFromUser()
 {
-    // This function can be called from AccountState::slotInvalidCredentials,
-    // which (indirectly, through HttpCredentials::invalidateToken) schedules
-    // a cache wipe of the qnam. We can only execute a network job again once
-    // the cache has been cleared, otherwise we'd interfere with the job.
-    QTimer::singleShot(100, this, &HttpCredentialsGui::askFromUserAsync);
+    // Unfortunately there's a bug that doesn't allow us to send the "is this
+    // OAuth2 or Basic auth?" GET request directly. Scheduling it for the event
+    // loop works though. See #5989.
+    QMetaObject::invokeMethod(this, "askFromUserAsync", Qt::QueuedConnection);
 }

 void HttpCredentialsGui::askFromUserAsync()
 {
    // First, we will check what kind of auth we need.
    auto job = new DetermineAuthTypeJob(_account->sharedFromThis(), this);
+    job->setTimeout(30 * 1000);
    QObject::connect(job, &DetermineAuthTypeJob::authType, this, [this](DetermineAuthTypeJob::AuthType type) {
        if (type == DetermineAuthTypeJob::OAuth) {
            _asyncAuth.reset(new OAuth(_account, this));
@@ -60,8 +58,7 @@ void HttpCredentialsGui::askFromUserAsync()
            // We will re-enter the event loop, so better wait the next iteration
            QMetaObject::invokeMethod(this, "showDialog", Qt::QueuedConnection);
        } else {
-            // Shibboleth?
-            qCWarning(lcHttpCredentialsGui) << "Bad http auth type:" << type;
+            // Network error? Unsupported auth type?
            emit asked();
        }
    });
--- a/src/gui/creds/httpcredentialsgui.h
+++ b/src/gui/creds/httpcredentialsgui.h
@@ -60,12 +60,12 @@ public:
 private slots:
    void asyncAuthResult(OAuth::Result, const QString &user, const QString &accessToken, const QString &refreshToken);
    void showDialog();
-    void askFromUserAsync();

 signals:
    void authorisationLinkChanged();

 private:
+    Q_INVOKABLE void askFromUserAsync();

    QScopedPointer<OAuth, QScopedPointerObjectDeleteLater<OAuth>> _asyncAuth;
 };
--- a/src/gui/creds/shibboleth/shibbolethwebview.cpp
+++ b/src/gui/creds/shibboleth/shibbolethwebview.cpp
@@ -43,7 +43,7 @@ public:
    UserAgentWebPage(QObject *parent)
        : QWebPage(parent)
    {
-        if (!qEnvironmentVariableIsEmpty("OWNCLOUD_SHIBBOLETH_DEBUG")) {
+        if (!qgetenv("OWNCLOUD_SHIBBOLETH_DEBUG").isEmpty()) {
            settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
        }
    }
@@ -83,7 +83,7 @@ ShibbolethWebView::ShibbolethWebView(AccountPtr account, QWidget *parent)
    setWindowTitle(tr("%1 - Authenticate").arg(Theme::instance()->appNameGUI()));

    // Debug view to display the cipher suite
-    if (!qEnvironmentVariableIsEmpty("OWNCLOUD_SHIBBOLETH_DEBUG")) {
+    if (!qgetenv("OWNCLOUD_SHIBBOLETH_DEBUG").isEmpty()) {
        // open an additional window to display some cipher debug info
        QWebPage *debugPage = new UserAgentWebPage(this);
        debugPage->mainFrame()->load(QUrl("https://cc.dcsec.uni-hannover.de/"));
--- a/src/gui/folder.cpp
+++ b/src/gui/folder.cpp
@@ -841,11 +841,6 @@ void Folder::slotTransmissionProgress(const ProgressInfo &pi)
 // a item is completed: count the errors and forward to the ProgressDispatcher
 void Folder::slotItemCompleted(const SyncFileItemPtr &item)
 {
-    if (item->_instruction == CSYNC_INSTRUCTION_NONE || item->_instruction == CSYNC_INSTRUCTION_UPDATE_METADATA) {
-        // We only care about the updates that deserve to be shown in the UI
-        return;
-    }
-
    // add new directories or remove gone away dirs to the watcher
    if (item->isDirectory() && item->_instruction == CSYNC_INSTRUCTION_NEW) {
        FolderMan::instance()->addMonitorPath(alias(), path() + item->_file);
--- a/src/gui/issueswidget.cpp
+++ b/src/gui/issueswidget.cpp
@@ -107,16 +107,6 @@ void IssuesWidget::showEvent(QShowEvent *ev)
 {
    ConfigFile cfg;
    cfg.restoreGeometryHeader(_ui->_treeWidget->header());
-
-    // Sorting by section was newly enabled. But if we restore the header
-    // from a state where sorting was disabled, both of these flags will be
-    // false and sorting will be impossible!
-    _ui->_treeWidget->header()->setSectionsClickable(true);
-    _ui->_treeWidget->header()->setSortIndicatorShown(true);
-
-    // Switch back to "first important, then by time" ordering
-    _ui->_treeWidget->sortByColumn(0, Qt::DescendingOrder);
-
    QWidget::showEvent(ev);
 }

@@ -129,8 +119,6 @@ void IssuesWidget::hideEvent(QHideEvent *ev)

 void IssuesWidget::cleanItems(const QString &folder)
 {
-    _ui->_treeWidget->setSortingEnabled(false);
-
    // The issue list is a state, clear it and let the next sync fill it
    // with ignored files and propagation errors.
    int itemCnt = _ui->_treeWidget->topLevelItemCount();
@@ -141,9 +129,6 @@ void IssuesWidget::cleanItems(const QString &folder)
            delete item;
        }
    }
-
-    _ui->_treeWidget->setSortingEnabled(true);
-
    // update the tabtext
    emit(issueCountUpdated(_ui->_treeWidget->topLevelItemCount()));
 }
@@ -255,7 +240,7 @@ bool IssuesWidget::shouldBeVisible(QTreeWidgetItem *item, AccountState *filterAc
    const QString &filterFolderAlias) const
 {
    bool visible = true;
-    auto status = item->data(3, Qt::UserRole);
+    auto status = item->data(0, Qt::UserRole);
    visible &= (_ui->showIgnores->isChecked() || status != SyncFileItem::FileIgnored);
    visible &= (_ui->showWarnings->isChecked()
        || (status != SyncFileItem::SoftError
@@ -383,14 +368,13 @@ void IssuesWidget::addError(const QString &folderAlias, const QString &message,

    QIcon icon = Theme::instance()->syncStateIcon(SyncResult::Error);

-    QTreeWidgetItem *twitem = new SortedTreeWidgetItem(columns);
+    QTreeWidgetItem *twitem = new QTreeWidgetItem(columns);
    twitem->setData(0, Qt::SizeHintRole, QSize(0, ActivityItemDelegate::rowHeight()));
-    twitem->setData(0, Qt::UserRole, timestamp);
    twitem->setIcon(0, icon);
    twitem->setToolTip(0, longTimeStr);
-    twitem->setData(2, Qt::UserRole, folderAlias);
    twitem->setToolTip(3, message);
-    twitem->setData(3, Qt::UserRole, SyncFileItem::NormalError);
+    twitem->setData(0, Qt::UserRole, SyncFileItem::NormalError);
+    twitem->setData(2, Qt::UserRole, folderAlias);

    addItem(twitem);
    addErrorWidget(twitem, message, category);
--- a/src/gui/issueswidget.ui
+++ b/src/gui/issueswidget.ui
@@ -99,9 +99,6 @@
     <property name="rootIsDecorated">
      <bool>false</bool>
     </property>
-     <property name="sortingEnabled">
-      <bool>true</bool>
-     </property>
     <property name="columnCount">
      <number>4</number>
     </property>
--- a/src/gui/main.cpp
+++ b/src/gui/main.cpp
@@ -88,7 +88,7 @@ int main(int argc, char **argv)

 // check a environment variable for core dumps
 #ifdef Q_OS_UNIX
-    if (!qEnvironmentVariableIsEmpty("OWNCLOUD_CORE_DUMP")) {
+    if (!qgetenv("OWNCLOUD_CORE_DUMP").isEmpty()) {
        struct rlimit core_limit;
        core_limit.rlim_cur = RLIM_INFINITY;
        core_limit.rlim_max = RLIM_INFINITY;
--- a/src/gui/owncloudgui.cpp
+++ b/src/gui/owncloudgui.cpp
@@ -207,23 +207,13 @@ void ownCloudGui::slotComputeOverallSyncStatus()
 {
    bool allSignedOut = true;
    bool allPaused = true;
-    bool allDisconnected = true;
    QVector<AccountStatePtr> problemAccounts;
-    auto setStatusText = [&](const QString &text) {
-        // Don't overwrite the status if we're currently syncing
-        if (FolderMan::instance()->currentSyncFolder())
-            return;
-        _actionStatus->setText(text);
-    };
-
    foreach (auto a, AccountManager::instance()->accounts()) {
        if (!a->isSignedOut()) {
            allSignedOut = false;
        }
        if (!a->isConnected()) {
            problemAccounts.append(a);
-        } else {
-            allDisconnected = false;
        }
    }
    foreach (Folder *f, FolderMan::instance()->map()) {
@@ -234,11 +224,6 @@ void ownCloudGui::slotComputeOverallSyncStatus()

    if (!problemAccounts.empty()) {
        _tray->setIcon(Theme::instance()->folderOfflineIcon(true, contextMenuVisible()));
-        if (allDisconnected) {
-            setStatusText(tr("Disconnected"));
-        } else {
-            setStatusText(tr("Disconnected from some accounts"));
-        }
 #ifdef Q_OS_WIN
        // Windows has a 128-char tray tooltip length limit.
        QStringList accountNames;
@@ -265,12 +250,10 @@ void ownCloudGui::slotComputeOverallSyncStatus()
    if (allSignedOut) {
        _tray->setIcon(Theme::instance()->folderOfflineIcon(true, contextMenuVisible()));
        _tray->setToolTip(tr("Please sign in"));
-        setStatusText(tr("Signed out"));
        return;
    } else if (allPaused) {
        _tray->setIcon(Theme::instance()->syncStateIcon(SyncResult::Paused, true, contextMenuVisible()));
        _tray->setToolTip(tr("Account synchronization is disabled"));
-        setStatusText(tr("Synchronization is paused"));
        return;
    }

@@ -278,40 +261,34 @@ void ownCloudGui::slotComputeOverallSyncStatus()
    QString trayMessage;
    FolderMan *folderMan = FolderMan::instance();
    Folder::Map map = folderMan->map();
-    SyncResult::Status overallResult = FolderMan::accountStatus(map.values()).status();
+    SyncResult overallResult = FolderMan::accountStatus(map.values());

    // create the tray blob message, check if we have an defined state
-    if (overallResult != SyncResult::Undefined && map.count() > 0) {
+    if (overallResult.status() != SyncResult::Undefined) {
+        if (map.count() > 0) {
 #ifdef Q_OS_WIN
-        // Windows has a 128-char tray tooltip length limit.
-        trayMessage = folderMan->statusToString(overallResult, false);
+            // Windows has a 128-char tray tooltip length limit.
+            trayMessage = folderMan->statusToString(overallResult.status(), false);
 #else
-        QStringList allStatusStrings;
-        foreach (Folder *folder, map.values()) {
-            QString folderMessage = folderMan->statusToString(folder->syncResult().status(), folder->syncPaused());
-            allStatusStrings += tr("Folder %1: %2").arg(folder->shortGuiLocalPath(), folderMessage);
-        }
-        trayMessage = allStatusStrings.join(QLatin1String("\n"));
+            QStringList allStatusStrings;
+            foreach (Folder *folder, map.values()) {
+                QString folderMessage = folderMan->statusToString(folder->syncResult().status(), folder->syncPaused());
+                allStatusStrings += tr("Folder %1: %2").arg(folder->shortGuiLocalPath(), folderMessage);
+            }
+            trayMessage = allStatusStrings.join(QLatin1String("\n"));
 #endif
+        } else {
+            trayMessage = tr("No sync folders configured.");
+        }

-        QIcon statusIcon = Theme::instance()->syncStateIcon(overallResult, true, contextMenuVisible());
+        QIcon statusIcon = Theme::instance()->syncStateIcon(overallResult.status(), true, contextMenuVisible());
        _tray->setIcon(statusIcon);
        _tray->setToolTip(trayMessage);
-
-        if (overallResult == SyncResult::Success || overallResult == SyncResult::Problem) {
-            setStatusText(tr("Up to date"));
-        } else if (overallResult == SyncResult::Paused) {
-            setStatusText(tr("Synchronization is paused"));
-        } else {
-            setStatusText(tr("Error during synchronization"));
-        }
    } else {
-        if (overallResult == SyncResult::Undefined)
-            overallResult = SyncResult::Problem;
-        QIcon icon = Theme::instance()->syncStateIcon(overallResult, true, contextMenuVisible());
+        // undefined because there are no folders.
+        QIcon icon = Theme::instance()->syncStateIcon(SyncResult::Problem, true, contextMenuVisible());
        _tray->setIcon(icon);
        _tray->setToolTip(tr("There are no sync folders configured."));
-        setStatusText(tr("No sync folders configured"));
    }
 }

@@ -573,13 +550,11 @@ void ownCloudGui::updateContextMenu()

    _contextMenu->addSeparator();

-    _contextMenu->addAction(_actionStatus);
    if (isConfigured && atLeastOneConnected) {
+        _contextMenu->addAction(_actionStatus);
        _contextMenu->addMenu(_recentActionsMenu);
+        _contextMenu->addSeparator();
    }
-
-    _contextMenu->addSeparator();
-
    if (accountList.isEmpty()) {
        _contextMenu->addAction(_actionNewAccountWizard);
    }
@@ -767,7 +742,7 @@ void ownCloudGui::slotUpdateProgress(const QString &folder, const ProgressInfo &
                                       .arg(progress._currentDiscoveredFolder));
        }
    } else if (progress.status() == ProgressInfo::Done) {
-        QTimer::singleShot(2000, this, &ownCloudGui::slotComputeOverallSyncStatus);
+        QTimer::singleShot(2000, this, &ownCloudGui::slotDisplayIdle);
    }
    if (progress.status() != ProgressInfo::Propagation) {
        return;
@@ -837,6 +812,11 @@ void ownCloudGui::slotUpdateProgress(const QString &folder, const ProgressInfo &
    }
 }

+void ownCloudGui::slotDisplayIdle()
+{
+    _actionStatus->setText(tr("Up to date"));
+}
+
 void ownCloudGui::slotLogin()
 {
    if (auto account = qvariant_cast<AccountStatePtr>(sender()->property(propertyAccountC))) {
--- a/src/gui/owncloudgui.h
+++ b/src/gui/owncloudgui.h
@@ -98,6 +98,7 @@ public slots:
    void slotRemoveDestroyedShareDialogs();

 private slots:
+    void slotDisplayIdle();
    void slotLogin();
    void slotLogout();
    void slotUnpauseAllFolders();
--- a/src/gui/owncloudsetupwizard.cpp
+++ b/src/gui/owncloudsetupwizard.cpp
@@ -18,7 +18,6 @@
 #include <QProcess>
 #include <QMessageBox>
 #include <QDesktopServices>
-#include <QApplication>

 #include "wizard/owncloudwizardcommon.h"
 #include "wizard/owncloudwizard.h"
@@ -46,7 +45,7 @@ OwncloudSetupWizard::OwncloudSetupWizard(QObject *parent)
    , _remoteFolder()
 {
    connect(_ocWizard, &OwncloudWizard::determineAuthType,
-        this, &OwncloudSetupWizard::slotCheckServer);
+        this, &OwncloudSetupWizard::slotDetermineAuthType);
    connect(_ocWizard, &OwncloudWizard::connectToOCUrl,
        this, &OwncloudSetupWizard::slotConnectToOCUrl);
    connect(_ocWizard, &OwncloudWizard::createLocalAndRemoteFolders,
@@ -70,7 +69,6 @@ static QPointer<OwncloudSetupWizard> wiz = 0;
 void OwncloudSetupWizard::runWizard(QObject *obj, const char *amember, QWidget *parent)
 {
    if (!wiz.isNull()) {
-        bringWizardToFrontIfVisible();
        return;
    }

@@ -86,17 +84,6 @@ bool OwncloudSetupWizard::bringWizardToFrontIfVisible()
        return false;
    }

-    if (wiz->_ocWizard->currentId() == WizardCommon::Page_ShibbolethCreds) {
-        // Try to find if there is a browser open and raise that instead (Issue #6105)
-        const auto allWindow = qApp->topLevelWidgets();
-        auto it = std::find_if(allWindow.cbegin(), allWindow.cend(), [](QWidget *w)
-            { return QLatin1String(w->metaObject()->className()) == QLatin1String("OCC::ShibbolethWebView"); });
-        if (it != allWindow.cend()) {
-            ownCloudGui::raiseDialog(*it);
-            return true;
-        }
-    }
-
    ownCloudGui::raiseDialog(wiz->_ocWizard);
    return true;
 }
@@ -140,7 +127,7 @@ void OwncloudSetupWizard::startWizard()
 }

 // also checks if an installation is valid and determines auth type in a second step
-void OwncloudSetupWizard::slotCheckServer(const QString &urlString)
+void OwncloudSetupWizard::slotDetermineAuthType(const QString &urlString)
 {
    QString fixedUrl = urlString;
    QUrl url = QUrl::fromUserInput(fixedUrl);
@@ -163,7 +150,7 @@ void OwncloudSetupWizard::slotCheckServer(const QString &urlString)
        // We want to reset the QNAM proxy so that the global proxy settings are used (via ClientProxy settings)
        account->networkAccessManager()->setProxy(QNetworkProxy(QNetworkProxy::DefaultProxy));
        // use a queued invocation so we're as asynchronous as with the other code path
-        QMetaObject::invokeMethod(this, "slotFindServer", Qt::QueuedConnection);
+        QMetaObject::invokeMethod(this, "slotContinueDetermineAuth", Qt::QueuedConnection);
    }
 }

@@ -177,40 +164,20 @@ void OwncloudSetupWizard::slotSystemProxyLookupDone(const QNetworkProxy &proxy)
    AccountPtr account = _ocWizard->account();
    account->networkAccessManager()->setProxy(proxy);

-    slotFindServer();
+    slotContinueDetermineAuth();
 }

-void OwncloudSetupWizard::slotFindServer()
+void OwncloudSetupWizard::slotContinueDetermineAuth()
 {
    AccountPtr account = _ocWizard->account();

    // Set fake credentials before we check what credential it actually is.
    account->setCredentials(CredentialsFactory::create("dummy"));

-    // Determining the actual server URL can be a multi-stage process
-    // 1. Check url/status.php with CheckServerJob
-    //    If that works we're done. In that case we don't check the
-    //    url directly for redirects, see #5954.
-    // 2. Check the url for permanent redirects (like url shorteners)
-    // 3. Check redirected-url/status.php with CheckServerJob
-
-    // Step 1: Check url/status.php
-    CheckServerJob *job = new CheckServerJob(account, this);
-    job->setIgnoreCredentialFailure(true);
-    connect(job, &CheckServerJob::instanceFound, this, &OwncloudSetupWizard::slotFoundServer);
-    connect(job, &CheckServerJob::instanceNotFound, this, &OwncloudSetupWizard::slotFindServerBehindRedirect);
-    connect(job, &CheckServerJob::timeout, this, &OwncloudSetupWizard::slotNoServerFoundTimeout);
-    job->setTimeout((account->url().scheme() == "https") ? 30 * 1000 : 10 * 1000);
-    job->start();
-
-    // Step 2 and 3 are in slotFindServerBehindRedirect()
-}
-
-void OwncloudSetupWizard::slotFindServerBehindRedirect()
-{
-    AccountPtr account = _ocWizard->account();
-
-    // Step 2: Resolve any permanent redirect chains on the base url
+    // Before we check the auth type, resolve any permanent redirect
+    // chain there might be. We cannot do this only on url/status.php
+    // in CheckServerJob, because things like url shorteners don't
+    // redirect subpaths.
    auto redirectCheckJob = account->sendRequest("GET", account->url());

    // Use a significantly reduced timeout for this redirect check:
@@ -230,20 +197,20 @@ void OwncloudSetupWizard::slotFindServerBehindRedirect()
            }
        });

-    // Step 3: When done, start checking status.php.
+    // When done, start checking status.php.
    connect(redirectCheckJob, &SimpleNetworkJob::finishedSignal, this,
        [this, account]() {
            CheckServerJob *job = new CheckServerJob(account, this);
            job->setIgnoreCredentialFailure(true);
-            connect(job, &CheckServerJob::instanceFound, this, &OwncloudSetupWizard::slotFoundServer);
-            connect(job, &CheckServerJob::instanceNotFound, this, &OwncloudSetupWizard::slotNoServerFound);
-            connect(job, &CheckServerJob::timeout, this, &OwncloudSetupWizard::slotNoServerFoundTimeout);
+            connect(job, &CheckServerJob::instanceFound, this, &OwncloudSetupWizard::slotOwnCloudFoundAuth);
+            connect(job, &CheckServerJob::instanceNotFound, this, &OwncloudSetupWizard::slotNoOwnCloudFoundAuth);
+            connect(job, &CheckServerJob::timeout, this, &OwncloudSetupWizard::slotNoOwnCloudFoundAuthTimeout);
            job->setTimeout((account->url().scheme() == "https") ? 30 * 1000 : 10 * 1000);
            job->start();
-    });
+        });
 }

-void OwncloudSetupWizard::slotFoundServer(const QUrl &url, const QJsonObject &info)
+void OwncloudSetupWizard::slotOwnCloudFoundAuth(const QUrl &url, const QJsonObject &info)
 {
    auto serverVersion = CheckServerJob::version(info);

@@ -263,10 +230,14 @@ void OwncloudSetupWizard::slotFoundServer(const QUrl &url, const QJsonObject &in
        qCInfo(lcWizard) << " was redirected to" << url.toString();
    }

-    slotDetermineAuthType();
+    DetermineAuthTypeJob *job = new DetermineAuthTypeJob(_ocWizard->account(), this);
+    job->setIgnoreCredentialFailure(true);
+    connect(job, &DetermineAuthTypeJob::authType,
+        _ocWizard, &OwncloudWizard::setAuthType);
+    job->start();
 }

-void OwncloudSetupWizard::slotNoServerFound(QNetworkReply *reply)
+void OwncloudSetupWizard::slotNoOwnCloudFoundAuth(QNetworkReply *reply)
 {
    auto job = qobject_cast<CheckServerJob *>(sender());
    int resultCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
@@ -279,7 +250,7 @@ void OwncloudSetupWizard::slotNoServerFound(QNetworkReply *reply)
    } else {
        msg = tr("Failed to connect to %1 at %2:<br/>%3")
                  .arg(Utility::escape(Theme::instance()->appNameGUI()),
-                      Utility::escape(_ocWizard->account()->url().toString()),
+                      Utility::escape(reply->url().toString()),
                      Utility::escape(job->errorString()));
    }
    bool isDowngradeAdvised = checkDowngradeAdvised(reply);
@@ -294,8 +265,7 @@ void OwncloudSetupWizard::slotNoServerFound(QNetworkReply *reply)
        QString serverError = reply->peek(1024 * 20);
        qCDebug(lcWizard) << serverError;
        QMessageBox messageBox(_ocWizard);
-        messageBox.setText(tr("The server reported the following error:"));
-        messageBox.setInformativeText(serverError);
+        messageBox.setText(serverError);
        messageBox.addButton(QMessageBox::Ok);
        messageBox.setTextFormat(Qt::RichText);
        messageBox.exec();
@@ -309,20 +279,12 @@ void OwncloudSetupWizard::slotNoServerFound(QNetworkReply *reply)
    _ocWizard->account()->resetRejectedCertificates();
 }

-void OwncloudSetupWizard::slotNoServerFoundTimeout(const QUrl &url)
+void OwncloudSetupWizard::slotNoOwnCloudFoundAuthTimeout(const QUrl &url)
 {
    _ocWizard->displayError(
        tr("Timeout while trying to connect to %1 at %2.")
            .arg(Utility::escape(Theme::instance()->appNameGUI()), Utility::escape(url.toString())),
-                false);
-}
-
-void OwncloudSetupWizard::slotDetermineAuthType()
-{
-    DetermineAuthTypeJob *job = new DetermineAuthTypeJob(_ocWizard->account(), this);
-    connect(job, &DetermineAuthTypeJob::authType,
-        _ocWizard, &OwncloudWizard::setAuthType);
-    job->start();
+        false);
 }

 void OwncloudSetupWizard::slotConnectToOCUrl(const QString &url)
--- a/src/gui/owncloudsetupwizard.h
+++ b/src/gui/owncloudsetupwizard.h
@@ -49,16 +49,12 @@ signals:
    void ownCloudWizardDone(int);

 private slots:
-    void slotCheckServer(const QString &);
+    void slotDetermineAuthType(const QString &);
    void slotSystemProxyLookupDone(const QNetworkProxy &proxy);
-
-    void slotFindServer();
-    void slotFindServerBehindRedirect();
-    void slotFoundServer(const QUrl &, const QJsonObject &);
-    void slotNoServerFound(QNetworkReply *reply);
-    void slotNoServerFoundTimeout(const QUrl &url);
-
-    void slotDetermineAuthType();
+    void slotContinueDetermineAuth();
+    void slotOwnCloudFoundAuth(const QUrl &, const QJsonObject &);
+    void slotNoOwnCloudFoundAuth(QNetworkReply *reply);
+    void slotNoOwnCloudFoundAuthTimeout(const QUrl &url);

    void slotConnectToOCUrl(const QString &);
    void slotAuthError();
--- a/src/gui/protocolwidget.cpp
+++ b/src/gui/protocolwidget.cpp
@@ -32,19 +32,6 @@

 namespace OCC {

-bool SortedTreeWidgetItem::operator<(const QTreeWidgetItem &other) const
-{
-    int column = treeWidget()->sortColumn();
-    if (column != 0) {
-        return QTreeWidgetItem::operator<(other);
-    }
-
-    // Items with empty "File" column are larger than others,
-    // otherwise sort by time (this uses lexicographic ordering)
-    return std::forward_as_tuple(text(1).isEmpty(), data(0, Qt::UserRole).toDateTime())
-        < std::forward_as_tuple(other.text(1).isEmpty(), other.data(0, Qt::UserRole).toDateTime());
-}
-
 ProtocolWidget::ProtocolWidget(QWidget *parent)
    : QWidget(parent)
    , _ui(new Ui::ProtocolWidget)
@@ -99,16 +86,6 @@ void ProtocolWidget::showEvent(QShowEvent *ev)
 {
    ConfigFile cfg;
    cfg.restoreGeometryHeader(_ui->_treeWidget->header());
-
-    // Sorting by section was newly enabled. But if we restore the header
-    // from a state where sorting was disabled, both of these flags will be
-    // false and sorting will be impossible!
-    _ui->_treeWidget->header()->setSectionsClickable(true);
-    _ui->_treeWidget->header()->setSortIndicatorShown(true);
-
-    // Switch back to "by time" ordering
-    _ui->_treeWidget->sortByColumn(0, Qt::DescendingOrder);
-
    QWidget::showEvent(ev);
 }

@@ -181,15 +158,14 @@ QTreeWidgetItem *ProtocolWidget::createCompletedTreewidgetItem(const QString &fo
        columns << Utility::octetsToString(item._size);
    }

-    QTreeWidgetItem *twitem = new SortedTreeWidgetItem(columns);
+    QTreeWidgetItem *twitem = new QTreeWidgetItem(columns);
    twitem->setData(0, Qt::SizeHintRole, QSize(0, ActivityItemDelegate::rowHeight()));
-    twitem->setData(0, Qt::UserRole, timestamp);
    twitem->setIcon(0, icon);
    twitem->setToolTip(0, longTimeStr);
    twitem->setToolTip(1, item._file);
-    twitem->setData(2, Qt::UserRole, folder);
    twitem->setToolTip(3, message);
-    twitem->setData(3, Qt::UserRole, item._status);
+    twitem->setData(0, Qt::UserRole, item._status);
+    twitem->setData(2, Qt::UserRole, folder);
    return twitem;
 }

--- a/src/gui/protocolwidget.h
+++ b/src/gui/protocolwidget.h
@@ -34,21 +34,6 @@ namespace Ui {
 }
 class Application;

-/**
- * A QTreeWidgetItem with special sorting.
- *
- * It allows items for global entries to be moved to the top if the
- * sorting section is the "Time" column.
- */
-class SortedTreeWidgetItem : public QTreeWidgetItem
-{
-public:
-    using QTreeWidgetItem::QTreeWidgetItem;
-
-private:
-    bool operator<(const QTreeWidgetItem &other) const override;
-};
-
 /**
 * @brief The ProtocolWidget class
 * @ingroup gui
--- a/src/gui/protocolwidget.ui
+++ b/src/gui/protocolwidget.ui
@@ -35,9 +35,6 @@
     <property name="uniformRowHeights">
      <bool>true</bool>
     </property>
-     <property name="sortingEnabled">
-      <bool>true</bool>
-     </property>
     <property name="columnCount">
      <number>4</number>
     </property>
--- a/src/gui/settingsdialog.cpp
+++ b/src/gui/settingsdialog.cpp
@@ -55,8 +55,6 @@ static const float buttonSizeRatio = 1.618; // golden ratio

 namespace OCC {

-#include "settingsdialogcommon.cpp"
-
 static QIcon circleMask(const QImage &avatar)
 {
    int dim = avatar.width();
@@ -238,7 +236,7 @@ void SettingsDialog::accountAdded(AccountState *s)

    if (!brandingSingleAccount) {
        accountAction->setToolTip(s->account()->displayName());
-        accountAction->setIconText(SettingsDialogCommon::shortDisplayNameForSettings(s->account().data(),  height * buttonSizeRatio));
+        accountAction->setIconText(s->shortDisplayNameForSettings(height * buttonSizeRatio));
    }
    _toolBar->insertAction(_toolBar->actions().at(0), accountAction);
    auto accountSettings = new AccountSettings(s, this);
@@ -252,7 +250,6 @@ void SettingsDialog::accountAdded(AccountState *s)
        _gui, &ownCloudGui::slotFolderOpenAction);
    connect(accountSettings, &AccountSettings::showIssuesList, this, &SettingsDialog::showIssuesList);
    connect(s->account().data(), &Account::accountChangedAvatar, this, &SettingsDialog::slotAccountAvatarChanged);
-    connect(s->account().data(), &Account::accountChangedDisplayName, this, &SettingsDialog::slotAccountDisplayNameChanged);

    slotRefreshActivity(s);
 }
@@ -271,20 +268,6 @@ void SettingsDialog::slotAccountAvatarChanged()
    }
 }

-void SettingsDialog::slotAccountDisplayNameChanged()
-{
-    Account *account = static_cast<Account *>(sender());
-    if (account && _actionForAccount.contains(account)) {
-        QAction *action = _actionForAccount[account];
-        if (action) {
-            QString displayName = account->displayName();
-            action->setText(displayName);
-            auto height = _toolBar->sizeHint().height();
-            action->setIconText(SettingsDialogCommon::shortDisplayNameForSettings(account, height * buttonSizeRatio));
-        }
-    }
-}
-
 void SettingsDialog::accountRemoved(AccountState *s)
 {
    for (auto it = _actionGroupWidgets.begin(); it != _actionGroupWidgets.end(); ++it) {
--- a/src/gui/settingsdialog.h
+++ b/src/gui/settingsdialog.h
@@ -60,7 +60,6 @@ public slots:
    void slotSwitchPage(QAction *action);
    void slotRefreshActivity(AccountState *accountState);
    void slotAccountAvatarChanged();
-    void slotAccountDisplayNameChanged();

 protected:
    void reject() Q_DECL_OVERRIDE;
--- a/src/gui/settingsdialogcommon.cpp
+++ b/src/gui/settingsdialogcommon.cpp
@@ -1,28 +0,0 @@
-namespace SettingsDialogCommon
-{
-
-/** display name with two lines that is displayed in the settings
- * If width is bigger than 0, the string will be ellided so it does not exceed that width
- */
-QString shortDisplayNameForSettings(Account* account, int width)
-{
-    QString user = account->davDisplayName();
-    if (user.isEmpty()) {
-        user = account->credentials()->user();
-    }
-    QString host = account->url().host();
-    int port = account->url().port();
-    if (port > 0 && port != 80 && port != 443) {
-        host.append(QLatin1Char(':'));
-        host.append(QString::number(port));
-    }
-    if (width > 0) {
-        QFont f;
-        QFontMetrics fm(f);
-        host = fm.elidedText(host, Qt::ElideMiddle, width);
-        user = fm.elidedText(user, Qt::ElideRight, width);
-    }
-    return user + QLatin1String("\n") + host;
-}
-
-}
--- a/src/gui/settingsdialogmac.cpp
+++ b/src/gui/settingsdialogmac.cpp
@@ -38,9 +38,6 @@

 namespace OCC {

-#include "settingsdialogcommon.cpp"
-
-
 // Duplicate in settingsdialog.cpp
 static QIcon circleMask(const QImage &avatar)
 {
@@ -149,7 +146,7 @@ void SettingsDialogMac::accountAdded(AccountState *s)
    QIcon accountIcon = MacStandardIcon::icon(MacStandardIcon::UserAccounts);
    auto accountSettings = new AccountSettings(s, this);

-    QString displayName = Theme::instance()->multiAccount() ? SettingsDialogCommon::shortDisplayNameForSettings(s->account().data(), 0) : tr("Account");
+    QString displayName = Theme::instance()->multiAccount() ? s->shortDisplayNameForSettings() : tr("Account");

    insertPreferencesPanel(0, accountIcon, displayName, accountSettings);

@@ -157,8 +154,7 @@ void SettingsDialogMac::accountAdded(AccountState *s)
    connect(accountSettings, &AccountSettings::openFolderAlias, _gui, &ownCloudGui::slotFolderOpenAction);
    connect(accountSettings, &AccountSettings::showIssuesList, this, &SettingsDialogMac::showIssuesList);

-    connect(s->account().data(), &Account::accountChangedAvatar, this, &SettingsDialogMac::slotAccountAvatarChanged);
-    connect(s->account().data(), &Account::accountChangedDisplayName, this, &SettingsDialogMac::slotAccountDisplayNameChanged);
+    connect(s->account().data(), SIGNAL(accountChangedAvatar()), this, SLOT(slotAccountAvatarChanged()));

    slotRefreshActivity(s);
 }
@@ -196,23 +192,4 @@ void SettingsDialogMac::slotAccountAvatarChanged()
        }
    }
 }
-
-void SettingsDialogMac::slotAccountDisplayNameChanged()
-{
-    Account *account = static_cast<Account *>(sender());
-    auto list = findChildren<AccountSettings *>(QString());
-    foreach (auto p, list) {
-        if (p->accountsState()->account() == account) {
-            int idx = indexForPanel(p);
-            QString displayName = account->displayName();
-            if (!displayName.isNull()) {
-                displayName = Theme::instance()->multiAccount()
-                        ? SettingsDialogCommon::shortDisplayNameForSettings(account, 0)
-                        : tr("Account");
-                setPreferencesPanelTitle(idx, displayName);
-            }
-        }
-    }
-}
-
 }
--- a/src/gui/settingsdialogmac.h
+++ b/src/gui/settingsdialogmac.h
@@ -54,7 +54,6 @@ private slots:
    void accountAdded(AccountState *);
    void accountRemoved(AccountState *);
    void slotAccountAvatarChanged();
-    void slotAccountDisplayNameChanged();

 private:
    void closeEvent(QCloseEvent *event);
--- a/src/gui/sharedialog.cpp
+++ b/src/gui/sharedialog.cpp
@@ -133,7 +133,6 @@ ShareDialog::ShareDialog(QPointer<AccountState> accountState,
    job->setProperties(
        QList<QByteArray>()
        << "http://open-collaboration-services.org/ns:share-permissions"
-        << "http://owncloud.org/ns:fileid" // numeric file id for fallback private link generation
        << "http://owncloud.org/ns:privatelink");
    job->setTimeout(10 * 1000);
    connect(job, &PropfindJob::result, this, &ShareDialog::slotPropfindReceived);
@@ -161,13 +160,9 @@ void ShareDialog::slotPropfindReceived(const QVariantMap &result)
        qCInfo(lcSharing) << "Received sharing permissions for" << _sharePath << _maxSharingPermissions;
    }
    auto privateLinkUrl = result["privatelink"].toString();
-    auto numericFileId = result["fileid"].toByteArray();
    if (!privateLinkUrl.isEmpty()) {
        qCInfo(lcSharing) << "Received private link url for" << _sharePath << privateLinkUrl;
        _privateLinkUrl = privateLinkUrl;
-    } else if (!numericFileId.isEmpty()) {
-        qCInfo(lcSharing) << "Received numeric file id for" << _sharePath << numericFileId;
-        _privateLinkUrl = _accountState->account()->deprecatedPrivateLinkUrl(numericFileId).toString(QUrl::FullyEncoded);
    }

    showSharingUi();
--- a/src/gui/sharelinkwidget.cpp
+++ b/src/gui/sharelinkwidget.cpp
@@ -155,15 +155,14 @@ ShareLinkWidget::ShareLinkWidget(AccountPtr account,

    // Prepare sharing menu

-    _linkContextMenu = new QMenu(this);
-    connect(_linkContextMenu, &QMenu::triggered,
-        this, &ShareLinkWidget::slotLinkContextMenuActionTriggered);
-    _deleteLinkAction = _linkContextMenu->addAction(tr("Delete"));
-    _openLinkAction = _linkContextMenu->addAction(tr("Open link in browser"));
-    _copyLinkAction = _linkContextMenu->addAction(tr("Copy link to clipboard"));
-    _copyDirectLinkAction = _linkContextMenu->addAction(tr("Copy link to clipboard (direct download)"));
-    _emailLinkAction = _linkContextMenu->addAction(tr("Send link by email"));
-    _emailDirectLinkAction = _linkContextMenu->addAction(tr("Send link by email (direct download)"));
+    _shareLinkMenu = new QMenu(this);
+    connect(_shareLinkMenu, &QMenu::triggered,
+        this, &ShareLinkWidget::slotShareLinkActionTriggered);
+    _openLinkAction = _shareLinkMenu->addAction(tr("Open link in browser"));
+    _copyLinkAction = _shareLinkMenu->addAction(tr("Copy link to clipboard"));
+    _copyDirectLinkAction = _shareLinkMenu->addAction(tr("Copy link to clipboard (direct download)"));
+    _emailLinkAction = _shareLinkMenu->addAction(tr("Send link by email"));
+    _emailDirectLinkAction = _shareLinkMenu->addAction(tr("Send link by email (direct download)"));

    /*
     * Create the share manager and connect it properly
@@ -232,24 +231,28 @@ void ShareLinkWidget::slotSharesFetched(const QList<QSharedPointer<Share>> &shar
        table->insertRow(row);

        auto nameItem = new QTableWidgetItem;
-        auto name = shareName(*linkShare);
-        if (!_namesSupported) {
-            nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
+        QString name = linkShare->getName();
+        if (name.isEmpty()) {
+            if (!_namesSupported) {
+                name = tr("Public link");
+                nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
+            } else {
+                name = linkShare->getToken();
+            }
        }
        nameItem->setText(name);
        nameItem->setData(Qt::UserRole, QVariant::fromValue(linkShare));
        table->setItem(row, 0, nameItem);

-        auto dotdotdotButton = new QToolButton;
-        dotdotdotButton->setText("...");
-        dotdotdotButton->setProperty(propertyShareC, QVariant::fromValue(linkShare));
-        connect(dotdotdotButton, &QAbstractButton::clicked, this, &ShareLinkWidget::slotContextMenuButtonClicked);
-        table->setCellWidget(row, 1, dotdotdotButton);
+        auto shareButton = new QToolButton;
+        shareButton->setText("...");
+        shareButton->setProperty(propertyShareC, QVariant::fromValue(linkShare));
+        connect(shareButton, &QAbstractButton::clicked, this, &ShareLinkWidget::slotShareLinkButtonClicked);
+        table->setCellWidget(row, 1, shareButton);

        auto deleteButton = new QToolButton;
        deleteButton->setIcon(deleteIcon);
        deleteButton->setProperty(propertyShareC, QVariant::fromValue(linkShare));
-        deleteButton->setToolTip(tr("Delete link share"));
        connect(deleteButton, &QAbstractButton::clicked, this, &ShareLinkWidget::slotDeleteShareClicked);
        table->setCellWidget(row, 2, deleteButton);

@@ -511,56 +514,22 @@ void ShareLinkWidget::openShareLink(const QUrl &url)
    Utility::openBrowser(url, this);
 }

-void ShareLinkWidget::confirmAndDeleteShare(const QSharedPointer<LinkShare> &share)
-{
-    auto messageBox = new QMessageBox(
-        QMessageBox::Question,
-        tr("Confirm Link Share Deletion"),
-        tr("<p>Do you really want to delete the public link share <i>%1</i>?</p>"
-           "<p>Note: This action cannot be undone.</p>")
-            .arg(shareName(*share)),
-        QMessageBox::NoButton,
-        this);
-    QPushButton *yesButton =
-        messageBox->addButton(tr("Delete"), QMessageBox::YesRole);
-    messageBox->addButton(tr("Cancel"), QMessageBox::NoRole);
-
-    connect(messageBox, &QMessageBox::finished, this,
-        [messageBox, yesButton, share]() {
-        if (messageBox->clickedButton() == yesButton)
-            share->deleteShare();
-    });
-    messageBox->open();
-}
-
-QString ShareLinkWidget::shareName(const LinkShare &share) const
-{
-    QString name = share.getName();
-    if (!name.isEmpty())
-        return name;
-    if (!_namesSupported)
-        return tr("Public link");
-    return share.getToken();
-}
-
-void ShareLinkWidget::slotContextMenuButtonClicked()
+void ShareLinkWidget::slotShareLinkButtonClicked()
 {
    auto share = sender()->property(propertyShareC).value<QSharedPointer<LinkShare>>();
    bool downloadEnabled = share->getShowFileListing();
    _copyDirectLinkAction->setVisible(downloadEnabled);
    _emailDirectLinkAction->setVisible(downloadEnabled);

-    _linkContextMenu->setProperty(propertyShareC, QVariant::fromValue(share));
-    _linkContextMenu->exec(QCursor::pos());
+    _shareLinkMenu->setProperty(propertyShareC, QVariant::fromValue(share));
+    _shareLinkMenu->exec(QCursor::pos());
 }

-void ShareLinkWidget::slotLinkContextMenuActionTriggered(QAction *action)
+void ShareLinkWidget::slotShareLinkActionTriggered(QAction *action)
 {
    auto share = sender()->property(propertyShareC).value<QSharedPointer<LinkShare>>();

-    if (action == _deleteLinkAction) {
-        confirmAndDeleteShare(share);
-    } else if (action == _copyLinkAction) {
+    if (action == _copyLinkAction) {
        QApplication::clipboard()->setText(share->getLink().toString());
    } else if (action == _copyDirectLinkAction) {
        QApplication::clipboard()->setText(share->getDirectDownloadLink().toString());
@@ -576,7 +545,7 @@ void ShareLinkWidget::slotLinkContextMenuActionTriggered(QAction *action)
 void ShareLinkWidget::slotDeleteShareClicked()
 {
    auto share = sender()->property(propertyShareC).value<QSharedPointer<LinkShare>>();
-    confirmAndDeleteShare(share);
+    share->deleteShare();
 }

 void ShareLinkWidget::slotPermissionsCheckboxClicked()
--- a/src/gui/sharelinkwidget.h
+++ b/src/gui/sharelinkwidget.h
@@ -70,8 +70,8 @@ private slots:
    void slotPasswordChanged(const QString &newText);
    void slotNameEdited(QTableWidgetItem *item);

-    void slotContextMenuButtonClicked();
-    void slotLinkContextMenuActionTriggered(QAction *action);
+    void slotShareLinkButtonClicked();
+    void slotShareLinkActionTriggered(QAction *action);

    void slotDeleteShareFetched();
    void slotCreateShareFetched(const QSharedPointer<LinkShare> &share);
@@ -93,12 +93,6 @@ private:
    void emailShareLink(const QUrl &url);
    void openShareLink(const QUrl &url);

-    /** Confirm with the user and then delete the share */
-    void confirmAndDeleteShare(const QSharedPointer<LinkShare> &share);
-
-    /** Retrieve a share's name, accounting for _namesSupported */
-    QString shareName(const LinkShare &share) const;
-
    /**
     * Retrieve the selected share, returning 0 if none.
     */
@@ -126,13 +120,12 @@ private:
    // the next time getShares() finishes. This stores its id.
    QString _newShareOverrideSelectionId;

-    QMenu *_linkContextMenu = nullptr;
-    QAction *_deleteLinkAction = nullptr;
-    QAction *_openLinkAction = nullptr;
-    QAction *_copyLinkAction = nullptr;
-    QAction *_copyDirectLinkAction = nullptr;
-    QAction *_emailLinkAction = nullptr;
-    QAction *_emailDirectLinkAction = nullptr;
+    QMenu *_shareLinkMenu;
+    QAction *_openLinkAction;
+    QAction *_copyLinkAction;
+    QAction *_copyDirectLinkAction;
+    QAction *_emailLinkAction;
+    QAction *_emailDirectLinkAction;
 };
 }

--- a/src/gui/sharemanager.cpp
+++ b/src/gui/sharemanager.cpp
@@ -15,40 +15,24 @@
 #include "sharemanager.h"
 #include "ocssharejob.h"
 #include "account.h"
-#include "folderman.h"
-#include "accountstate.h"

 #include <QUrl>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>

-namespace OCC {
-
-/**
- * When a share is modified, we need to tell the folders so they can adjust overlay icons
- */
-static void updateFolder(const AccountPtr &account, const QString &path)
+namespace {
+struct CreateShare
 {
-    foreach (Folder *f, FolderMan::instance()->map()) {
-        if (f->accountState()->account() != account)
-            continue;
-        auto folderPath = f->remotePath();
-        if (path.startsWith(folderPath) && (path == folderPath || folderPath.endsWith('/') || path[folderPath.size()] == '/')) {
-            // Workaround the fact that the server does not invalidate the etags of parent directories
-            // when something is shared.
-            auto relative = path.midRef(folderPath.size());
-            if (relative.startsWith('/'))
-                relative = relative.mid(1);
-            f->journalDb()->avoidReadFromDbOnNextSync(relative.toString());
-
-            // Schedule a sync so it can update the remote permission flag and let the socket API
-            // know about the shared icon.
-            f->scheduleThisFolderSoon();
-        }
-    }
-}
+    QString path;
+    OCC::Share::ShareType shareType;
+    QString shareWith;
+    OCC::Share::Permissions permissions;
+};
+} // anonymous namespace
+Q_DECLARE_METATYPE(CreateShare)

+namespace OCC {

 Share::Share(AccountPtr account,
    const QString &id,
@@ -70,11 +54,6 @@ AccountPtr Share::account() const
    return _account;
 }

-QString Share::path() const
-{
-    return _path;
-}
-
 QString Share::getId() const
 {
    return _id;
@@ -120,8 +99,6 @@ void Share::deleteShare()
 void Share::slotDeleted()
 {
    emit shareDeleted();
-
-    updateFolder(_account, _path);
 }

 void Share::slotOcsError(int statusCode, const QString &message)
@@ -281,8 +258,6 @@ void ShareManager::slotLinkShareCreated(const QJsonDocument &reply)
    QSharedPointer<LinkShare> share(parseLinkShare(data));

    emit linkShareCreated(share);
-
-    updateFolder(_account, share->path());
 }


@@ -292,34 +267,51 @@ void ShareManager::createShare(const QString &path,
    const Share::Permissions permissions)
 {
    auto job = new OcsShareJob(_account);
+
+    // Store values that we need for creating this share later.
+    CreateShare continuation;
+    continuation.path = path;
+    continuation.shareType = shareType;
+    continuation.shareWith = shareWith;
+    continuation.permissions = permissions;
+    _jobContinuation[job] = QVariant::fromValue(continuation);
+
+    connect(job, &OcsShareJob::shareJobFinished, this, &ShareManager::slotCreateShare);
    connect(job, &OcsJob::ocsError, this, &ShareManager::slotOcsError);
-    connect(job, &OcsShareJob::shareJobFinished, this,
-        [=](const QJsonDocument &reply) {
-            // Find existing share permissions (if this was shared with us)
-            Share::Permissions existingPermissions = SharePermissionDefault;
-            foreach (const QJsonValue &element, reply.object()["ocs"].toObject()["data"].toArray()) {
-                auto map = element.toObject();
-                if (map["file_target"] == path)
-                    existingPermissions = Share::Permissions(map["permissions"].toInt());
-            }
-
-            // Limit the permissions we request for a share to the ones the item
-            // was shared with initially.
-            auto perm = permissions;
-            if (permissions == SharePermissionDefault) {
-                perm = existingPermissions;
-            } else if (existingPermissions != SharePermissionDefault) {
-                perm &= existingPermissions;
-            }
-
-            OcsShareJob *job = new OcsShareJob(_account);
-            connect(job, &OcsShareJob::shareJobFinished, this, &ShareManager::slotShareCreated);
-            connect(job, &OcsJob::ocsError, this, &ShareManager::slotOcsError);
-            job->createShare(path, shareType, shareWith, permissions);
-        });
    job->getSharedWithMe();
 }

+void ShareManager::slotCreateShare(const QJsonDocument &reply)
+{
+    if (!_jobContinuation.contains(sender()))
+        return;
+
+    CreateShare cont = _jobContinuation[sender()].value<CreateShare>();
+    if (cont.path.isEmpty())
+        return;
+    _jobContinuation.remove(sender());
+
+    // Find existing share permissions (if this was shared with us)
+    Share::Permissions existingPermissions = SharePermissionDefault;
+    foreach (const QJsonValue &element, reply.object()["ocs"].toObject()["data"].toArray()) {
+        auto map = element.toObject();
+        if (map["file_target"] == cont.path)
+            existingPermissions = Share::Permissions(map["permissions"].toInt());
+    }
+
+    // Limit the permissions we request for a share to the ones the item
+    // was shared with initially.
+    if (cont.permissions == SharePermissionDefault) {
+        cont.permissions = existingPermissions;
+    } else if (existingPermissions != SharePermissionDefault) {
+        cont.permissions &= existingPermissions;
+    }
+
+    OcsShareJob *job = new OcsShareJob(_account);
+    connect(job, &OcsShareJob::shareJobFinished, this, &ShareManager::slotShareCreated);
+    connect(job, &OcsJob::ocsError, this, &ShareManager::slotOcsError);
+    job->createShare(cont.path, cont.shareType, cont.shareWith, cont.permissions);
+}

 void ShareManager::slotShareCreated(const QJsonDocument &reply)
 {
@@ -328,8 +320,6 @@ void ShareManager::slotShareCreated(const QJsonDocument &reply)
    QSharedPointer<Share> share(parseShare(data));

    emit shareCreated(share);
-
-    updateFolder(_account, share->path());
 }

 void ShareManager::fetchShares(const QString &path)
--- a/src/gui/sharemanager.h
+++ b/src/gui/sharemanager.h
@@ -64,8 +64,6 @@ public:
     */
    AccountPtr account() const;

-    QString path() const;
-
    /*
     * Get the id
     */
@@ -295,10 +293,13 @@ private slots:
    void slotLinkShareCreated(const QJsonDocument &reply);
    void slotShareCreated(const QJsonDocument &reply);
    void slotOcsError(int statusCode, const QString &message);
+    void slotCreateShare(const QJsonDocument &reply);
+
 private:
    QSharedPointer<LinkShare> parseLinkShare(const QJsonObject &data);
    QSharedPointer<Share> parseShare(const QJsonObject &data);

+    QMap<QObject *, QVariant> _jobContinuation;
    AccountPtr _account;
 };
 }
--- a/src/gui/socketapi.cpp
+++ b/src/gui/socketapi.cpp
@@ -503,29 +503,27 @@ void fetchPrivateLinkUrl(const QString &localFile, SocketApi *target, void (Sock
    const QString localFileClean = QDir::cleanPath(localFile);
    const QString file = localFileClean.mid(shareFolder->cleanPath().length() + 1);

-    AccountPtr account = shareFolder->accountState()->account();
-
    // Generate private link ourselves: used as a fallback
    SyncJournalFileRecord rec;
    if (!shareFolder->journalDb()->getFileRecord(file, &rec) || !rec.isValid())
        return;
    const QString oldUrl =
-        account->deprecatedPrivateLinkUrl(rec.numericFileId()).toString(QUrl::FullyEncoded);
+        shareFolder->accountState()->account()->deprecatedPrivateLinkUrl(rec.numericFileId()).toString(QUrl::FullyEncoded);

-    // Retrieve the new link or numeric file id by PROPFIND
-    PropfindJob *job = new PropfindJob(account, file, target);
-    job->setProperties(
-        QList<QByteArray>()
-        << "http://owncloud.org/ns:fileid" // numeric file id for fallback private link generation
-        << "http://owncloud.org/ns:privatelink");
+    // If the server doesn't have the property, use the old url directly.
+    if (!shareFolder->accountState()->account()->capabilities().privateLinkPropertyAvailable()) {
+        (target->*targetFun)(oldUrl);
+        return;
+    }
+
+    // Retrieve the new link by PROPFIND
+    PropfindJob *job = new PropfindJob(shareFolder->accountState()->account(), file, target);
+    job->setProperties(QList<QByteArray>() << "http://owncloud.org/ns:privatelink");
    job->setTimeout(10 * 1000);
    QObject::connect(job, &PropfindJob::result, target, [=](const QVariantMap &result) {
        auto privateLinkUrl = result["privatelink"].toString();
-        auto numericFileId = result["fileid"].toByteArray();
        if (!privateLinkUrl.isEmpty()) {
            (target->*targetFun)(privateLinkUrl);
-        } else if (!numericFileId.isEmpty()) {
-            (target->*targetFun)(account->deprecatedPrivateLinkUrl(numericFileId).toString(QUrl::FullyEncoded));
        } else {
            (target->*targetFun)(oldUrl);
        }
--- a/src/gui/wizard/owncloudsetuppage.cpp
+++ b/src/gui/wizard/owncloudsetuppage.cpp
@@ -201,15 +201,13 @@ bool OwncloudSetupPage::urlHasChanged()

 int OwncloudSetupPage::nextId() const
 {
-    switch (_authType) {
-    case DetermineAuthTypeJob::Basic:
+    if (_authType == DetermineAuthTypeJob::Basic) {
        return WizardCommon::Page_HttpCreds;
-    case DetermineAuthTypeJob::OAuth:
+    } else if (_authType == DetermineAuthTypeJob::OAuth) {
        return WizardCommon::Page_OAuthCreds;
-    case DetermineAuthTypeJob::Shibboleth:
+    } else {
        return WizardCommon::Page_ShibbolethCreds;
    }
-    return WizardCommon::Page_HttpCreds;
 }

 QString OwncloudSetupPage::url() const
--- a/src/libsync/abstractnetworkjob.cpp
+++ b/src/libsync/abstractnetworkjob.cpp
@@ -135,7 +135,6 @@ void AbstractNetworkJob::adoptRequest(QNetworkReply *reply)
    addTimer(reply);
    setReply(reply);
    setupConnections(reply);
-    newReplyHook(reply);
 }

 QUrl AbstractNetworkJob::makeAccountUrl(const QString &relativePath) const
@@ -173,6 +172,8 @@ void AbstractNetworkJob::slotFinished()
    QUrl requestedUrl = reply()->request().url();
    QUrl redirectUrl = reply()->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
    if (_followRedirects && !redirectUrl.isEmpty()) {
+        _redirectCount++;
+
        // Redirects may be relative
        if (redirectUrl.isRelative())
            redirectUrl = requestedUrl.resolved(redirectUrl);
@@ -193,32 +194,27 @@ void AbstractNetworkJob::slotFinished()
        QByteArray verb = requestVerb(*reply());
        if (requestedUrl.scheme() == QLatin1String("https") && redirectUrl.scheme() == QLatin1String("http")) {
            qCWarning(lcNetworkJob) << this << "HTTPS->HTTP downgrade detected!";
-        } else if (requestedUrl == redirectUrl || _redirectCount + 1 >= maxRedirects()) {
+        } else if (requestedUrl == redirectUrl || _redirectCount >= maxRedirects()) {
            qCWarning(lcNetworkJob) << this << "Redirect loop detected!";
        } else if (_requestBody && _requestBody->isSequential()) {
            qCWarning(lcNetworkJob) << this << "cannot redirect request with sequential body";
        } else if (verb.isEmpty()) {
            qCWarning(lcNetworkJob) << this << "cannot redirect request: could not detect original verb";
        } else {
-            emit redirected(_reply, redirectUrl, _redirectCount);
+            emit redirected(_reply, redirectUrl, _redirectCount - 1);

-            // The signal emission may have changed this value
-            if (_followRedirects) {
-                _redirectCount++;
-
-                // Create the redirected request and send it
-                qCInfo(lcNetworkJob) << "Redirecting" << verb << requestedUrl << redirectUrl;
-                resetTimeout();
-                if (_requestBody) {
-                    _requestBody->seek(0);
-                }
-                sendRequest(
-                    verb,
-                    redirectUrl,
-                    reply()->request(),
-                    _requestBody);
-                return;
+            // Create the redirected request and send it
+            qCInfo(lcNetworkJob) << "Redirecting" << verb << requestedUrl << redirectUrl;
+            resetTimeout();
+            if (_requestBody) {
+                _requestBody->seek(0);
            }
+            sendRequest(
+                verb,
+                redirectUrl,
+                reply()->request(),
+                _requestBody);
+            return;
        }
    }

--- a/src/libsync/abstractnetworkjob.h
+++ b/src/libsync/abstractnetworkjob.h
@@ -66,7 +66,6 @@ public:
     * requests where custom handling is necessary.
     */
    void setFollowRedirects(bool follow);
-    bool followRedirects() const { return _followRedirects; }

    QByteArray responseTimestamp();

@@ -108,6 +107,8 @@ signals:
    void redirected(QNetworkReply *reply, const QUrl &targetUrl, int redirectCount);

 protected:
+    void setupConnections(QNetworkReply *reply);
+
    /** Initiate a network request, returning a QNetworkReply.
     *
     * Calls setReply() and setupConnections() on it.
@@ -132,16 +133,6 @@ protected:
     */
    void adoptRequest(QNetworkReply *reply);

-    void setupConnections(QNetworkReply *reply);
-
-    /** Can be used by derived classes to set up the network reply.
-     *
-     * Particularly useful when the request is redirected and reply()
-     * changes. For things like setting up additional signal connections
-     * on the new reply.
-     */
-    virtual void newReplyHook(QNetworkReply *) {}
-
    /// Creates a url for the account from a relative path
    QUrl makeAccountUrl(const QString &relativePath) const;

--- a/src/libsync/account.cpp
+++ b/src/libsync/account.cpp
@@ -105,7 +105,7 @@ void Account::setAvatar(const QImage &img)

 QString Account::displayName() const
 {
-    QString dn = QString("%1@%2").arg(davUser(), _url.host());
+    QString dn = QString("%1@%2").arg(_credentials->user(), _url.host());
    int port = url().port();
    if (port > 0 && port != 80 && port != 443) {
        dn.append(QLatin1Char(':'));
@@ -114,17 +114,6 @@ QString Account::displayName() const
    return dn;
 }

-QString Account::davDisplayName() const
-{
-    return _displayName;
-}
-
-void Account::setDavDisplayName(const QString &newDisplayName)
-{
-    _displayName = newDisplayName;
-    emit accountChangedDisplayName();
-}
-
 QString Account::id() const
 {
    return _id;
@@ -176,7 +165,7 @@ QUrl Account::davUrl() const

 QUrl Account::deprecatedPrivateLinkUrl(const QByteArray &numericFileId) const
 {
-    return Utility::concatUrlPath(_userVisibleUrl,
+    return Utility::concatUrlPath(url(),
        QLatin1String("/index.php/f/") + QUrl::toPercentEncoding(QString::fromLatin1(numericFileId)));
 }

@@ -311,12 +300,6 @@ void Account::setSslErrorHandler(AbstractSslErrorHandler *handler)
 void Account::setUrl(const QUrl &url)
 {
    _url = url;
-    _userVisibleUrl = url;
-}
-
-void Account::setUserVisibleHost(const QString &host)
-{
-    _userVisibleUrl.setHost(host);
 }

 QVariant Account::credentialSetting(const QString &key) const
--- a/src/libsync/account.h
+++ b/src/libsync/account.h
@@ -83,9 +83,6 @@ public:
    QString davUser() const;
    void setDavUser(const QString &newDavUser);

-    QString davDisplayName() const;
-    void setDavDisplayName(const QString &newDisplayName);
-
    QImage avatar() const;
    void setAvatar(const QImage &img);

@@ -99,9 +96,6 @@ public:
    void setUrl(const QUrl &url);
    QUrl url() const { return _url; }

-    /// Adjusts _userVisibleUrl once the host to use is discovered.
-    void setUserVisibleHost(const QString &host);
-
    /**
     * @brief The possibly themed dav path for the account. It has
     *        a trailing slash.
@@ -215,7 +209,7 @@ public:

    /** True when the server supports HTTP2  */
    bool isHttp2Supported() { return _http2Supported; }
-    void setHttp2Supported(bool value) { _http2Supported = value; }
+    void setHttp2Supported(bool value) { _http2Supported = value; };

    void clearCookieJar();
    void lendCookieJarTo(QNetworkAccessManager *guest);
@@ -252,7 +246,6 @@ signals:
    void serverVersionChanged(Account *account, const QString &newVersion, const QString &oldVersion);

    void accountChangedAvatar();
-    void accountChangedDisplayName();

 protected Q_SLOTS:
    void slotCredentialsFetched();
@@ -265,19 +258,9 @@ private:
    QWeakPointer<Account> _sharedThis;
    QString _id;
    QString _davUser;
-    QString _displayName;
    QImage _avatarImg;
    QMap<QString, QVariant> _settingsMap;
    QUrl _url;
-
-    /** If url to use for any user-visible urls.
-     *
-     * If the server configures overwritehost this can be different from
-     * the connection url in _url. We retrieve the visible host through
-     * the ocs/v1.php/config endpoint in ConnectionValidator.
-     */
-    QUrl _userVisibleUrl;
-
    QList<QSslCertificate> _approvedCerts;
    QSslConfiguration _sslConfiguration;
    Capabilities _capabilities;
--- a/src/libsync/capabilities.cpp
+++ b/src/libsync/capabilities.cpp
@@ -145,9 +145,4 @@ QList<int> Capabilities::httpErrorCodesThatResetFailingChunkedUploads() const
    }
    return list;
 }
-
-QString Capabilities::invalidFilenameRegex() const
-{
-    return _capabilities["dav"].toMap()["invalidFilenameRegex"].toString();
-}
 }
--- a/src/libsync/capabilities.h
+++ b/src/libsync/capabilities.h
@@ -105,17 +105,6 @@ public:
     */
    QList<int> httpErrorCodesThatResetFailingChunkedUploads() const;

-    /**
-     * Regex that, if contained in a filename, will result in it not being uploaded.
-     *
-     * For servers older than 8.1.0 it defaults to [\\:?*"<>|]
-     * For servers >= that version, it defaults to the empty regex (the server
-     * will indicate invalid characters through an upload error)
-     *
-     * Note that it just needs to be contained. The regex [ab] is contained in "car".
-     */
-    QString invalidFilenameRegex() const;
-
 private:
    QVariantMap _capabilities;
 };
--- a/src/libsync/connectionvalidator.cpp
+++ b/src/libsync/connectionvalidator.cpp
@@ -18,7 +18,6 @@
 #include <QNetworkReply>
 #include <QNetworkProxyFactory>
 #include <QPixmap>
-#include <QXmlStreamReader>

 #include "connectionvalidator.h"
 #include "account.h"
@@ -248,22 +247,10 @@ void ConnectionValidator::slotAuthSuccess()

 void ConnectionValidator::checkServerCapabilities()
 {
-    // The main flow now needs the capabilities
    JsonApiJob *job = new JsonApiJob(_account, QLatin1String("ocs/v1.php/cloud/capabilities"), this);
    job->setTimeout(timeoutToUseMsec);
    QObject::connect(job, &JsonApiJob::jsonReceived, this, &ConnectionValidator::slotCapabilitiesRecieved);
    job->start();
-
-    // And we'll retrieve the ocs config in parallel
-    // note that 'this' might be destroyed before the job finishes, so intentionally not parented
-    auto configJob = new JsonApiJob(_account, QLatin1String("ocs/v1.php/config"));
-    configJob->setTimeout(timeoutToUseMsec);
-    auto account = _account; // capturing account by value will make it live long enough
-    QObject::connect(configJob, &JsonApiJob::jsonReceived, _account.data(),
-        [=](const QJsonDocument &json) {
-            ocsConfigReceived(json, account);
-        });
-    configJob->start();
 }

 void ConnectionValidator::slotCapabilitiesRecieved(const QJsonDocument &json)
@@ -281,17 +268,6 @@ void ConnectionValidator::slotCapabilitiesRecieved(const QJsonDocument &json)
    fetchUser();
 }

-void ConnectionValidator::ocsConfigReceived(const QJsonDocument &json, AccountPtr account)
-{
-    QString host = json.object().value("ocs").toObject().value("data").toObject().value("host").toString();
-    if (host.isEmpty()) {
-        qCWarning(lcConnectionValidator) << "Could not extract 'host' from ocs config reply";
-        return;
-    }
-    qCInfo(lcConnectionValidator) << "Determined user-visible host to be" << host;
-    account->setUserVisibleHost(host);
-}
-
 void ConnectionValidator::fetchUser()
 {
    JsonApiJob *job = new JsonApiJob(_account, QLatin1String("ocs/v1.php/cloud/user"), this);
@@ -340,10 +316,6 @@ void ConnectionValidator::slotUserFetched(const QJsonDocument &json)

        job->start();
    }
-    QString displayName = json.object().value("ocs").toObject().value("data").toObject().value("display-name").toString();
-    if (!displayName.isEmpty()) {
-        _account->setDavDisplayName(displayName);
-    }
 }

 void ConnectionValidator::slotAvatarImage(const QImage &img)
--- a/src/libsync/connectionvalidator.h
+++ b/src/libsync/connectionvalidator.h
@@ -58,9 +58,9 @@ namespace OCC {
                              |
  +---------------------------+
  |
-  +-> checkServerCapabilities --------------v (in parallel)
-        JsonApiJob (cloud/capabilities)     JsonApiJob (ocs/v1.php/config)
-        |                                   +-> ocsConfigReceived
+  +-> checkServerCapabilities (cloud/capabilities)
+        JsonApiJob
+        |
        +-> slotCapabilitiesRecieved -+
                                      |
  +-----------------------------------+
@@ -129,7 +129,6 @@ private:
    void reportResult(Status status);
    void checkServerCapabilities();
    void fetchUser();
-    static void ocsConfigReceived(const QJsonDocument &json, AccountPtr account);

    /** Sets the account's server version
     *
--- a/src/libsync/creds/abstractcredentials.cpp
+++ b/src/libsync/creds/abstractcredentials.cpp
@@ -14,7 +14,6 @@

 #include <QLoggingCategory>
 #include <QString>
-#include <QCoreApplication>

 #include "common/asserts.h"
 #include "creds/abstractcredentials.h"
@@ -54,15 +53,6 @@ QString AbstractCredentials::keychainKey(const QString &url, const QString &user
    QString key = user + QLatin1Char(':') + u;
    if (!accountId.isEmpty()) {
        key += QLatin1Char(':') + accountId;
-#ifdef Q_OS_WIN
-        // On Windows the credential keys aren't namespaced properly
-        // by qtkeychain. To work around that we manually add namespacing
-        // to the generated keys. See #6125.
-        // It's safe to do that since the key format is changing for 2.4
-        // anyway to include the account ids. That means old keys can be
-        // migrated to new namespaced keys on windows for 2.4.
-        key.prepend(QCoreApplication::applicationName() + "_");
-#endif
    }
    return key;
 }
--- a/src/libsync/creds/httpcredentials.cpp
+++ b/src/libsync/creds/httpcredentials.cpp
@@ -442,38 +442,32 @@ void HttpCredentials::persist()
    _account->setCredentialSetting(QLatin1String(isOAuthC), isUsingOAuth());
    _account->wantsAccountSaved(_account);

-    // write cert if there is one
-    if (!_clientSslCertificate.isNull()) {
-        WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
-        addSettingsToJob(_account, job);
-        job->setInsecureFallback(false);
-        connect(job, &Job::finished, this, &HttpCredentials::slotWriteClientCertPEMJobDone);
-        job->setKey(keychainKey(_account->url().toString(), _user + clientCertificatePEMC, _account->id()));
-        job->setBinaryData(_clientSslCertificate.toPem());
-        job->start();
-    } else {
-        slotWriteClientCertPEMJobDone();
-    }
+    // write cert
+    WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
+    addSettingsToJob(_account, job);
+    job->setInsecureFallback(false);
+    connect(job, &Job::finished, this, &HttpCredentials::slotWriteClientCertPEMJobDone);
+    job->setKey(keychainKey(_account->url().toString(), _user + clientCertificatePEMC, _account->id()));
+    job->setBinaryData(_clientSslCertificate.toPem());
+    job->start();
 }

-void HttpCredentials::slotWriteClientCertPEMJobDone()
+void HttpCredentials::slotWriteClientCertPEMJobDone(Job *incomingJob)
 {
-    // write ssl key if there is one
-    if (!_clientSslKey.isNull()) {
-        WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
-        addSettingsToJob(_account, job);
-        job->setInsecureFallback(false);
-        connect(job, &Job::finished, this, &HttpCredentials::slotWriteClientKeyPEMJobDone);
-        job->setKey(keychainKey(_account->url().toString(), _user + clientKeyPEMC, _account->id()));
-        job->setBinaryData(_clientSslKey.toPem());
-        job->start();
-    } else {
-        slotWriteClientKeyPEMJobDone();
-    }
+    Q_UNUSED(incomingJob);
+    // write ssl key
+    WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
+    addSettingsToJob(_account, job);
+    job->setInsecureFallback(false);
+    connect(job, &Job::finished, this, &HttpCredentials::slotWriteClientKeyPEMJobDone);
+    job->setKey(keychainKey(_account->url().toString(), _user + clientKeyPEMC, _account->id()));
+    job->setBinaryData(_clientSslKey.toPem());
+    job->start();
 }

-void HttpCredentials::slotWriteClientKeyPEMJobDone()
+void HttpCredentials::slotWriteClientKeyPEMJobDone(Job *incomingJob)
 {
+    Q_UNUSED(incomingJob);
    WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
    addSettingsToJob(_account, job);
    job->setInsecureFallback(false);
--- a/src/libsync/creds/httpcredentials.h
+++ b/src/libsync/creds/httpcredentials.h
@@ -114,8 +114,8 @@ private Q_SLOTS:
    void slotReadClientKeyPEMJobDone(QKeychain::Job *);
    void slotReadJobDone(QKeychain::Job *);

-    void slotWriteClientCertPEMJobDone();
-    void slotWriteClientKeyPEMJobDone();
+    void slotWriteClientCertPEMJobDone(QKeychain::Job *);
+    void slotWriteClientKeyPEMJobDone(QKeychain::Job *);
    void slotWriteJobDone(QKeychain::Job *);

 protected:
--- a/src/libsync/networkjobs.cpp
+++ b/src/libsync/networkjobs.cpp
@@ -819,69 +819,71 @@ bool JsonApiJob::finished()
 }

 DetermineAuthTypeJob::DetermineAuthTypeJob(AccountPtr account, QObject *parent)
-    : QObject(parent)
-    , _account(account)
+    : AbstractNetworkJob(account, QString(), parent)
+    , _redirects(0)
 {
+    // This job implements special redirect handling to detect redirections
+    // to pages that are indicative of Shibboleth-using servers. Hence we
+    // disable the standard job redirection handling here.
+    _followRedirects = false;
 }

 void DetermineAuthTypeJob::start()
 {
-    qCInfo(lcDetermineAuthTypeJob) << "Determining auth type for" << _account->davUrl();
+    send(account()->davUrl());
+    AbstractNetworkJob::start();
+}

-    QNetworkRequest req;
-    // Prevent HttpCredentialsAccessManager from setting an Authorization header.
-    req.setAttribute(HttpCredentials::DontAddCredentialsAttribute, true);
-    // Don't reuse previous auth credentials
-    req.setAttribute(QNetworkRequest::AuthenticationReuseAttribute, QNetworkRequest::Manual);
-    // Don't send cookies, we can't determine the auth type if we're logged in
-    req.setAttribute(QNetworkRequest::CookieLoadControlAttribute, QNetworkRequest::Manual);
+bool DetermineAuthTypeJob::finished()
+{
+    QUrl redirection = reply()->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
+    if (_redirects >= maxRedirects()) {
+        redirection.clear();
+    }

-    // Start two parallel requests, one determines whether it's a shib server
-    // and the other checks the HTTP auth method.
-    auto get = _account->sendRequest("GET", _account->davUrl(), req);
-    auto propfind = _account->sendRequest("PROPFIND", _account->davUrl(), req);
-    get->setTimeout(30 * 1000);
-    propfind->setTimeout(30 * 1000);
-    get->setIgnoreCredentialFailure(true);
-    propfind->setIgnoreCredentialFailure(true);
-
-    connect(get, &AbstractNetworkJob::redirected, this, [this, get](QNetworkReply *, const QUrl &target, int) {
+    auto authChallenge = reply()->rawHeader("WWW-Authenticate").toLower();
+    if (redirection.isEmpty()) {
+        if (authChallenge.contains("bearer ")) {
+            emit authType(OAuth);
+        } else if (!authChallenge.isEmpty()) {
+            emit authType(Basic);
+        } else {
+            // This is also where we end up in case of network error.
+            emit authType(Unknown);
+        }
+    } else if (redirection.toString().endsWith(account()->davPath())) {
+        // do a new run
+        _redirects++;
+        resetTimeout();
+        send(redirection);
+        qCDebug(lcDetermineAuthTypeJob()) << "Redirected to:" << redirection.toString();
+        return false; // don't discard
+    } else {
 #ifndef NO_SHIBBOLETH
        QRegExp shibbolethyWords("SAML|wayf");
        shibbolethyWords.setCaseSensitivity(Qt::CaseInsensitive);
-        if (target.toString().contains(shibbolethyWords)) {
-            _resultGet = Shibboleth;
-            get->setFollowRedirects(false);
-        }
+        if (redirection.toString().contains(shibbolethyWords)) {
+            emit authType(Shibboleth);
+        } else
 #endif
-    });
-    connect(get, &SimpleNetworkJob::finishedSignal, this, [this]() {
-        _getDone = true;
-        checkBothDone();
-    });
-    connect(propfind, &SimpleNetworkJob::finishedSignal, this, [this](QNetworkReply *reply) {
-        auto authChallenge = reply->rawHeader("WWW-Authenticate").toLower();
-        if (authChallenge.contains("bearer ")) {
-            _resultPropfind = OAuth;
-        } else if (authChallenge.isEmpty()) {
-            qCWarning(lcDetermineAuthTypeJob) << "Did not receive WWW-Authenticate reply to auth-test PROPFIND";
+        {
+            // We got redirected to an address that doesn't look like shib
+            // and also doesn't have the davPath. Give up.
+            qCWarning(lcDetermineAuthTypeJob()) << account()->davUrl()
+                                                << "was redirected to the incompatible address"
+                                                << redirection.toString();
+            emit authType(Unknown);
        }
-        _propfindDone = true;
-        checkBothDone();
-    });
+    }
+    return true;
 }

-void DetermineAuthTypeJob::checkBothDone()
+void DetermineAuthTypeJob::send(const QUrl &url)
 {
-    if (!_getDone || !_propfindDone)
-        return;
-    auto result = _resultPropfind;
-    // OAuth > Shib > Basic
-    if (_resultGet == Shibboleth && result != OAuth)
-        result = Shibboleth;
-    qCInfo(lcDetermineAuthTypeJob) << "Auth type for" << _account->davUrl() << "is" << result;
-    emit authType(result);
-    deleteLater();
+    QNetworkRequest req;
+    // Prevent HttpCredentialsAccessManager from setting an Authorization header.
+    req.setAttribute(HttpCredentials::DontAddCredentialsAttribute, true);
+    sendRequest("GET", url, req);
 }

 SimpleNetworkJob::SimpleNetworkJob(AccountPtr account, QObject *parent)
--- a/src/libsync/networkjobs.h
+++ b/src/libsync/networkjobs.h
@@ -355,29 +355,26 @@ private:
 * @brief Checks with auth type to use for a server
 * @ingroup libsync
 */
-class OWNCLOUDSYNC_EXPORT DetermineAuthTypeJob : public QObject
+class OWNCLOUDSYNC_EXPORT DetermineAuthTypeJob : public AbstractNetworkJob
 {
    Q_OBJECT
 public:
    enum AuthType {
-        Basic, // also the catch-all fallback for backwards compatibility reasons
+        Unknown,
+        Basic,
        OAuth,
        Shibboleth
    };

    explicit DetermineAuthTypeJob(AccountPtr account, QObject *parent = 0);
-    void start();
+    void start() Q_DECL_OVERRIDE;
 signals:
    void authType(AuthType);
-
+private slots:
+    bool finished() Q_DECL_OVERRIDE;
 private:
-    void checkBothDone();
-
-    AccountPtr _account;
-    AuthType _resultGet = Basic;
-    AuthType _resultPropfind = Basic;
-    bool _getDone = false;
-    bool _propfindDone = false;
+    void send(const QUrl &url);
+    int _redirects;
 };

 /**
--- a/src/libsync/owncloudpropagator.cpp
+++ b/src/libsync/owncloudpropagator.cpp
@@ -114,13 +114,13 @@ PropagateItemJob::~PropagateItemJob()

 static qint64 getMinBlacklistTime()
 {
-    return qMax(qEnvironmentVariableIntValue("OWNCLOUD_BLACKLIST_TIME_MIN"),
+    return qMax(qgetenv("OWNCLOUD_BLACKLIST_TIME_MIN").toInt(),
        25); // 25 seconds
 }

 static qint64 getMaxBlacklistTime()
 {
-    int v = qEnvironmentVariableIntValue("OWNCLOUD_BLACKLIST_TIME_MAX");
+    int v = qgetenv("OWNCLOUD_BLACKLIST_TIME_MAX").toInt();
    if (v > 0)
        return v;
    return 24 * 60 * 60; // 1 day
@@ -742,16 +742,6 @@ PropagatorJob::JobParallelism PropagatorCompositeJob::parallelism()
    return FullParallelism;
 }

-void PropagatorCompositeJob::slotSubJobAbortFinished()
-{
-    // Count that job has been finished
-    _abortsCount--;
-
-    // Emit abort if last job has been aborted
-    if (_abortsCount == 0) {
-        emit abortFinished();
-    }
-}

 bool PropagatorCompositeJob::scheduleSelfOrChild()
 {
@@ -910,8 +900,7 @@ void PropagateDirectory::slotFirstJobFinished(SyncFileItem::Status status)

    if (status != SyncFileItem::Success && status != SyncFileItem::Restoration) {
        if (_state != Finished) {
-            // Synchronously abort
-            abort(AbortType::Synchronous);
+            abort();
            _state = Finished;
            emit finished(status);
        }
--- a/src/libsync/owncloudpropagator.h
+++ b/src/libsync/owncloudpropagator.h
@@ -65,11 +65,6 @@ class PropagatorJob : public QObject
 public:
    explicit PropagatorJob(OwncloudPropagator *propagator);

-    enum AbortType {
-        Synchronous,
-        Asynchronous
-    };
-
    enum JobState {
        NotYetStarted,
        Running,
@@ -103,14 +98,7 @@ public:
    virtual qint64 committedDiskSpace() const { return 0; }

 public slots:
-    /*
-     * Asynchronous abort requires emit of abortFinished() signal,
-     * while synchronous is expected to abort immedietaly.
-    */
-    virtual void abort(PropagatorJob::AbortType abortType) {
-        if (abortType == AbortType::Asynchronous)
-            emit abortFinished();
-    }
+    virtual void abort() {}

    /** Starts this job, or a new subjob
     * returns true if a job was started.
@@ -122,14 +110,11 @@ signals:
     */
    void finished(SyncFileItem::Status);

-    /**
-     * Emitted when the abort is fully finished
-     */
-    void abortFinished(SyncFileItem::Status status = SyncFileItem::NormalError);
 protected:
    OwncloudPropagator *propagator() const;
 };

+
 /*
 * Abstract class to propagate a single item
 */
@@ -200,11 +185,10 @@ public:
    SyncFileItemVector _tasksToDo;
    QVector<PropagatorJob *> _runningJobs;
    SyncFileItem::Status _hasError; // NoStatus,  or NormalError / SoftError if there was an error
-    quint64 _abortsCount;

    explicit PropagatorCompositeJob(OwncloudPropagator *propagator)
        : PropagatorJob(propagator)
-        , _hasError(SyncFileItem::NoStatus), _abortsCount(0)
+        , _hasError(SyncFileItem::NoStatus)
    {
    }

@@ -225,32 +209,15 @@ public:

    virtual bool scheduleSelfOrChild() Q_DECL_OVERRIDE;
    virtual JobParallelism parallelism() Q_DECL_OVERRIDE;
-
-    /*
-     * Abort synchronously or asynchronously - some jobs
-     * require to be finished without immediete abort (abort on job might
-     * cause conflicts/duplicated files - owncloud/client/issues/5949)
-     */
-    virtual void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE
+    virtual void abort() Q_DECL_OVERRIDE
    {
-        if (!_runningJobs.empty()) {
-            _abortsCount = _runningJobs.size();
-            foreach (PropagatorJob *j, _runningJobs) {
-                if (abortType == AbortType::Asynchronous) {
-                    connect(j, &PropagatorJob::abortFinished,
-                            this, &PropagatorCompositeJob::slotSubJobAbortFinished);
-                }
-                j->abort(abortType);
-            }
-        } else if (abortType == AbortType::Asynchronous){
-            emit abortFinished();
-        }
+        foreach (PropagatorJob *j, _runningJobs)
+            j->abort();
    }

    qint64 committedDiskSpace() const Q_DECL_OVERRIDE;

 private slots:
-    void slotSubJobAbortFinished();
    bool possiblyRunNextJob(PropagatorJob *next)
    {
        if (next->_state == NotYetStarted) {
@@ -291,17 +258,11 @@ public:

    virtual bool scheduleSelfOrChild() Q_DECL_OVERRIDE;
    virtual JobParallelism parallelism() Q_DECL_OVERRIDE;
-    virtual void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE
+    virtual void abort() Q_DECL_OVERRIDE
    {
        if (_firstJob)
-            // Force first job to abort synchronously
-            // even if caller allows async abort (asyncAbort)
-            _firstJob->abort(AbortType::Synchronous);
-
-        if (abortType == AbortType::Asynchronous){
-            connect(&_subJobs, &PropagatorCompositeJob::abortFinished, this, &PropagateDirectory::abortFinished);
-        }
-        _subJobs.abort(abortType);
+            _firstJob->abort();
+        _subJobs.abort();
    }

    void increaseAffectedCount()
@@ -319,7 +280,6 @@ private slots:

    void slotFirstJobFinished(SyncFileItem::Status status);
    void slotSubJobsFinished(SyncFileItem::Status status);
-
 };


@@ -364,7 +324,6 @@ public:
        , _chunkSize(10 * 1000 * 1000) // 10 MB, overridden in setSyncOptions
        , _account(account)
    {
-        qRegisterMetaType<PropagatorJob::AbortType>("PropagatorJob::AbortType");
    }

    ~OwncloudPropagator();
@@ -445,23 +404,13 @@ public:

    void abort()
    {
-        bool alreadyAborting = _abortRequested.fetchAndStoreOrdered(true);
-        if (alreadyAborting)
-            return;
+        _abortRequested.fetchAndStoreOrdered(true);
        if (_rootJob) {
-            // Connect to abortFinished  which signals that abort has been asynchronously finished
-            connect(_rootJob.data(), &PropagateDirectory::abortFinished, this, &OwncloudPropagator::emitFinished);
-
-            // Use Queued Connection because we're possibly already in an item's finished stack
-            QMetaObject::invokeMethod(_rootJob.data(), "abort", Qt::QueuedConnection,
-                                      Q_ARG(PropagatorJob::AbortType, PropagatorJob::AbortType::Asynchronous));
-
-            // Give asynchronous abort 5000 msec to finish on its own
-            QTimer::singleShot(5000, this, SLOT(abortTimeout()));
-        } else {
-            // No root job, call emitFinished
-            emitFinished(SyncFileItem::NormalError);
+            // We're possibly already in an item's finished stack
+            QMetaObject::invokeMethod(_rootJob.data(), "abort", Qt::QueuedConnection);
        }
+        // abort() of all jobs will likely have already resulted in finished being emitted, but just in case.
+        QMetaObject::invokeMethod(this, "emitFinished", Qt::QueuedConnection, Q_ARG(SyncFileItem::Status, SyncFileItem::NormalError));
    }

    // timeout in seconds
@@ -482,13 +431,6 @@ public:

 private slots:

-    void abortTimeout()
-    {
-        // Abort synchronously and finish
-        _rootJob.data()->abort(PropagatorJob::AbortType::Synchronous);
-        emitFinished(SyncFileItem::NormalError);
-    }
-
    /** Emit the finished signal and make sure it is only emitted once */
    void emitFinished(SyncFileItem::Status status)
    {
--- a/src/libsync/propagatedownload.cpp
+++ b/src/libsync/propagatedownload.cpp
@@ -127,6 +127,7 @@ void GETFileJob::start()
        sendRequest("GET", _directDownloadUrl, req);
    }

+    reply()->setReadBufferSize(16 * 1024); // keep low so we can easier limit the bandwidth
    qCDebug(lcGetJob) << _bandwidthManager << _bandwidthChoked << _bandwidthLimited;
    if (_bandwidthManager) {
        _bandwidthManager->registerDownloadJob(this);
@@ -136,20 +137,14 @@ void GETFileJob::start()
        qCWarning(lcGetJob) << " Network error: " << errorString();
    }

+    connect(reply(), &QNetworkReply::metaDataChanged, this, &GETFileJob::slotMetaDataChanged);
+    connect(reply(), &QIODevice::readyRead, this, &GETFileJob::slotReadyRead);
+    connect(reply(), &QNetworkReply::downloadProgress, this, &GETFileJob::downloadProgress);
    connect(this, &AbstractNetworkJob::networkActivity, account().data(), &Account::propagatorNetworkActivity);

    AbstractNetworkJob::start();
 }

-void GETFileJob::newReplyHook(QNetworkReply *reply)
-{
-    reply->setReadBufferSize(16 * 1024); // keep low so we can easier limit the bandwidth
-
-    connect(reply, &QNetworkReply::metaDataChanged, this, &GETFileJob::slotMetaDataChanged);
-    connect(reply, &QIODevice::readyRead, this, &GETFileJob::slotReadyRead);
-    connect(reply, &QNetworkReply::downloadProgress, this, &GETFileJob::downloadProgress);
-}
-
 void GETFileJob::slotMetaDataChanged()
 {
    // For some reason setting the read buffer in GETFileJob::start doesn't seem to go
@@ -158,10 +153,6 @@ void GETFileJob::slotMetaDataChanged()

    int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

-    // Ignore redirects
-    if (httpStatus == 301 || httpStatus == 302 || httpStatus == 303 || httpStatus == 307 || httpStatus == 308)
-        return;
-
    // If the status code isn't 2xx, don't write the reply body to the file.
    // For any error: handle it when the job is finished, not here.
    if (httpStatus / 100 != 2) {
@@ -225,8 +216,6 @@ void GETFileJob::slotMetaDataChanged()
    if (!lastModified.isNull()) {
        _lastModified = Utility::qDateTimeToTime_t(lastModified.toDateTime());
    }
-
-    _saveBodyToFile = true;
 }

 void GETFileJob::setBandwidthManager(BandwidthManager *bwm)
@@ -292,7 +281,7 @@ void GETFileJob::slotReadyRead()
            return;
        }

-        if (_device->isOpen() && _saveBodyToFile) {
+        if (_device->isOpen()) {
            qint64 w = _device->write(buffer.constData(), r);
            if (w != r) {
                _errorString = _device->errorString();
@@ -357,16 +346,13 @@ void PropagateDownloadFile::start()
        }
    }

-    // If we have a conflict where size of the file is unchanged,
+    // If we have a conflict where size and mtime are identical,
    // compare the remote checksum to the local one.
    // Maybe it's not a real conflict and no download is necessary!
-    // If the hashes are collision safe and identical, we assume the content is too.
-    // For weak checksums, we only do that if the mtimes are also identical.
    if (_item->_instruction == CSYNC_INSTRUCTION_CONFLICT
        && _item->_size == _item->_previousSize
-        && !_item->_checksumHeader.isEmpty()
-        && (csync_is_collision_safe_hash(_item->_checksumHeader)
-            || _item->_modtime == _item->_previousModtime)) {
+        && _item->_modtime == _item->_previousModtime
+        && !_item->_checksumHeader.isEmpty()) {
        qCDebug(lcPropagateDownload) << _item->_file << "may not need download, computing checksum";
        auto computeChecksum = new ComputeChecksum(this);
        computeChecksum->setChecksumType(parseChecksumHeaderType(_item->_checksumHeader));
@@ -382,17 +368,8 @@ void PropagateDownloadFile::start()
 void PropagateDownloadFile::conflictChecksumComputed(const QByteArray &checksumType, const QByteArray &checksum)
 {
    if (makeChecksumHeader(checksumType, checksum) == _item->_checksumHeader) {
-        // No download necessary, just update fs and journal metadata
        qCDebug(lcPropagateDownload) << _item->_file << "remote and local checksum match";
-
-        // Apply the server mtime locally if necessary, ensuring the journal
-        // and local mtimes end up identical
-        auto fn = propagator()->getFilePath(_item->_file);
-        if (_item->_modtime != _item->_previousModtime) {
-            FileSystem::setModTime(fn, _item->_modtime);
-            emit propagator()->touchedFile(fn);
-        }
-        _item->_modtime = FileSystem::getModTime(fn);
+        // No download necessary, just update metadata
        updateMetadata(/*isConflict=*/false);
        return;
    }
@@ -648,9 +625,6 @@ void PropagateDownloadFile::slotGetFinished()
    connect(validator, &ValidateChecksumHeader::validationFailed,
        this, &PropagateDownloadFile::slotChecksumFail);
    auto checksumHeader = job->reply()->rawHeader(checkSumHeaderC);
-    auto contentMd5Header = job->reply()->rawHeader(contentMd5HeaderC);
-    if (checksumHeader.isEmpty() && !contentMd5Header.isEmpty())
-        checksumHeader = "MD5:" + contentMd5Header;
    validator->start(_tmpFile.fileName(), checksumHeader);
 }

@@ -923,13 +897,9 @@ void PropagateDownloadFile::slotDownloadProgress(qint64 received, qint64)
 }


-void PropagateDownloadFile::abort(PropagatorJob::AbortType abortType)
+void PropagateDownloadFile::abort()
 {
    if (_job && _job->reply())
        _job->reply()->abort();
-
-    if (abortType == AbortType::Asynchronous) {
-        emit abortFinished();
-    }
 }
 }
--- a/src/libsync/propagatedownload.h
+++ b/src/libsync/propagatedownload.h
@@ -43,9 +43,6 @@ class GETFileJob : public AbstractNetworkJob
    bool _hasEmittedFinishedSignal;
    time_t _lastModified;

-    /// Will be set to true once we've seen a 2xx response header
-    bool _saveBodyToFile = false;
-
 public:
    // DOES NOT take ownership of the device.
    explicit GETFileJob(AccountPtr account, const QString &path, QFile *device,
@@ -79,8 +76,6 @@ public:
        }
    }

-    void newReplyHook(QNetworkReply *reply) override;
-
    void setBandwidthManager(BandwidthManager *bwm);
    void setChoked(bool c);
    void setBandwidthLimited(bool b);
@@ -190,7 +185,7 @@ private slots:
    /// Called when it's time to update the db metadata
    void updateMetadata(bool isConflict);

-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+    void abort() Q_DECL_OVERRIDE;
    void slotDownloadProgress(qint64, qint64);
    void slotChecksumFail(const QString &errMsg);

--- a/src/libsync/propagateremotedelete.cpp
+++ b/src/libsync/propagateremotedelete.cpp
@@ -75,14 +75,10 @@ void PropagateRemoteDelete::start()
    _job->start();
 }

-void PropagateRemoteDelete::abort(PropagatorJob::AbortType abortType)
+void PropagateRemoteDelete::abort()
 {
    if (_job && _job->reply())
        _job->reply()->abort();
-
-    if (abortType == AbortType::Asynchronous) {
-        emit abortFinished();
-    }
 }

 void PropagateRemoteDelete::slotDeleteJobFinished()
--- a/src/libsync/propagateremotedelete.h
+++ b/src/libsync/propagateremotedelete.h
@@ -52,7 +52,7 @@ public:
    {
    }
    void start() Q_DECL_OVERRIDE;
-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+    void abort() Q_DECL_OVERRIDE;

    bool isLikelyFinishedQuickly() Q_DECL_OVERRIDE { return !_item->isDirectory(); }

--- a/src/libsync/propagateremotemkdir.cpp
+++ b/src/libsync/propagateremotemkdir.cpp
@@ -60,14 +60,10 @@ void PropagateRemoteMkdir::slotStartMkcolJob()
    _job->start();
 }

-void PropagateRemoteMkdir::abort(PropagatorJob::AbortType abortType)
+void PropagateRemoteMkdir::abort()
 {
    if (_job && _job->reply())
        _job->reply()->abort();
-
-    if (abortType == AbortType::Asynchronous) {
-        emit abortFinished();
-    }
 }

 void PropagateRemoteMkdir::setDeleteExisting(bool enabled)
--- a/src/libsync/propagateremotemkdir.h
+++ b/src/libsync/propagateremotemkdir.h
@@ -35,7 +35,7 @@ public:
    {
    }
    void start() Q_DECL_OVERRIDE;
-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+    void abort() Q_DECL_OVERRIDE;

    // Creating a directory should be fast.
    bool isLikelyFinishedQuickly() Q_DECL_OVERRIDE { return true; }
--- a/src/libsync/propagateremotemove.cpp
+++ b/src/libsync/propagateremotemove.cpp
@@ -117,14 +117,10 @@ void PropagateRemoteMove::start()
    _job->start();
 }

-void PropagateRemoteMove::abort(PropagatorJob::AbortType abortType)
+void PropagateRemoteMove::abort()
 {
    if (_job && _job->reply())
        _job->reply()->abort();
-
-    if (abortType == AbortType::Asynchronous) {
-        emit abortFinished();
-    }
 }

 void PropagateRemoteMove::slotMoveJobFinished()
--- a/src/libsync/propagateremotemove.h
+++ b/src/libsync/propagateremotemove.h
@@ -56,7 +56,7 @@ public:
    {
    }
    void start() Q_DECL_OVERRIDE;
-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+    void abort() Q_DECL_OVERRIDE;
    JobParallelism parallelism() Q_DECL_OVERRIDE { return _item->isDirectory() ? WaitForFinished : FullParallelism; }

    /**
--- a/src/libsync/propagateupload.cpp
+++ b/src/libsync/propagateupload.cpp
@@ -558,24 +558,20 @@ void PropagateUploadFileCommon::slotJobDestroyed(QObject *job)
    _jobs.erase(std::remove(_jobs.begin(), _jobs.end(), job), _jobs.end());
 }

-void PropagateUploadFileCommon::abort(PropagatorJob::AbortType abortType)
+void PropagateUploadFileCommon::abort()
 {
    foreach (auto *job, _jobs) {
        if (job->reply()) {
            job->reply()->abort();
        }
    }
-
-    if (abortType == AbortType::Asynchronous) {
-        emit abortFinished();
-    }
 }

 // This function is used whenever there is an error occuring and jobs might be in progress
 void PropagateUploadFileCommon::abortWithError(SyncFileItem::Status status, const QString &error)
 {
    _finished = true;
-    abort(AbortType::Synchronous);
+    abort();
    done(status, error);
 }

@@ -629,33 +625,4 @@ void PropagateUploadFileCommon::finalize()

    done(SyncFileItem::Success);
 }
-
-void PropagateUploadFileCommon::prepareAbort(PropagatorJob::AbortType abortType) {
-    if (!_jobs.empty()) {
-        // Count number of jobs to be aborted asynchronously
-        _abortCount = _jobs.size();
-
-        foreach (AbstractNetworkJob *job, _jobs) {
-            // Check if async abort is requested
-            if (job->reply() && abortType == AbortType::Asynchronous) {
-                // Connect to finished signal of job reply
-                // to asynchonously finish the abort
-                connect(job->reply(), &QNetworkReply::finished, this, &PropagateUploadFileCommon::slotReplyAbortFinished);
-            }
-        }
-    } else if (abortType == AbortType::Asynchronous) {
-        // Empty job list, emit abortFinished immedietaly
-        emit abortFinished();
-    }
-}
-
-void PropagateUploadFileCommon::slotReplyAbortFinished()
-{
-    _abortCount--;
-
-    if (_abortCount == 0) {
-        emit abortFinished();
-    }
-}
-
 }
--- a/src/libsync/propagateupload.h
+++ b/src/libsync/propagateupload.h
@@ -129,11 +129,6 @@ public:
        return true;
    }

-    QIODevice *device()
-    {
-        return _device;
-    }
-
    QString errorString()
    {
        return _errorString.isEmpty() ? AbstractNetworkJob::errorString() : _errorString;
@@ -210,7 +205,6 @@ protected:
    QVector<AbstractNetworkJob *> _jobs; /// network jobs that are currently in transit
    bool _finished BITFIELD(1); /// Tells that all the jobs have been finished
    bool _deleteExisting BITFIELD(1);
-    quint64 _abortCount; /// Keep track of number of aborted items

 // measure the performance of checksum calc and upload
 #ifdef WITH_TESTING
@@ -224,7 +218,6 @@ public:
        : PropagateItemJob(propagator, item)
        , _finished(false)
        , _deleteExisting(false)
-        , _abortCount(0)
    {
    }

@@ -255,20 +248,13 @@ public:
    void abortWithError(SyncFileItem::Status status, const QString &error);

 public slots:
-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+    void abort() Q_DECL_OVERRIDE;
    void slotJobDestroyed(QObject *job);

 private slots:
-    void slotReplyAbortFinished();
    void slotPollFinished();

 protected:
-    /**
-     * Prepares the abort e.g. connects proper signals and slots
-     * to the subjobs to abort asynchronously
-     */
-    void prepareAbort(PropagatorJob::AbortType abortType);
-
    /**
     * Checks whether the current error is one that should reset the whole
     * transfer if it happens too often. If so: Bump UploadInfo::errorCount
@@ -301,15 +287,15 @@ private:
     * In the non-resuming case it is 0.
     * If we are resuming, this is the first chunk we need to send
     */
-    int _startChunk = 0;
+    int _startChunk;
    /**
     * This is the next chunk that we need to send. Starting from 0 even if _startChunk != 0
     * (In other words,  _startChunk + _currentChunk is really the number of the chunk we need to send next)
     * (In other words, _currentChunk is the number of the chunk that we already sent or started sending)
     */
-    int _currentChunk = 0;
-    int _chunkCount = 0; /// Total number of chunks for this file
-    int _transferId = 0; /// transfer id (part of the url)
+    int _currentChunk;
+    int _chunkCount; /// Total number of chunks for this file
+    int _transferId; /// transfer id (part of the url)

    quint64 chunkSize() const {
        // Old chunking does not use dynamic chunking algorithm, and does not adjusts the chunk size respectively,
@@ -317,6 +303,7 @@ private:
        return propagator()->syncOptions()._initialChunkSize;
    }

+
 public:
    PropagateUploadFileV1(OwncloudPropagator *propagator, const SyncFileItemPtr &item)
        : PropagateUploadFileCommon(propagator, item)
@@ -324,8 +311,7 @@ public:
    }

    void doStartUpload() Q_DECL_OVERRIDE;
-public slots:
-    void abort(PropagatorJob::AbortType abortType) Q_DECL_OVERRIDE;
+
 private slots:
    void startNextChunk();
    void slotPutFinished();
@@ -342,11 +328,11 @@ class PropagateUploadFileNG : public PropagateUploadFileCommon
 {
    Q_OBJECT
 private:
-    quint64 _sent = 0; /// amount of data (bytes) that was already sent
-    uint _transferId = 0; /// transfer id (part of the url)
-    int _currentChunk = 0; /// Id of the next chunk that will be sent
-    quint64 _currentChunkSize = 0; /// current chunk size
-    bool _removeJobError = false; /// If not null, there was an error removing the job
+    quint64 _sent; /// amount of data (bytes) that was already sent
+    uint _transferId; /// transfer id (part of the url)
+    int _currentChunk; /// Id of the next chunk that will be sent
+    quint64 _currentChunkSize; /// current chunk size
+    bool _removeJobError; /// If not null, there was an error removing the job

    // Map chunk number with its size  from the PROPFIND on resume.
    // (Only used from slotPropfindIterate/slotPropfindFinished because the LsColJob use signals to report data.)
@@ -366,6 +352,7 @@ private:
 public:
    PropagateUploadFileNG(OwncloudPropagator *propagator, const SyncFileItemPtr &item)
        : PropagateUploadFileCommon(propagator, item)
+        , _currentChunkSize(0)
    {
    }

@@ -374,8 +361,6 @@ public:
 private:
    void startNewUpload();
    void startNextChunk();
-public slots:
-    void abort(AbortType abortType) Q_DECL_OVERRIDE;
 private slots:
    void slotPropfindFinished();
    void slotPropfindFinishedWithError();
--- a/src/libsync/propagateuploadng.cpp
+++ b/src/libsync/propagateuploadng.cpp
@@ -365,7 +365,7 @@ void PropagateUploadFileNG::slotPutFinished()
    // target duration for each chunk upload.
    double targetDuration = propagator()->syncOptions()._targetChunkUploadDuration;
    if (targetDuration > 0) {
-        double uploadTime = job->msSinceStart() + 1; // add one to avoid div-by-zero
+        double uploadTime = job->msSinceStart();

        auto predictedGoodSize = static_cast<quint64>(
            _currentChunkSize / uploadTime * targetDuration);
@@ -491,26 +491,4 @@ void PropagateUploadFileNG::slotUploadProgress(qint64 sent, qint64 total)
    }
    propagator()->reportProgress(*_item, _sent + sent - total);
 }
-
-void PropagateUploadFileNG::abort(PropagatorJob::AbortType abortType)
-{
-    // Prepare abort
-    prepareAbort(abortType);
-
-    // Abort all jobs (if there are any left), except final PUT
-    foreach (AbstractNetworkJob *job, _jobs) {
-        if (job->reply()) {
-            if (abortType == AbortType::Asynchronous && qobject_cast<MoveJob *>(job)){
-                // If it is async abort, dont abort
-                // MoveJob since it might result in conflict,
-                // only PUT and MKDIR jobs can be safely aborted.
-                continue;
-            }
-
-            // Abort the job
-            job->reply()->abort();
-        }
-    }
-}
-
 }
--- a/src/libsync/propagateuploadv1.cpp
+++ b/src/libsync/propagateuploadv1.cpp
@@ -350,31 +350,4 @@ void PropagateUploadFileV1::slotUploadProgress(qint64 sent, qint64 total)
    }
    propagator()->reportProgress(*_item, amount);
 }
-
-void PropagateUploadFileV1::abort(PropagatorJob::AbortType abortType)
-{
-    // Prepare abort
-    prepareAbort(abortType);
-
-    // Abort all jobs (if there are any left), except final PUT
-    foreach (AbstractNetworkJob *job, _jobs) {
-        if (job->reply()) {
-            // If asynchronous abort allowed,
-            // dont abort final PUT which uploaded its data,
-            // since this might result in conflicts
-            if (PUTFileJob *putJob = qobject_cast<PUTFileJob *>(job)){
-                if (abortType == AbortType::Asynchronous
-                    && _chunkCount > 0
-                    && (((_currentChunk + _startChunk) % _chunkCount) == 0)
-                    && putJob->device()->atEnd()) {
-                    continue;
-                }
-            }
-
-            // Abort the job
-            job->reply()->abort();
-        }
-    }
-}
-
 }
--- a/src/libsync/propagatorjobs.h
+++ b/src/libsync/propagatorjobs.h
@@ -25,7 +25,6 @@ namespace OCC {
 * It's here for being shared between Upload- and Download Job
 */
 static const char checkSumHeaderC[] = "OC-Checksum";
-static const char contentMd5HeaderC[] = "Content-MD5";

 /**
 * @brief Declaration of the other propagation jobs
--- a/src/libsync/syncengine.cpp
+++ b/src/libsync/syncengine.cpp
@@ -571,6 +571,7 @@ int SyncEngine::treewalkFile(csync_file_stat_t *file, csync_file_stat_t *other,
        dir = SyncFileItem::None;
        // For directories, metadata-only updates will be done after all their files are propagated.
        if (!isDirectory) {
+            emit syncItemDiscovered(*item);

            // Update the database now already:  New remote fileid or Etag or RemotePerm
            // Or for files that were detected as "resolved conflict".
@@ -607,9 +608,6 @@ int SyncEngine::treewalkFile(csync_file_stat_t *file, csync_file_stat_t *other,
                }

                _journal->setFileRecordMetadata(item->toSyncJournalFileRecordWithInode(filePath));
-
-                // This might have changed the shared flag, so we must notify SyncFileStatusTracker for example
-                emit itemCompleted(item);
            } else {
                // The local tree is walked first and doesn't have all the info from the server.
                // Update only outdated data from the disk.
@@ -685,6 +683,8 @@ int SyncEngine::treewalkFile(csync_file_stat_t *file, csync_file_stat_t *other,
    }

    _syncItemMap.insert(key, item);
+
+    emit syncItemDiscovered(*item);
    return re;
 }

@@ -960,20 +960,11 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
    }

    // Check for invalid character in old server version
-    QString invalidFilenamePattern = _account->capabilities().invalidFilenameRegex();
-    if (invalidFilenamePattern.isNull()
-        && _account->serverVersionInt() < Account::makeServerVersion(8, 1, 0)) {
-        // Server versions older than 8.1 don't support some characters in filenames.
-        // If the capability is not set, default to a pattern that avoids uploading
-        // files with names that contain these.
-        // It's important to respect the capability also for older servers -- the
-        // version check doesn't make sense for custom servers.
-        invalidFilenamePattern = "[\\\\:?*\"<>|]";
-    }
-    if (!invalidFilenamePattern.isEmpty()) {
-        const QRegExp invalidFilenameRx(invalidFilenamePattern);
+    if (_account->serverVersionInt() < Account::makeServerVersion(8, 1, 0)) {
+        // Server version older than 8.1 don't support these character in filename.
+        static const QRegExp invalidCharRx("[\\\\:?*\"<>|]");
        for (auto it = syncItems.begin(); it != syncItems.end(); ++it) {
-            if ((*it)->_direction == SyncFileItem::Up && (*it)->destination().contains(invalidFilenameRx)) {
+            if ((*it)->_direction == SyncFileItem::Up && (*it)->destination().contains(invalidCharRx)) {
                (*it)->_errorString = tr("File name contains at least one invalid character");
                (*it)->_instruction = CSYNC_INSTRUCTION_IGNORE;
            }
@@ -1031,7 +1022,7 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
    _progressInfo->startEstimateUpdates();

    // post update phase script: allow to tweak stuff by a custom script in debug mode.
-    if (!qEnvironmentVariableIsEmpty("OWNCLOUD_POST_UPDATE_SCRIPT")) {
+    if (!qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT").isEmpty()) {
 #ifndef NDEBUG
        QString script = qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT");

@@ -1464,7 +1455,7 @@ void SyncEngine::checkForPermission(SyncFileItemVector &syncItems)

 RemotePermissions SyncEngine::getPermissions(const QString &file) const
 {
-    static bool isTest = qEnvironmentVariableIntValue("OWNCLOUD_TEST_PERMISSIONS");
+    static bool isTest = qgetenv("OWNCLOUD_TEST_PERMISSIONS").toInt();
    if (isTest) {
        QRegExp rx("_PERM_([^_]*)_[^/]*$");
        if (rx.indexIn(file) != -1) {
--- a/src/libsync/syncengine.h
+++ b/src/libsync/syncengine.h
@@ -105,6 +105,8 @@ signals:
    // During update, before reconcile
    void rootEtag(QString);

+    // before actual syncing (after update+reconcile) for each item
+    void syncItemDiscovered(const SyncFileItem &);
    // after the above signals. with the items that actually need propagating
    void aboutToPropagate(SyncFileItemVector &);

--- a/src/libsync/theme.cpp
+++ b/src/libsync/theme.cpp
@@ -428,15 +428,7 @@ QPixmap Theme::wizardHeaderBanner() const
    if (!c.isValid())
        return QPixmap();

-    QSize size(750, 78);
-    if (auto screen = qApp->primaryScreen()) {
-        // Adjust the the size if there is a different DPI. (Issue #6156)
-        // Indeed, this size need to be big enough to for the banner height, and the wizard's width
-        auto ratio = screen->logicalDotsPerInch() / 96.;
-        if (ratio > 1.)
-            size *= ratio;
-    }
-    QPixmap pix(size);
+    QPixmap pix(QSize(750, 78));
    pix.fill(wizardHeaderBackgroundColor());
    return pix;
 }
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -46,7 +46,6 @@ owncloud_add_test(ExcludedFiles "")
 owncloud_add_test(FileSystem "")
 owncloud_add_test(Utility "")
 owncloud_add_test(SyncEngine "syncenginetestutils.h")
-owncloud_add_test(SyncMove "syncenginetestutils.h")
 owncloud_add_test(SyncFileStatusTracker "syncenginetestutils.h")
 owncloud_add_test(ChunkingNg "syncenginetestutils.h")
 owncloud_add_test(UploadReset "syncenginetestutils.h")
--- a/test/scripts/txpl/t9.pl
+++ b/test/scripts/txpl/t9.pl
@@ -48,7 +48,6 @@ assert($txtpropbefore);
 assert($emlpropbefore);

 printInfo( "Touch local files");
-system( "sleep 1" );
 system( "touch $locDir/test.txt" );
 system( "touch $locDir/test.eml" );

--- a/test/syncenginetestutils.h
+++ b/test/syncenginetestutils.h
@@ -161,15 +161,12 @@ public:
    FileInfo(const QString &name, qint64 size) : name{name}, isDir{false}, size{size} { }
    FileInfo(const QString &name, qint64 size, char contentChar) : name{name}, isDir{false}, size{size}, contentChar{contentChar} { }
    FileInfo(const QString &name, const std::initializer_list<FileInfo> &children) : name{name} {
-        for (const auto &source : children)
-            addChild(source);
-    }
-
-    void addChild(const FileInfo &info)
-    {
-        auto &dest = this->children[info.name] = info;
-        dest.parentPath = path();
-        dest.fixupParentPathRecursively();
+        QString p = path();
+        for (const auto &source : children) {
+            auto &dest = this->children[source.name] = source;
+            dest.parentPath = p;
+            dest.fixupParentPathRecursively();
+        }
    }

    void remove(const QString &relativePath) override {
@@ -436,8 +433,6 @@ public:
            abort();
            return;
        }
-        fileInfo->lastModified = OCC::Utility::qDateTimeFromTime_t(request.rawHeader("X-OC-Mtime").toLongLong());
-        remoteRootFileInfo.find(fileName, /*invalidate_etags=*/true);
        QMetaObject::invokeMethod(this, "respond", Qt::QueuedConnection);
    }

@@ -602,9 +597,6 @@ public:
        size -= len;
        return len;
    }
-
-    // useful to be public for testing
-    using QNetworkReply::setRawHeader;
 };


@@ -614,10 +606,8 @@ class FakeChunkMoveReply : public QNetworkReply
    FileInfo *fileInfo;
 public:
    FakeChunkMoveReply(FileInfo &uploadsFileInfo, FileInfo &remoteRootFileInfo,
-        QNetworkAccessManager::Operation op, const QNetworkRequest &request,
-        quint64 delayMs, QObject *parent)
-        : QNetworkReply{ parent }
-    {
+                       QNetworkAccessManager::Operation op, const QNetworkRequest &request,
+                       QObject *parent) : QNetworkReply{parent} {
        setRequest(request);
        setUrl(request.url());
        setOperation(op);
@@ -672,10 +662,7 @@ public:
            abort();
            return;
        }
-        fileInfo->lastModified = OCC::Utility::qDateTimeFromTime_t(request.rawHeader("X-OC-Mtime").toLongLong());
-        remoteRootFileInfo.find(fileName, /*invalidate_etags=*/true);
-
-        QTimer::singleShot(delayMs, this, &FakeChunkMoveReply::respond);
+        QMetaObject::invokeMethod(this, "respond", Qt::QueuedConnection);
    }

    Q_INVOKABLE void respond() {
@@ -726,24 +713,6 @@ public:
    int _httpErrorCode;
 };

-// A reply that never responds
-class FakeHangingReply : public QNetworkReply
-{
-    Q_OBJECT
-public:
-    FakeHangingReply(QNetworkAccessManager::Operation op, const QNetworkRequest &request, QObject *parent)
-        : QNetworkReply(parent)
-    {
-        setRequest(request);
-        setUrl(request.url());
-        setOperation(op);
-        open(QIODevice::ReadOnly);
-    }
-
-    void abort() override {}
-    qint64 readData(char *, qint64) override { return 0; }
-};
-
 class FakeQNAM : public QNetworkAccessManager
 {
 public:
@@ -796,7 +765,7 @@ protected:
        else if (verb == QLatin1String("MOVE") && !isUpload)
            return new FakeMoveReply{info, op, request, this};
        else if (verb == QLatin1String("MOVE") && isUpload)
-            return new FakeChunkMoveReply{ info, _remoteRootFileInfo, op, request, 0, this };
+            return new FakeChunkMoveReply{info, _remoteRootFileInfo, op, request, this};
        else {
            qDebug() << verb << outgoingData;
            Q_UNREACHABLE();
@@ -955,11 +924,6 @@ private:
            } else {
                QFile f{diskChild.filePath()};
                f.open(QFile::ReadOnly);
-                auto content = f.read(1);
-                if (content.size() == 0) {
-                    qWarning() << "Empty file at:" << diskChild.filePath();
-                    continue;
-                }
                char contentChar = f.read(1).at(0);
                templateFi.children.insert(diskChild.fileName(), FileInfo{diskChild.fileName(), diskChild.size(), contentChar});
            }
--- a/test/testchunkingng.cpp
+++ b/test/testchunkingng.cpp
@@ -85,136 +85,6 @@ private slots:
        QCOMPARE(fakeFolder.uploadState().children.first().name, chunkingId);
    }

-    // Check what happens when we abort during the final MOVE and the
-    // the final MOVE takes longer than the abort-delay
-    void testLateAbortHard()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        fakeFolder.syncEngine().account()->setCapabilities({ { "dav", QVariantMap{ { "chunking", "1.0" } } }, { "checksums", QVariantMap{ { "supportedTypes", QStringList() << "SHA1" } } } });
-        const int size = 150 * 1000 * 1000;
-
-        // Make the MOVE never reply, but trigger a client-abort and apply the change remotely
-        auto parent = new QObject;
-        QByteArray moveChecksumHeader;
-        int nGET = 0;
-        int responseDelay = 10000; // bigger than abort-wait timeout
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &request) -> QNetworkReply * {
-            if (request.attribute(QNetworkRequest::CustomVerbAttribute) == "MOVE") {
-                QTimer::singleShot(50, parent, [&]() { fakeFolder.syncEngine().abort(); });
-                moveChecksumHeader = request.rawHeader("OC-Checksum");
-                return new FakeChunkMoveReply(fakeFolder.uploadState(), fakeFolder.remoteModifier(), op, request, responseDelay, parent);
-            } else if (op == QNetworkAccessManager::GetOperation) {
-                nGET++;
-            }
-            return nullptr;
-        });
-
-
-        // Test 1: NEW file aborted
-        fakeFolder.localModifier().insert("A/a0", size);
-        QVERIFY(!fakeFolder.syncOnce()); // error: abort!
-
-        // Now the next sync gets a NEW/NEW conflict and since there's no checksum
-        // it just becomes a UPDATE_METADATA
-        auto checkEtagUpdated = [&](SyncFileItemVector &items) {
-            QCOMPARE(items.size(), 1);
-            QCOMPARE(items[0]->_file, QLatin1String("A"));
-            SyncJournalFileRecord record;
-            QVERIFY(fakeFolder.syncJournal().getFileRecord(QByteArray("A/a0"), &record));
-            QCOMPARE(record._etag, fakeFolder.remoteModifier().find("A/a0")->etag.toUtf8());
-        };
-        auto connection = connect(&fakeFolder.syncEngine(), &SyncEngine::aboutToPropagate, checkEtagUpdated);
-        QVERIFY(fakeFolder.syncOnce());
-        disconnect(connection);
-        QCOMPARE(nGET, 0);
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-
-        // Test 2: modified file upload aborted
-        fakeFolder.localModifier().appendByte("A/a0");
-        QVERIFY(!fakeFolder.syncOnce()); // error: abort!
-
-        // An EVAL/EVAL conflict is also UPDATE_METADATA when there's no checksums
-        connection = connect(&fakeFolder.syncEngine(), &SyncEngine::aboutToPropagate, checkEtagUpdated);
-        QVERIFY(fakeFolder.syncOnce());
-        disconnect(connection);
-        QCOMPARE(nGET, 0);
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-
-        // Test 3: modified file upload aborted, with good checksums
-        fakeFolder.localModifier().appendByte("A/a0");
-        QVERIFY(!fakeFolder.syncOnce()); // error: abort!
-
-        // Set the remote checksum -- the test setup doesn't do it automatically
-        QVERIFY(!moveChecksumHeader.isEmpty());
-        fakeFolder.remoteModifier().find("A/a0")->checksums = moveChecksumHeader;
-
-        // This time it's a real conflict, we have a remote checksum!
-        connection = connect(&fakeFolder.syncEngine(), &SyncEngine::aboutToPropagate, [&](SyncFileItemVector &items) {
-            SyncFileItemPtr a0;
-            for (auto &item : items) {
-                if (item->_file == "A/a0")
-                    a0 = item;
-            }
-
-            QVERIFY(a0);
-            QCOMPARE(a0->_instruction, CSYNC_INSTRUCTION_CONFLICT);
-        });
-        QVERIFY(fakeFolder.syncOnce());
-        disconnect(connection);
-        QCOMPARE(nGET, 0); // no new download, just a metadata update!
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-
-        // Test 4: New file, that gets deleted locally before the next sync
-        fakeFolder.localModifier().insert("A/a3", size);
-        QVERIFY(!fakeFolder.syncOnce()); // error: abort!
-        fakeFolder.localModifier().remove("A/a3");
-
-        // bug: in this case we must expect a re-download of A/A3
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(nGET, 1);
-        QVERIFY(fakeFolder.currentLocalState().find("A/a3"));
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-    }
-
-    // Check what happens when we abort during the final MOVE and the
-    // the final MOVE is short enough for the abort-delay to help
-    void testLateAbortRecoverable()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        fakeFolder.syncEngine().account()->setCapabilities({ { "dav", QVariantMap{ { "chunking", "1.0" } } }, { "checksums", QVariantMap{ { "supportedTypes", QStringList() << "SHA1" } } } });
-        const int size = 150 * 1000 * 1000;
-
-        // Make the MOVE never reply, but trigger a client-abort and apply the change remotely
-        auto parent = new QObject;
-        QByteArray moveChecksumHeader;
-        int nGET = 0;
-        int responseDelay = 2000; // smaller than abort-wait timeout
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &request) -> QNetworkReply * {
-            if (request.attribute(QNetworkRequest::CustomVerbAttribute) == "MOVE") {
-                QTimer::singleShot(50, parent, [&]() { fakeFolder.syncEngine().abort(); });
-                moveChecksumHeader = request.rawHeader("OC-Checksum");
-                return new FakeChunkMoveReply(fakeFolder.uploadState(), fakeFolder.remoteModifier(), op, request, responseDelay, parent);
-            } else if (op == QNetworkAccessManager::GetOperation) {
-                nGET++;
-            }
-            return nullptr;
-        });
-
-
-        // Test 1: NEW file aborted
-        fakeFolder.localModifier().insert("A/a0", size);
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // Test 2: modified file upload aborted
-        fakeFolder.localModifier().appendByte("A/a0");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-    }
-
    // We modify the file locally after it has been partially uploaded
    void testRemoveStale1() {

--- a/test/testsyncengine.cpp
+++ b/test/testsyncengine.cpp
@@ -16,7 +16,7 @@ bool itemDidComplete(const QSignalSpy &spy, const QString &path)
    for(const QList<QVariant> &args : spy) {
        auto item = args[0].value<SyncFileItemPtr>();
        if (item->destination() == path)
-            return item->_instruction != CSYNC_INSTRUCTION_NONE && item->_instruction != CSYNC_INSTRUCTION_UPDATE_METADATA;
+            return true;
    }
    return false;
 }
@@ -141,6 +141,98 @@ private slots:
        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
    }

+    void testRemoteChangeInMovedFolder() {
+        // issue #5192
+        FakeFolder fakeFolder{FileInfo{ QString(), {
+            FileInfo { QStringLiteral("folder"), {
+                FileInfo{ QStringLiteral("folderA"), { { QStringLiteral("file.txt"), 400 } } },
+                QStringLiteral("folderB")
+            }
+        }}}};
+
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+
+        // Edit a file in a moved directory.
+        fakeFolder.remoteModifier().setContents("folder/folderA/file.txt", 'a');
+        fakeFolder.remoteModifier().rename("folder/folderA", "folder/folderB/folderA");
+        fakeFolder.syncOnce();
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+        auto oldState = fakeFolder.currentLocalState();
+        QVERIFY(oldState.find("folder/folderB/folderA/file.txt"));
+        QVERIFY(!oldState.find("folder/folderA/file.txt"));
+
+        // This sync should not remove the file
+        fakeFolder.syncOnce();
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+        QCOMPARE(fakeFolder.currentLocalState(), oldState);
+
+    }
+
+    void testSelectiveSyncModevFolder() {
+        // issue #5224
+        FakeFolder fakeFolder{FileInfo{ QString(), {
+            FileInfo { QStringLiteral("parentFolder"), {
+                FileInfo{ QStringLiteral("subFolderA"), { { QStringLiteral("fileA.txt"), 400 } } },
+                FileInfo{ QStringLiteral("subFolderB"), { { QStringLiteral("fileB.txt"), 400 } } }
+            }
+        }}}};
+
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+        auto expectedServerState = fakeFolder.currentRemoteState();
+
+        // Remove subFolderA with selectiveSync:
+        fakeFolder.syncEngine().journal()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList,
+                                                                {"parentFolder/subFolderA/"});
+        fakeFolder.syncEngine().journal()->avoidReadFromDbOnNextSync(QByteArrayLiteral("parentFolder/subFolderA/"));
+
+        fakeFolder.syncOnce();
+
+        {
+            // Nothing changed on the server
+            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
+            // The local state should not have subFolderA
+            auto remoteState = fakeFolder.currentRemoteState();
+            remoteState.remove("parentFolder/subFolderA");
+            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
+        }
+
+        // Rename parentFolder on the server
+        fakeFolder.remoteModifier().rename("parentFolder", "parentFolderRenamed");
+        expectedServerState = fakeFolder.currentRemoteState();
+        fakeFolder.syncOnce();
+
+        {
+            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
+            auto remoteState = fakeFolder.currentRemoteState();
+            // The subFolderA should still be there on the server.
+            QVERIFY(remoteState.find("parentFolderRenamed/subFolderA/fileA.txt"));
+            // But not on the client because of the selective sync
+            remoteState.remove("parentFolderRenamed/subFolderA");
+            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
+        }
+
+        // Rename it again, locally this time.
+        fakeFolder.localModifier().rename("parentFolderRenamed", "parentThirdName");
+        fakeFolder.syncOnce();
+
+        {
+            auto remoteState = fakeFolder.currentRemoteState();
+            // The subFolderA should still be there on the server.
+            QVERIFY(remoteState.find("parentThirdName/subFolderA/fileA.txt"));
+            // But not on the client because of the selective sync
+            remoteState.remove("parentThirdName/subFolderA");
+            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
+
+            expectedServerState = fakeFolder.currentRemoteState();
+            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
+            fakeFolder.syncOnce(); // This sync should do nothing
+            QCOMPARE(completeSpy.count(), 0);
+
+            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
+            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
+        }
+    }
+
    void testSelectiveSyncBug() {
        // issue owncloud/enterprise#1965: files from selective-sync ignored
        // folders are uploaded anyway is some circumstances.
@@ -251,53 +343,8 @@ private slots:
        }
    }

-    void testFakeConflict_data()
-    {
-        QTest::addColumn<bool>("sameMtime");
-        QTest::addColumn<QByteArray>("checksums");
-
-        QTest::addColumn<int>("expectedGET");
-
-        QTest::newRow("Same mtime, but no server checksum -> ignored in reconcile")
-            << true << QByteArray()
-            << 0;
-
-        QTest::newRow("Same mtime, weak server checksum differ -> downloaded")
-            << true << QByteArray("Adler32:bad")
-            << 1;
-
-        QTest::newRow("Same mtime, matching weak checksum -> skipped")
-            << true << QByteArray("Adler32:2a2010d")
-            << 0;
-
-        QTest::newRow("Same mtime, strong server checksum differ -> downloaded")
-            << true << QByteArray("SHA1:bad")
-            << 1;
-
-        QTest::newRow("Same mtime, matching strong checksum -> skipped")
-            << true << QByteArray("SHA1:56900fb1d337cf7237ff766276b9c1e8ce507427")
-            << 0;
-
-
-        QTest::newRow("mtime changed, but no server checksum -> download")
-            << false << QByteArray()
-            << 1;
-
-        QTest::newRow("mtime changed, weak checksum match -> download anyway")
-            << false << QByteArray("Adler32:2a2010d")
-            << 1;
-
-        QTest::newRow("mtime changed, strong checksum match -> skip")
-            << false << QByteArray("SHA1:56900fb1d337cf7237ff766276b9c1e8ce507427")
-            << 0;
-    }
-
    void testFakeConflict()
    {
-        QFETCH(bool, sameMtime);
-        QFETCH(QByteArray, checksums);
-        QFETCH(int, expectedGET);
-
        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };

        int nGET = 0;
@@ -314,25 +361,51 @@ private slots:
        auto mtime = QDateTime::currentDateTimeUtc().addDays(-4);
        mtime.setMSecsSinceEpoch(mtime.toMSecsSinceEpoch() / 1000 * 1000);

+        // Conflict: Same content, mtime, but no server checksum
+        //           -> ignored in reconcile
        fakeFolder.localModifier().setContents("A/a1", 'C');
        fakeFolder.localModifier().setModTime("A/a1", mtime);
        fakeFolder.remoteModifier().setContents("A/a1", 'C');
-        if (!sameMtime)
-            mtime = mtime.addDays(1);
        fakeFolder.remoteModifier().setModTime("A/a1", mtime);
-        remoteInfo.find("A/a1")->checksums = checksums;
        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(nGET, expectedGET);
+        QCOMPARE(nGET, 0);

-        // check that mtime in journal and filesystem agree
-        QString a1path = fakeFolder.localPath() + "A/a1";
-        SyncJournalFileRecord a1record;
-        fakeFolder.syncJournal().getFileRecord(QByteArray("A/a1"), &a1record);
-        QCOMPARE(a1record._modtime, (qint64)FileSystem::getModTime(a1path));
+        // Conflict: Same content, mtime, but weak server checksum
+        //           -> ignored in reconcile
+        mtime = mtime.addDays(1);
+        fakeFolder.localModifier().setContents("A/a1", 'D');
+        fakeFolder.localModifier().setModTime("A/a1", mtime);
+        fakeFolder.remoteModifier().setContents("A/a1", 'D');
+        fakeFolder.remoteModifier().setModTime("A/a1", mtime);
+        remoteInfo.find("A/a1")->checksums = "Adler32:bad";
+        QVERIFY(fakeFolder.syncOnce());
+        QCOMPARE(nGET, 0);
+
+        // Conflict: Same content, mtime, but server checksum differs
+        //           -> downloaded
+        mtime = mtime.addDays(1);
+        fakeFolder.localModifier().setContents("A/a1", 'W');
+        fakeFolder.localModifier().setModTime("A/a1", mtime);
+        fakeFolder.remoteModifier().setContents("A/a1", 'W');
+        fakeFolder.remoteModifier().setModTime("A/a1", mtime);
+        remoteInfo.find("A/a1")->checksums = "SHA1:bad";
+        QVERIFY(fakeFolder.syncOnce());
+        QCOMPARE(nGET, 1);
+
+        // Conflict: Same content, mtime, matching checksums
+        //           -> PropagateDownload, but it skips the download
+        mtime = mtime.addDays(1);
+        fakeFolder.localModifier().setContents("A/a1", 'C');
+        fakeFolder.localModifier().setModTime("A/a1", mtime);
+        fakeFolder.remoteModifier().setContents("A/a1", 'C');
+        fakeFolder.remoteModifier().setModTime("A/a1", mtime);
+        remoteInfo.find("A/a1")->checksums = "SHA1:56900fb1d337cf7237ff766276b9c1e8ce507427";
+        QVERIFY(fakeFolder.syncOnce());
+        QCOMPARE(nGET, 1);

        // Extra sync reads from db, no difference
        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(nGET, expectedGET);
+        QCOMPARE(nGET, 1);
    }

    /**
@@ -462,116 +535,6 @@ private slots:
        QCOMPARE(nPUT, 6);
        QCOMPARE(n507, 3);
    }
-
-    // Checks whether downloads with bad checksums are accepted
-    void testChecksumValidation()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        QObject parent;
-
-        QByteArray checksumValue;
-        QByteArray contentMd5Value;
-
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &request) -> QNetworkReply * {
-            if (op == QNetworkAccessManager::GetOperation) {
-                auto reply = new FakeGetReply(fakeFolder.remoteModifier(), op, request, &parent);
-                if (!checksumValue.isNull())
-                    reply->setRawHeader("OC-Checksum", checksumValue);
-                if (!contentMd5Value.isNull())
-                    reply->setRawHeader("Content-MD5", contentMd5Value);
-                return reply;
-            }
-            return nullptr;
-        });
-
-        // Basic case
-        fakeFolder.remoteModifier().create("A/a3", 16, 'A');
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // Bad OC-Checksum
-        checksumValue = "SHA1:bad";
-        fakeFolder.remoteModifier().create("A/a4", 16, 'A');
-        QVERIFY(!fakeFolder.syncOnce());
-
-        // Good OC-Checksum
-        checksumValue = "SHA1:19b1928d58a2030d08023f3d7054516dbc186f20"; // printf 'A%.0s' {1..16} | sha1sum -
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        checksumValue = QByteArray();
-
-        // Bad Content-MD5
-        contentMd5Value = "bad";
-        fakeFolder.remoteModifier().create("A/a5", 16, 'A');
-        QVERIFY(!fakeFolder.syncOnce());
-
-        // Good Content-MD5
-        contentMd5Value = "d8a73157ce10cd94a91c2079fc9a92c8"; // printf 'A%.0s' {1..16} | md5sum -
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // OC-Checksum has preference
-        checksumValue = "garbage";
-        // contentMd5Value is still good
-        fakeFolder.remoteModifier().create("A/a6", 16, 'A');
-        QVERIFY(!fakeFolder.syncOnce());
-    }
-
-    // Tests the behavior of invalid filename detection
-    void testInvalidFilenameRegex()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-
-        // For current servers, no characters are forbidden
-        fakeFolder.syncEngine().account()->setServerVersion("10.0.0");
-        fakeFolder.localModifier().insert("A/\\:?*\"<>|.txt");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // For legacy servers, some characters were forbidden by the client
-        fakeFolder.syncEngine().account()->setServerVersion("8.0.0");
-        fakeFolder.localModifier().insert("B/\\:?*\"<>|.txt");
-        QVERIFY(fakeFolder.syncOnce());
-        QVERIFY(!fakeFolder.currentRemoteState().find("B/\\:?*\"<>|.txt"));
-
-        // We can override that by setting the capability
-        fakeFolder.syncEngine().account()->setCapabilities({ { "dav", QVariantMap{ { "invalidFilenameRegex", "" } } } });
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // Check that new servers also accept the capability
-        fakeFolder.syncEngine().account()->setServerVersion("10.0.0");
-        fakeFolder.syncEngine().account()->setCapabilities({ { "dav", QVariantMap{ { "invalidFilenameRegex", "my[fgh]ile" } } } });
-        fakeFolder.localModifier().insert("C/myfile.txt");
-        QVERIFY(fakeFolder.syncOnce());
-        QVERIFY(!fakeFolder.currentRemoteState().find("C/myfile.txt"));
-    }
-
-    void testDiscoveryHiddenFile()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // We can't depend on currentLocalState for hidden files since
-        // it should rightfully skip things like download temporaries
-        auto localFileExists = [&](QString name) {
-            return QFileInfo(fakeFolder.localPath() + name).exists();
-        };
-
-        fakeFolder.syncEngine().setIgnoreHiddenFiles(true);
-        fakeFolder.remoteModifier().insert("A/.hidden");
-        fakeFolder.localModifier().insert("B/.hidden");
-        QVERIFY(fakeFolder.syncOnce());
-        QVERIFY(!localFileExists("A/.hidden"));
-        QVERIFY(!fakeFolder.currentRemoteState().find("B/.hidden"));
-
-        fakeFolder.syncEngine().setIgnoreHiddenFiles(false);
-        fakeFolder.syncJournal().forceRemoteDiscoveryNextSync();
-        QVERIFY(fakeFolder.syncOnce());
-        QVERIFY(localFileExists("A/.hidden"));
-        QVERIFY(fakeFolder.currentRemoteState().find("B/.hidden"));
-    }
 };

 QTEST_GUILESS_MAIN(TestSyncEngine)
--- a/test/testsyncfilestatustracker.cpp
+++ b/test/testsyncfilestatustracker.cpp
@@ -436,8 +436,6 @@ private slots:
        fakeFolder.remoteModifier().appendByte("S/s1");
        fakeFolder.remoteModifier().insert("B/b3");
        fakeFolder.remoteModifier().find("B/b3")->extraDavProperties = "<oc:share-types><oc:share-type>0</oc:share-type></oc:share-types>";
-        fakeFolder.remoteModifier().find("A/a1")->isShared = true; // becomes shared
-        fakeFolder.remoteModifier().find("A", true); // change the etags of the parent

        StatusPushSpy statusSpy(fakeFolder.syncEngine());

@@ -460,7 +458,6 @@ private slots:
        QCOMPARE(statusSpy.statusOf("S/s1"), sharedUpToDateStatus);
        QCOMPARE(statusSpy.statusOf("B/b1").shared(), false);
        QCOMPARE(statusSpy.statusOf("B/b3"), sharedUpToDateStatus);
-        QCOMPARE(statusSpy.statusOf("A/a1"), sharedUpToDateStatus);

        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
    }
--- a/test/testsyncmove.cpp
+++ b/test/testsyncmove.cpp
@@ -1,569 +0,0 @@
-/*
- *    This software is in the public domain, furnished "as is", without technical
- *    support, and with no warranty, express or implied, as to its usefulness for
- *    any purpose.
- *
- */
-
-#include <QtTest>
-#include "syncenginetestutils.h"
-#include <syncengine.h>
-
-using namespace OCC;
-
-SyncFileItemPtr findItem(const QSignalSpy &spy, const QString &path)
-{
-    for (const QList<QVariant> &args : spy) {
-        auto item = args[0].value<SyncFileItemPtr>();
-        if (item->destination() == path)
-            return item;
-    }
-    return SyncFileItemPtr(new SyncFileItem);
-}
-
-bool itemSuccessful(const QSignalSpy &spy, const QString &path, const csync_instructions_e instr)
-{
-    auto item = findItem(spy, path);
-    return item->_status == SyncFileItem::Success && item->_instruction == instr;
-}
-
-bool itemConflict(const QSignalSpy &spy, const QString &path)
-{
-    auto item = findItem(spy, path);
-    return item->_status == SyncFileItem::Conflict && item->_instruction == CSYNC_INSTRUCTION_CONFLICT;
-}
-
-bool itemSuccessfulMove(const QSignalSpy &spy, const QString &path)
-{
-    return itemSuccessful(spy, path, CSYNC_INSTRUCTION_RENAME);
-}
-
-QStringList findConflicts(const FileInfo &dir)
-{
-    QStringList conflicts;
-    for (const auto &item : dir.children) {
-        if (item.name.contains("conflict")) {
-            conflicts.append(item.path());
-        }
-    }
-    return conflicts;
-}
-
-bool expectAndWipeConflict(FileModifier &local, FileInfo state, const QString path)
-{
-    PathComponents pathComponents(path);
-    auto base = state.find(pathComponents.parentDirComponents());
-    if (!base)
-        return false;
-    for (const auto &item : base->children) {
-        if (item.name.startsWith(pathComponents.fileName()) && item.name.contains("_conflict")) {
-            local.remove(item.path());
-            return true;
-        }
-    }
-    return false;
-}
-
-class TestSyncMove : public QObject
-{
-    Q_OBJECT
-
-private slots:
-    void testRemoteChangeInMovedFolder()
-    {
-        // issue #5192
-        FakeFolder fakeFolder{ FileInfo{ QString(), { FileInfo{ QStringLiteral("folder"), { FileInfo{ QStringLiteral("folderA"), { { QStringLiteral("file.txt"), 400 } } }, QStringLiteral("folderB") } } } } };
-
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        // Edit a file in a moved directory.
-        fakeFolder.remoteModifier().setContents("folder/folderA/file.txt", 'a');
-        fakeFolder.remoteModifier().rename("folder/folderA", "folder/folderB/folderA");
-        fakeFolder.syncOnce();
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        auto oldState = fakeFolder.currentLocalState();
-        QVERIFY(oldState.find("folder/folderB/folderA/file.txt"));
-        QVERIFY(!oldState.find("folder/folderA/file.txt"));
-
-        // This sync should not remove the file
-        fakeFolder.syncOnce();
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(fakeFolder.currentLocalState(), oldState);
-    }
-
-    void testSelectiveSyncMovedFolder()
-    {
-        // issue #5224
-        FakeFolder fakeFolder{ FileInfo{ QString(), { FileInfo{ QStringLiteral("parentFolder"), { FileInfo{ QStringLiteral("subFolderA"), { { QStringLiteral("fileA.txt"), 400 } } }, FileInfo{ QStringLiteral("subFolderB"), { { QStringLiteral("fileB.txt"), 400 } } } } } } } };
-
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        auto expectedServerState = fakeFolder.currentRemoteState();
-
-        // Remove subFolderA with selectiveSync:
-        fakeFolder.syncEngine().journal()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList,
-            { "parentFolder/subFolderA/" });
-        fakeFolder.syncEngine().journal()->avoidReadFromDbOnNextSync(QByteArrayLiteral("parentFolder/subFolderA/"));
-
-        fakeFolder.syncOnce();
-
-        {
-            // Nothing changed on the server
-            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
-            // The local state should not have subFolderA
-            auto remoteState = fakeFolder.currentRemoteState();
-            remoteState.remove("parentFolder/subFolderA");
-            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
-        }
-
-        // Rename parentFolder on the server
-        fakeFolder.remoteModifier().rename("parentFolder", "parentFolderRenamed");
-        expectedServerState = fakeFolder.currentRemoteState();
-        fakeFolder.syncOnce();
-
-        {
-            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
-            auto remoteState = fakeFolder.currentRemoteState();
-            // The subFolderA should still be there on the server.
-            QVERIFY(remoteState.find("parentFolderRenamed/subFolderA/fileA.txt"));
-            // But not on the client because of the selective sync
-            remoteState.remove("parentFolderRenamed/subFolderA");
-            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
-        }
-
-        // Rename it again, locally this time.
-        fakeFolder.localModifier().rename("parentFolderRenamed", "parentThirdName");
-        fakeFolder.syncOnce();
-
-        {
-            auto remoteState = fakeFolder.currentRemoteState();
-            // The subFolderA should still be there on the server.
-            QVERIFY(remoteState.find("parentThirdName/subFolderA/fileA.txt"));
-            // But not on the client because of the selective sync
-            remoteState.remove("parentThirdName/subFolderA");
-            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
-
-            expectedServerState = fakeFolder.currentRemoteState();
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            fakeFolder.syncOnce(); // This sync should do nothing
-            QCOMPARE(completeSpy.count(), 0);
-
-            QCOMPARE(fakeFolder.currentRemoteState(), expectedServerState);
-            QCOMPARE(fakeFolder.currentLocalState(), remoteState);
-        }
-    }
-
-    void testLocalMoveDetection()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-
-        int nPUT = 0;
-        int nDELETE = 0;
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &) {
-            if (op == QNetworkAccessManager::PutOperation)
-                ++nPUT;
-            if (op == QNetworkAccessManager::DeleteOperation)
-                ++nDELETE;
-            return nullptr;
-        });
-
-        // For directly editing the remote checksum
-        FileInfo &remoteInfo = fakeFolder.remoteModifier();
-
-        // Simple move causing a remote rename
-        fakeFolder.localModifier().rename("A/a1", "A/a1m");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-        QCOMPARE(nPUT, 0);
-
-        // Move-and-change, causing a upload and delete
-        fakeFolder.localModifier().rename("A/a2", "A/a2m");
-        fakeFolder.localModifier().appendByte("A/a2m");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-        QCOMPARE(nPUT, 1);
-        QCOMPARE(nDELETE, 1);
-
-        // Move-and-change, mtime+content only
-        fakeFolder.localModifier().rename("B/b1", "B/b1m");
-        fakeFolder.localModifier().setContents("B/b1m", 'C');
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-        QCOMPARE(nPUT, 2);
-        QCOMPARE(nDELETE, 2);
-
-        // Move-and-change, size+content only
-        auto mtime = fakeFolder.remoteModifier().find("B/b2")->lastModified;
-        fakeFolder.localModifier().rename("B/b2", "B/b2m");
-        fakeFolder.localModifier().appendByte("B/b2m");
-        fakeFolder.localModifier().setModTime("B/b2m", mtime);
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-        QCOMPARE(nPUT, 3);
-        QCOMPARE(nDELETE, 3);
-
-        // Move-and-change, content only -- c1 has no checksum, so we fail to detect this!
-        // NOTE: This is an expected failure.
-        mtime = fakeFolder.remoteModifier().find("C/c1")->lastModified;
-        fakeFolder.localModifier().rename("C/c1", "C/c1m");
-        fakeFolder.localModifier().setContents("C/c1m", 'C');
-        fakeFolder.localModifier().setModTime("C/c1m", mtime);
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(nPUT, 3);
-        QCOMPARE(nDELETE, 3);
-        QVERIFY(!(fakeFolder.currentLocalState() == remoteInfo));
-
-        // cleanup, and upload a file that will have a checksum in the db
-        fakeFolder.localModifier().remove("C/c1m");
-        fakeFolder.localModifier().insert("C/c3");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-        QCOMPARE(nPUT, 4);
-        QCOMPARE(nDELETE, 4);
-
-        // Move-and-change, content only, this time while having a checksum
-        mtime = fakeFolder.remoteModifier().find("C/c3")->lastModified;
-        fakeFolder.localModifier().rename("C/c3", "C/c3m");
-        fakeFolder.localModifier().setContents("C/c3m", 'C');
-        fakeFolder.localModifier().setModTime("C/c3m", mtime);
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(nPUT, 5);
-        QCOMPARE(nDELETE, 5);
-        QCOMPARE(fakeFolder.currentLocalState(), remoteInfo);
-    }
-
-    // If the same folder is shared in two different ways with the same
-    // user, the target user will see duplicate file ids. We need to make
-    // sure the move detection and sync still do the right thing in that
-    // case.
-    void testDuplicateFileId()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        auto &remote = fakeFolder.remoteModifier();
-
-        remote.mkdir("A/W");
-        remote.insert("A/W/w1");
-        remote.mkdir("A/Q");
-
-        // Duplicate every entry in A under O/A
-        remote.mkdir("O");
-        remote.children["O"].addChild(remote.children["A"]);
-
-        // This already checks that the rename detection doesn't get
-        // horribly confused if we add new files that have the same
-        // fileid as existing ones
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-
-        int nGET = 0;
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &) {
-            if (op == QNetworkAccessManager::GetOperation)
-                ++nGET;
-            return nullptr;
-        });
-
-        // Try a remote file move
-        remote.rename("A/a1", "A/W/a1m");
-        remote.rename("O/A/a1", "O/A/W/a1m");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 0);
-
-        // And a remote directory move
-        remote.rename("A/W", "A/Q/W");
-        remote.rename("O/A/W", "O/A/Q/W");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 0);
-
-        // Partial file removal (in practice, A/a2 may be moved to O/a2, but we don't care)
-        remote.rename("O/A/a2", "O/a2");
-        remote.remove("A/a2");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 0);
-
-        // Local change plus remote move at the same time
-        fakeFolder.localModifier().appendByte("O/a2");
-        remote.rename("O/a2", "O/a3");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 1);
-    }
-
-    void testMovePropagation()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        auto &local = fakeFolder.localModifier();
-        auto &remote = fakeFolder.remoteModifier();
-
-        int nGET = 0;
-        int nPUT = 0;
-        int nMOVE = 0;
-        int nDELETE = 0;
-        fakeFolder.setServerOverride([&](QNetworkAccessManager::Operation op, const QNetworkRequest &req) {
-            if (op == QNetworkAccessManager::GetOperation)
-                ++nGET;
-            if (op == QNetworkAccessManager::PutOperation)
-                ++nPUT;
-            if (op == QNetworkAccessManager::DeleteOperation)
-                ++nDELETE;
-            if (req.attribute(QNetworkRequest::CustomVerbAttribute) == "MOVE")
-                ++nMOVE;
-            return nullptr;
-        });
-        auto resetCounters = [&]() {
-            nGET = nPUT = nMOVE = nDELETE = 0;
-        };
-
-        // Move
-        {
-            resetCounters();
-            local.rename("A/a1", "A/a1m");
-            remote.rename("B/b1", "B/b1m");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-            QCOMPARE(nGET, 0);
-            QCOMPARE(nPUT, 0);
-            QCOMPARE(nMOVE, 1);
-            QCOMPARE(nDELETE, 0);
-            QVERIFY(itemSuccessfulMove(completeSpy, "A/a1m"));
-            QVERIFY(itemSuccessfulMove(completeSpy, "B/b1m"));
-        }
-
-        // Touch+Move on same side
-        resetCounters();
-        local.rename("A/a2", "A/a2m");
-        local.setContents("A/a2m", 'A');
-        remote.rename("B/b2", "B/b2m");
-        remote.setContents("B/b2m", 'A');
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 1);
-        QCOMPARE(nPUT, 1);
-        QCOMPARE(nMOVE, 0);
-        QCOMPARE(nDELETE, 1);
-        QCOMPARE(remote.find("A/a2m")->contentChar, 'A');
-        QCOMPARE(remote.find("B/b2m")->contentChar, 'A');
-
-        // Touch+Move on opposite sides
-        resetCounters();
-        local.rename("A/a1m", "A/a1m2");
-        remote.setContents("A/a1m", 'B');
-        remote.rename("B/b1m", "B/b1m2");
-        local.setContents("B/b1m", 'B');
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 2);
-        QCOMPARE(nPUT, 2);
-        QCOMPARE(nMOVE, 0);
-        QCOMPARE(nDELETE, 0);
-        // All these files existing afterwards is debatable. Should we propagate
-        // the rename in one direction and grab the new contents in the other?
-        // Currently there's no propagation job that would do that, and this does
-        // at least not lose data.
-        QCOMPARE(remote.find("A/a1m")->contentChar, 'B');
-        QCOMPARE(remote.find("B/b1m")->contentChar, 'B');
-        QCOMPARE(remote.find("A/a1m2")->contentChar, 'W');
-        QCOMPARE(remote.find("B/b1m2")->contentChar, 'W');
-
-        // Touch+create on one side, move on the other
-        {
-            resetCounters();
-            local.appendByte("A/a1m");
-            local.insert("A/a1mt");
-            remote.rename("A/a1m", "A/a1mt");
-            remote.appendByte("B/b1m");
-            remote.insert("B/b1mt");
-            local.rename("B/b1m", "B/b1mt");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            QVERIFY(expectAndWipeConflict(local, fakeFolder.currentLocalState(), "A/a1mt"));
-            QVERIFY(expectAndWipeConflict(local, fakeFolder.currentLocalState(), "B/b1mt"));
-            QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-            QCOMPARE(nGET, 3);
-            QCOMPARE(nPUT, 1);
-            QCOMPARE(nMOVE, 0);
-            QCOMPARE(nDELETE, 0);
-            QVERIFY(itemSuccessful(completeSpy, "A/a1m", CSYNC_INSTRUCTION_NEW));
-            QVERIFY(itemSuccessful(completeSpy, "B/b1m", CSYNC_INSTRUCTION_NEW));
-            QVERIFY(itemConflict(completeSpy, "A/a1mt"));
-            QVERIFY(itemConflict(completeSpy, "B/b1mt"));
-        }
-
-        // Create new on one side, move to new on the other
-        {
-            resetCounters();
-            local.insert("A/a1N", 13);
-            remote.rename("A/a1mt", "A/a1N");
-            remote.insert("B/b1N", 13);
-            local.rename("B/b1mt", "B/b1N");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            QVERIFY(expectAndWipeConflict(local, fakeFolder.currentLocalState(), "A/a1N"));
-            QVERIFY(expectAndWipeConflict(local, fakeFolder.currentLocalState(), "B/b1N"));
-            QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-            QCOMPARE(nGET, 2);
-            QCOMPARE(nPUT, 0);
-            QCOMPARE(nMOVE, 0);
-            QCOMPARE(nDELETE, 1);
-            QVERIFY(itemSuccessful(completeSpy, "A/a1mt", CSYNC_INSTRUCTION_REMOVE));
-            QVERIFY(itemSuccessful(completeSpy, "B/b1mt", CSYNC_INSTRUCTION_REMOVE));
-            QVERIFY(itemConflict(completeSpy, "A/a1N"));
-            QVERIFY(itemConflict(completeSpy, "B/b1N"));
-        }
-
-        // Local move, remote move
-        resetCounters();
-        local.rename("C/c1", "C/c1mL");
-        remote.rename("C/c1", "C/c1mR");
-        QVERIFY(fakeFolder.syncOnce());
-        // end up with both files
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 1);
-        QCOMPARE(nPUT, 1);
-        QCOMPARE(nMOVE, 0);
-        QCOMPARE(nDELETE, 0);
-
-        // Rename/rename conflict on a folder
-        resetCounters();
-        remote.rename("C", "CMR");
-        local.rename("C", "CML");
-        QVERIFY(fakeFolder.syncOnce());
-        // End up with both folders
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 3); // 3 files in C
-        QCOMPARE(nPUT, 3);
-        QCOMPARE(nMOVE, 0);
-        QCOMPARE(nDELETE, 0);
-
-        // Folder move
-        {
-            resetCounters();
-            local.rename("A", "AM");
-            remote.rename("B", "BM");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-            QCOMPARE(nGET, 0);
-            QCOMPARE(nPUT, 0);
-            QCOMPARE(nMOVE, 1);
-            QCOMPARE(nDELETE, 0);
-            QVERIFY(itemSuccessfulMove(completeSpy, "AM"));
-            QVERIFY(itemSuccessfulMove(completeSpy, "BM"));
-        }
-
-        // Folder move with contents touched on the same side
-        {
-            resetCounters();
-            local.setContents("AM/a2m", 'C');
-            local.rename("AM", "A2");
-            remote.setContents("BM/b2m", 'C');
-            remote.rename("BM", "B2");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-            QCOMPARE(nGET, 1);
-            QCOMPARE(nPUT, 1);
-            QCOMPARE(nMOVE, 1);
-            QCOMPARE(nDELETE, 0);
-            QCOMPARE(remote.find("A2/a2m")->contentChar, 'C');
-            QCOMPARE(remote.find("B2/b2m")->contentChar, 'C');
-            QVERIFY(itemSuccessfulMove(completeSpy, "A2"));
-            QVERIFY(itemSuccessfulMove(completeSpy, "B2"));
-        }
-
-        // Folder rename with contents touched on the other tree
-        resetCounters();
-        remote.setContents("A2/a2m", 'D');
-        // setContents alone may not produce updated mtime if the test is fast
-        // and since we don't use checksums here, that matters.
-        remote.appendByte("A2/a2m");
-        local.rename("A2", "A3");
-        local.setContents("B2/b2m", 'D');
-        local.appendByte("B2/b2m");
-        remote.rename("B2", "B3");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 1);
-        QCOMPARE(nPUT, 1);
-        QCOMPARE(nMOVE, 1);
-        QCOMPARE(nDELETE, 0);
-        QCOMPARE(remote.find("A3/a2m")->contentChar, 'D');
-        QCOMPARE(remote.find("B3/b2m")->contentChar, 'D');
-
-        // Folder rename with contents touched on both ends
-        resetCounters();
-        remote.setContents("A3/a2m", 'R');
-        remote.appendByte("A3/a2m");
-        local.setContents("A3/a2m", 'L');
-        local.appendByte("A3/a2m");
-        local.appendByte("A3/a2m");
-        local.rename("A3", "A4");
-        remote.setContents("B3/b2m", 'R');
-        remote.appendByte("B3/b2m");
-        local.setContents("B3/b2m", 'L');
-        local.appendByte("B3/b2m");
-        local.appendByte("B3/b2m");
-        remote.rename("B3", "B4");
-        QVERIFY(fakeFolder.syncOnce());
-        auto currentLocal = fakeFolder.currentLocalState();
-        auto conflicts = findConflicts(currentLocal.children["A4"]);
-        QCOMPARE(conflicts.size(), 1);
-        for (auto c : conflicts) {
-            QCOMPARE(currentLocal.find(c)->contentChar, 'L');
-            local.remove(c);
-        }
-        conflicts = findConflicts(currentLocal.children["B4"]);
-        QCOMPARE(conflicts.size(), 1);
-        for (auto c : conflicts) {
-            QCOMPARE(currentLocal.find(c)->contentChar, 'L');
-            local.remove(c);
-        }
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 2);
-        QCOMPARE(nPUT, 0);
-        QCOMPARE(nMOVE, 1);
-        QCOMPARE(nDELETE, 0);
-        QCOMPARE(remote.find("A4/a2m")->contentChar, 'R');
-        QCOMPARE(remote.find("B4/b2m")->contentChar, 'R');
-
-        // Rename a folder and rename the contents at the same time
-        resetCounters();
-        local.rename("A4/a2m", "A4/a2m2");
-        local.rename("A4", "A5");
-        remote.rename("B4/b2m", "B4/b2m2");
-        remote.rename("B4", "B5");
-        QVERIFY(fakeFolder.syncOnce());
-        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        QCOMPARE(nGET, 0);
-        QCOMPARE(nPUT, 0);
-        QCOMPARE(nMOVE, 2);
-        QCOMPARE(nDELETE, 0);
-    }
-
-    // Check interaction of moves with file type changes
-    void testMoveAndTypeChange()
-    {
-        FakeFolder fakeFolder{ FileInfo::A12_B12_C12_S12() };
-        auto &local = fakeFolder.localModifier();
-        auto &remote = fakeFolder.remoteModifier();
-
-        // Touch on one side, rename and mkdir on the other
-        {
-            local.appendByte("A/a1");
-            remote.rename("A/a1", "A/a1mq");
-            remote.mkdir("A/a1");
-            remote.appendByte("B/b1");
-            local.rename("B/b1", "B/b1mq");
-            local.mkdir("B/b1");
-            QSignalSpy completeSpy(&fakeFolder.syncEngine(), SIGNAL(itemCompleted(const SyncFileItemPtr &)));
-            QVERIFY(fakeFolder.syncOnce());
-            // BUG: This doesn't behave right
-            //QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
-        }
-    }
-};
-
-QTEST_GUILESS_MAIN(TestSyncMove)
-#include "testsyncmove.moc"
--- a/translations/client_ca.ts
+++ b/translations/client_ca.ts
--- a/translations/client_cs.ts
+++ b/translations/client_cs.ts
--- a/translations/client_de.ts
+++ b/translations/client_de.ts
--- a/translations/client_el.ts
+++ b/translations/client_el.ts
--- a/translations/client_en.ts
+++ b/translations/client_en.ts
--- a/translations/client_es.ts
+++ b/translations/client_es.ts
--- a/translations/client_es_AR.ts
+++ b/translations/client_es_AR.ts
--- a/Show More
+++ b/Show More