1.6.0rc2

This causes infinite sync loops

This reverts commit 8b469d3992.

CMakeLists.txt

@@ -85,6 +85,14 @@ endif()
 # this option creates only libocsync and libowncloudsync
 option(BUILD_LIBRARIES_ONLY "BUILD_LIBRARIES_ONLY" OFF)
 
+# When this option is enabled, 5xx errors are not added to the clacklist
+# Normaly you don't want to enable this option because if a particular file
+# trigger a bug on the server, you want the file to be blacklisted.
+option(OWNCLOUD_5XX_NO_BLACKLIST "OWNCLOUD_5XX_NO_BLACKLIST" OFF)
+if(OWNCLOUD_5XX_NO_BLACKLIST)
+    add_definitions(-DOWNCLOUD_5XX_NO_BLACKLIST=1)
+endif()
+
 #### find libs
 #find_package(Qt4 4.7.0 COMPONENTS QtCore QtGui QtXml QtNetwork QtTest QtWebkit REQUIRED )
 #if( UNIX AND NOT APPLE ) # Fdo notifications

ChangeLog

@@ -1,6 +1,22 @@
 ChangeLog
 =========
 version 1.6.0 (release 2014-04- )
+ * Minor GUI improvements
+ * Qt5 compile issues fixed
+ * Ignore sync log file in filewatcher
+ * Install libocsync to private library dir and use rpath to localize
+ * Fix reconnect after server disconnect
+ * Fix "unknown action" display in Activity window
+ * Fix memory leaks
+ * Respect XDG_CONFIG_HOME environment var
+ * Handle empty fileids in the journal correctly
+ * Add abilility to compile libowncloudsync without GUI dependendy
+ * Fix SSL error with previously-expired CAs on Windows
+ * Fix incorrect folder pause state after start
+ * Fix a couple of actual potential crashes
+ * Improve Cookie support (e.g. for cookie-based load-balancers)
+ * Introduce a general timeout of 300s for network operations
+ * Improve error handling, blacklisting
  * Job-based change propagation, enables faster parallel up/downloads 
    (right now only if no bandwidth limit is set and no proxy is used)
  * Significantly reduced CPU load when checking for local and remote changes

VERSION.cmake

@@ -4,7 +4,7 @@ set( MIRALL_VERSION_PATCH 0 )
 set( MIRALL_SOVERSION 0 )
 
 if ( NOT DEFINED MIRALL_VERSION_SUFFIX )
-    set( MIRALL_VERSION_SUFFIX "beta1" ) #e.g. beta1, beta2, rc1
+    set( MIRALL_VERSION_SUFFIX "rc2" ) #e.g. beta1, beta2, rc1
 endif( NOT DEFINED MIRALL_VERSION_SUFFIX )
 
 if( NOT DEFINED MIRALL_VERSION_BUILD )

admin/win/nsi/l10n/Hungarian.nsh

@@ -1,17 +1,18 @@
 # Auto-generated - do not modify
+StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Kiadási jegyzetek megtekintése"
+StrCpy $PageReinstall_NEW_Field_2 "Eltávolítás telepítés előtt"
+StrCpy $PageReinstall_NEW_Field_3 "Ne távolítsa el"
 StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_TITLE "Már telepítve"
 StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_SUBTITLE "Válaszd ki, hogy szeretnéd telepíteni a következő alkalmazást ${APPLICATION_NAME}."
 StrCpy $PageReinstall_SAME_Field_2 "Komponens hozzáadása/újratelepítése"
-StrCpy $PageReinstall_SAME_Field_3 "Eltávolitani  ${APPLICATION_NAME}"
+StrCpy $PageReinstall_SAME_Field_3 "${APPLICATION_NAME} eltávolítása"
-StrCpy $UNINSTALLER_APPDATA_TITLE "Eltávolitani  ${APPLICATION_NAME}"
+StrCpy $UNINSTALLER_APPDATA_TITLE "${APPLICATION_NAME} eltávolítása"
+StrCpy $UNINSTALLER_APPDATA_CHECKBOX "Igen, törölje ezt az adatkönyvtárat."
 StrCpy $UNINSTALLER_FINISHED_Detail "Befejezve"
-StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Show release notes"
 StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "Found ${APPLICATION_EXECUTABLE} process(s) which need to be stopped.$\nDo you want the installer to stop these for you?"
 StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Killing ${APPLICATION_EXECUTABLE} processes."
 StrCpy $ConfirmEndProcess_KILL_NOT_FOUND_TEXT "Process to kill not found!"
 StrCpy $PageReinstall_NEW_Field_1 "An older version of ${APPLICATION_NAME} is installed on your system. It is recommended that you uninstall the current version before installing. Select the operation you want to perform and click Next to continue."
-StrCpy $PageReinstall_NEW_Field_2 "Uninstall before installing"
-StrCpy $PageReinstall_NEW_Field_3 "Do not uninstall"
 StrCpy $PageReinstall_OLD_Field_1 "A newer version of ${APPLICATION_NAME} is already installed! It is not recommended that you install an older version. If you really want to install this older version, it is better to uninstall the current version first. Select the operation you want to perform and click Next to continue."
 StrCpy $PageReinstall_SAME_Field_1 "${APPLICATION_NAME} ${VERSION} is already installed.\r\nSelect the operation you want to perform and click Next to continue."
 StrCpy $PageReinstall_SAME_MUI_HEADER_TEXT_SUBTITLE "Choose the maintenance option to perform."
@@ -29,7 +30,6 @@ StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_Desc "Quick Launch shortcut for ${APPLICA
 StrCpy $UNINSTALLER_APPDATA_SUBTITLE "Remove ${APPLICATION_NAME}'s data folder from your computer."
 StrCpy $UNINSTALLER_APPDATA_LABEL_1 "Do you want to delete ${APPLICATION_NAME}'s data folder?"
 StrCpy $UNINSTALLER_APPDATA_LABEL_2 "Leave unchecked to keep the data folder for later use or check to delete the data folder."
-StrCpy $UNINSTALLER_APPDATA_CHECKBOX "Yes, delete this data folder."
 StrCpy $UNINSTALLER_FILE_Detail "Writing Uninstaller"
 StrCpy $UNINSTALLER_REGISTRY_Detail "Writing Installer Registry Keys"
 StrCpy $UNINSTALL_MESSAGEBOX "It does not appear that ${APPLICATION_NAME} is installed in the directory '$INSTDIR'.$\r$\nContinue anyway (not recommended)?"

admin/win/nsi/l10n/Italian.nsh

@@ -1,6 +1,6 @@
 # Auto-generated - do not modify
 StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Mostra le note di rilascio"
-StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "Trovati ${APPLICATION_EXECUTABLE} processi che dovrebbero essere fermati.$\nVuoi che il programma di installazione li fermi per te?"
+StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "Trovati ${APPLICATION_EXECUTABLE} processi che dovrebbero essere fermati.$\nVuoi che il programma di installazione li fermi al posto tuo?"
 StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Sto terminando ${APPLICATION_EXECUTABLE} processi."
 StrCpy $ConfirmEndProcess_KILL_NOT_FOUND_TEXT "Il processo da terminare non è stato trovato!"
 StrCpy $PageReinstall_NEW_Field_1 "Una versione più datata di ${APPLICATION_NAME} è installata sul tuo sistema. Si consiglia di disinstallare la versione attuale prima di installare. Seleziona l'operazione da eseguire e fai clic su Avanti per continuare."

admin/win/nsi/l10n/SpanishInternational.nsh

@@ -0,0 +1,44 @@
+# Auto-generated - do not modify
+StrCpy $MUI_FINISHPAGE_SHOWREADME_TEXT_STRING "Mostrar notas de la versión"
+StrCpy $ConfirmEndProcess_KILLING_PROCESSES_TEXT "Parando el proceso ${APPLICATION_EXECUTABLE}."
+StrCpy $ConfirmEndProcess_KILL_NOT_FOUND_TEXT "Proceso a detener no encontrado!"
+StrCpy $PageReinstall_NEW_Field_1 "Una versión anterior de ${APPLICATION_NAME} esta instalada en el sistema. Es recomendado que quite esta versión antes de instalar. Elija la operación a realizar y seleccione Siguiente para continuar."
+StrCpy $PageReinstall_NEW_Field_2 "Des-instale antes de Instalar."
+StrCpy $PageReinstall_NEW_Field_3 "No des-instalar."
+StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_TITLE "Actualmente Instalado."
+StrCpy $PageReinstall_NEW_MUI_HEADER_TEXT_SUBTITLE "Elija como desea instalar ${APPLICATION_NAME}."
+StrCpy $PageReinstall_OLD_Field_1 "Una versión mas reciente de ${APPLICATION_NAME} esta actualmente instalada! No es recomendado que instale una versión antigua. Si realmente desea instalar esta versión obsoleta, es mejor que des-instale la versión actual primero. Seleccione la operación que desea realizar y presione en Siguiente para continuar. "
+StrCpy $PageReinstall_SAME_Field_2 "Agregar/Re-Instalar componentes"
+StrCpy $PageReinstall_SAME_Field_3 "Des-instalar ${APPLICATION_NAME}"
+StrCpy $UNINSTALLER_APPDATA_TITLE "Des-instalar ${APPLICATION_NAME}"
+StrCpy $PageReinstall_SAME_MUI_HEADER_TEXT_SUBTITLE "Elija la opción de mantenimiento a realizar."
+StrCpy $SEC_APPLICATION_DETAILS "Instalar  esenciales ${APPLICATION_NAME}."
+StrCpy $OPTION_SECTION_SC_START_MENU_SECTION "Acceso Directo en Menú de Programas"
+StrCpy $OPTION_SECTION_SC_START_MENU_DetailPrint "Agregando el Acceso Directo al Menú de Inicio para ${APPLICATION_NAME}."
+StrCpy $OPTION_SECTION_SC_DESKTOP_SECTION "Acceso directo en Escritorio"
+StrCpy $OPTION_SECTION_SC_DESKTOP_DetailPrint "Creando Accesos Directos en Escritorio"
+StrCpy $OPTION_SECTION_SC_START_MENU_Desc "Acceso directo de ${APPLICATION_NAME}"
+StrCpy $OPTION_SECTION_SC_DESKTOP_Desc "Acceso Directo al Escritorio para ${APPLICATION_NAME}."
+StrCpy $UNINSTALLER_APPDATA_SUBTITLE "Quitar la carpeta de datos ${APPLICATION_NAME} de la computadora."
+StrCpy $UNINSTALLER_APPDATA_LABEL_1 "Desea borrar la carpeta de datos de ${APPLICATION_NAME}?"
+StrCpy $UNINSTALLER_APPDATA_LABEL_2 "Dejar des-tildado para mantener la carpeta de datos para posterior uso o tildar para borrar la carpeta de datos."
+StrCpy $UNINSTALLER_APPDATA_CHECKBOX "Si, eliminar esta carpeta de datos."
+StrCpy $UNINSTALLER_FILE_Detail "Escribiendo Des-Instalador."
+StrCpy $UNINSTALLER_REGISTRY_Detail "Escribiendo claves de Registro del Instalador"
+StrCpy $UNINSTALLER_FINISHED_Detail "Terminado"
+StrCpy $UNINSTALL_ABORT "Des-instalación abortada por el usuario"
+StrCpy $INIT_NO_DESKTOP "Acceso Directo en Escritorio (Sobrescribe existentes)"
+StrCpy $UAC_INSTALLER_REQUIRE_ADMIN "Este instalador requiere acceso Administrador, intente de nuevo. "
+StrCpy $INIT_INSTALLER_RUNNING "El instalador ya esta corriendo."
+StrCpy $UAC_UNINSTALLER_REQUIRE_ADMIN "Este des-instalador requiere acceso administrador, intente de nuevo"
+StrCpy $INIT_UNINSTALLER_RUNNING "El des-instalador ya esta corriendo"
+StrCpy $SectionGroup_Shortcuts "Accesos Directos"
+StrCpy $ConfirmEndProcess_MESSAGEBOX_TEXT "Found ${APPLICATION_EXECUTABLE} process(s) which need to be stopped.$\nDo you want the installer to stop these for you?"
+StrCpy $PageReinstall_SAME_Field_1 "${APPLICATION_NAME} ${VERSION} is already installed.\r\nSelect the operation you want to perform and click Next to continue."
+StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_SECTION "Quick Launch Shortcut"
+StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_DetailPrint "Creating Quick Launch Shortcut"
+StrCpy $OPTION_SECTION_SC_APPLICATION_Desc "${APPLICATION_NAME} essentials."
+StrCpy $OPTION_SECTION_SC_QUICK_LAUNCH_Desc "Quick Launch shortcut for ${APPLICATION_NAME}."
+StrCpy $UNINSTALL_MESSAGEBOX "It does not appear that ${APPLICATION_NAME} is installed in the directory '$INSTDIR'.$\r$\nContinue anyway (not recommended)?"
+StrCpy $INIT_NO_QUICK_LAUNCH "Quick Launch Shortcut (N/A)"
+StrCpy $UAC_ERROR_ELEVATE "Unable to elevate, error:"

admin/win/nsi/l10n/Swedish.nsh

@@ -36,9 +36,9 @@ StrCpy $UNINSTALL_MESSAGEBOX "Det verkar inte som ${APPLICATION_NAME} är instal
 StrCpy $UNINSTALL_ABORT "Avinstallering avbröts av användare"
 StrCpy $INIT_NO_QUICK_LAUNCH "Snabbstartsgenväg (N/A)"
 StrCpy $INIT_NO_DESKTOP "Skrivbordsgenväg (skriver över nuvarande)"
+StrCpy $UAC_ERROR_ELEVATE "Kunde inte få förhöjda rättigheter, fel:"
 StrCpy $UAC_INSTALLER_REQUIRE_ADMIN "Detta installationsprogram kräver adminstratörs rättigheter, försök igen"
 StrCpy $INIT_INSTALLER_RUNNING "Installationsprogrammet körs redan."
 StrCpy $UAC_UNINSTALLER_REQUIRE_ADMIN "Detta avinstallationsprogram  kräver administratörs rättigheter, försök igen"
 StrCpy $INIT_UNINSTALLER_RUNNING "Avinstallationsprogrammet körs redan."
 StrCpy $SectionGroup_Shortcuts "Genvägar"
-StrCpy $UAC_ERROR_ELEVATE "Unable to elevate, error:"

admin/win/nsi/l10n/languages.nsh

@@ -3,6 +3,7 @@
 !insertmacro MUI_LANGUAGE "Estonian"
 !insertmacro MUI_LANGUAGE "Turkish"
 !insertmacro MUI_LANGUAGE "Slovenian"
+!insertmacro MUI_LANGUAGE "SpanishInternational"
 !insertmacro MUI_LANGUAGE "Dutch"
 !insertmacro MUI_LANGUAGE "Hungarian"
 !insertmacro MUI_LANGUAGE "French"

cmake/modules/FindNeon.cmake

@@ -31,7 +31,7 @@ HINTS
 
 find_library(NEON_LIBRARIES
 NAMES
-    neon
+    neon neon-27
 HINTS
     ${_NEON_LIBDIR}
     ${CMAKE_INSTALL_LIBDIR}

cmake/modules/FindSQLite3.cmake

@@ -30,7 +30,7 @@ find_path(SQLITE3_INCLUDE_DIR
 
 find_library(SQLITE3_LIBRARY
     NAMES
-        sqlite3
+        sqlite3 sqlite3-0
     PATHS
         ${_SQLITE3_LIBDIR}
 )

cmake/modules/GNUInstallDirs.cmake

@@ -1,32 +1,49 @@
-# - Define GNU standard installation directories
+#.rst:
+# GNUInstallDirs
+# --------------
+#
+# Define GNU standard installation directories
+#
 # Provides install directory variables as defined for GNU software:
-#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+#
+# ::
+#
+#   http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+#
 # Inclusion of this module defines the following variables:
-#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#
-#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# ::
+#
+#   CMAKE_INSTALL_<dir>      - destination for files of a given type
+#   CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+#
 # where <dir> is one of:
-#  BINDIR           - user executables (bin)
+#
-#  SBINDIR          - system admin executables (sbin)
+# ::
-#  LIBEXECDIR       - program executables (libexec)
+#
-#  SYSCONFDIR       - read-only single-machine data (etc)
+#   BINDIR           - user executables (bin)
-#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#   SBINDIR          - system admin executables (sbin)
-#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#   LIBEXECDIR       - program executables (libexec)
-#  LIBDIR           - object code libraries (lib or lib64)
+#   SYSCONFDIR       - read-only single-machine data (etc)
-#  INCLUDEDIR       - C header files (include)
+#   SHAREDSTATEDIR   - modifiable architecture-independent data (com)
-#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#   LOCALSTATEDIR    - modifiable single-machine data (var)
-#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#   LIBDIR           - object code libraries (lib or lib64 or lib/<multiarch-tuple> on Debian)
-#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#   INCLUDEDIR       - C header files (include)
-#  INFODIR          - info documentation (DATAROOTDIR/info)
+#   OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
-#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#   DATAROOTDIR      - read-only architecture-independent data root (share)
-#  MANDIR           - man documentation (DATAROOTDIR/man)
+#   DATADIR          - read-only architecture-independent data (DATAROOTDIR)
-#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+#   INFODIR          - info documentation (DATAROOTDIR/info)
-# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+#   LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
-# install() commands for the corresponding file type.  If the includer does
+#   MANDIR           - man documentation (DATAROOTDIR/man)
-# not define a value the above-shown default will be used and the value will
+#   DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
-# appear in the cache for editing by the user.
+#
-# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION
-# from the corresponding destination by prepending (if necessary) the value
+# options of install() commands for the corresponding file type.  If the
-# of CMAKE_INSTALL_PREFIX.
+# includer does not define a value the above-shown default will be used
+# and the value will appear in the cache for editing by the user.  Each
+# CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the
+# value of CMAKE_INSTALL_PREFIX.
 
 #=============================================================================
 # Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
@@ -68,30 +85,90 @@ if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
   set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
 endif()
 
-if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+# We check if the variable was manually set and not cached, in order to
+# allow projects to set the values as normal variables before including
+# GNUInstallDirs to avoid having the entries cached or user-editable. It
+# replaces the "if(NOT DEFINED CMAKE_INSTALL_XXX)" checks in all the
+# other cases.
+# If CMAKE_INSTALL_LIBDIR is defined, if _libdir_set is false, then the
+# variable is a normal one, otherwise it is a cache one.
+get_property(_libdir_set CACHE CMAKE_INSTALL_LIBDIR PROPERTY TYPE SET)
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR OR (_libdir_set
+    AND DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX
+    AND NOT "${_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX}" STREQUAL "${CMAKE_INSTALL_PREFIX}"))
+  # If CMAKE_INSTALL_LIBDIR is not defined, it is always executed.
+  # Otherwise:
+  #  * if _libdir_set is false it is not executed (meaning that it is
+  #    not a cache variable)
+  #  * if _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX is not defined it is
+  #    not executed
+  #  * if _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX and
+  #    CMAKE_INSTALL_PREFIX are the same string it is not executed.
+  #    _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX is updated after the
+  #    execution, of this part of code, therefore at the next inclusion
+  #    of the file, CMAKE_INSTALL_LIBDIR is defined, and the 2 strings
+  #    are equal, meaning that the if is not executed the code the
+  #    second time.
+
   set(_LIBDIR_DEFAULT "lib")
   # Override this default 'lib' with 'lib64' iff:
   #  - we are on Linux system but NOT cross-compiling
   #  - we are NOT on debian
   #  - we are on a 64 bits system
   # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
-  # Note that the future of multi-arch handling may be even
+  # For Debian with multiarch, use 'lib/${CMAKE_LIBRARY_ARCHITECTURE}' if
-  # more complicated than that: http://wiki.debian.org/Multiarch
+  # CMAKE_LIBRARY_ARCHITECTURE is set (which contains e.g. "i386-linux-gnu"
-  if(CMAKE_SYSTEM_NAME MATCHES "Linux"
+  # and CMAKE_INSTALL_PREFIX is "/usr"
-      AND NOT CMAKE_CROSSCOMPILING
+  # See http://wiki.debian.org/Multiarch
-      AND NOT EXISTS "/etc/debian_version")
+  if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX)
-    if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+    set(__LAST_LIBDIR_DEFAULT "lib")
-      message(AUTHOR_WARNING
+    # __LAST_LIBDIR_DEFAULT is the default value that we compute from
-        "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+    # _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX, not a cache entry for
-        "Please enable at least one language before including GNUInstallDirs.")
+    # the value that was last used as the default.
-    else()
+    # This value is used to figure out whether the user changed the
-      if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    # CMAKE_INSTALL_LIBDIR value manually, or if the value was the
-        set(_LIBDIR_DEFAULT "lib64")
+    # default one. When CMAKE_INSTALL_PREFIX changes, the value is
+    # updated to the new default, unless the user explicitly changed it.
+  endif()
+  if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$"
+      AND NOT CMAKE_CROSSCOMPILING)
+    if (EXISTS "/etc/debian_version") # is this a debian system ?
+      if(CMAKE_LIBRARY_ARCHITECTURE)
+        if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
+          set(_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+        endif()
+        if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX
+            AND "${_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
+          set(__LAST_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+        endif()
+      endif()
+    else() # not debian, rely on CMAKE_SIZEOF_VOID_P:
+      if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+        message(AUTHOR_WARNING
+          "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+          "Please enable at least one language before including GNUInstallDirs.")
+      else()
+        if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+          set(_LIBDIR_DEFAULT "lib64")
+          if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX)
+            set(__LAST_LIBDIR_DEFAULT "lib64")
+          endif()
+        endif()
       endif()
     endif()
   endif()
-  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+  if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+    set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+  elseif(DEFINED __LAST_LIBDIR_DEFAULT
+      AND "${__LAST_LIBDIR_DEFAULT}" STREQUAL "${CMAKE_INSTALL_LIBDIR}")
+    set_property(CACHE CMAKE_INSTALL_LIBDIR PROPERTY VALUE "${_LIBDIR_DEFAULT}")
+  endif()
 endif()
+# Save for next run
+set(_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE INTERNAL "CMAKE_INSTALL_PREFIX during last run")
+unset(_libdir_set)
+unset(__LAST_LIBDIR_DEFAULT)
+
 
 if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
   set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")

cmake/modules/QtVersionAbstraction.cmake

@@ -11,13 +11,15 @@ endif( BUILD_WITH_QT4 )
 
 if( Qt5Core_FOUND )
     message(STATUS "Found Qt5 core, checking for further dependencies...")
-    find_package(Qt5Widgets REQUIRED)
-    find_package(Qt5Quick REQUIRED)
-    find_package(Qt5PrintSupport REQUIRED)
-    find_package(Qt5WebKit REQUIRED)
     find_package(Qt5Network REQUIRED)
     find_package(Qt5Xml REQUIRED)
-    find_package(Qt5WebKitWidgets REQUIRED)
+    if(NOT TOKEN_AUTH_ONLY)
+        find_package(Qt5WebKitWidgets REQUIRED)
+        find_package(Qt5WebKit REQUIRED)
+        find_package(Qt5PrintSupport REQUIRED)
+        find_package(Qt5Quick REQUIRED)
+        find_package(Qt5Widgets REQUIRED)
+    endif()
     if(APPLE)
 	find_package(Qt5MacExtras REQUIRED)
     endif(APPLE)
@@ -37,23 +39,27 @@ if( Qt5Core_FOUND )
 	include_directories(${Qt5DBus_INCLUDES})
 	add_definitions(${Qt5DBus_DEFINITIONS})
     endif (WITH_DBUS)
-
+    include_directories(${Qt5Core_INCLUDES})
-    include_directories(${Qt5Widgets_INCLUDES})
+    add_definitions(${Qt5Core_DEFINITIONS})
-    add_definitions(${Qt5Widgets_DEFINITIONS})
     if (NOT WIN32) #implied on Win32
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
     endif(NOT WIN32)
 #        set(CMAKE_CXX_FLAGS "${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
 
-    if(APPLE)
+    if(APPLE AND NOT TOKEN_AUTH_ONLY)
 	include_directories(${Qt5MacExtras_INCLUDE_DIRS})
 	add_definitions(${Qt5MacExtras_DEFINITIONS})
 	set (QT_LIBRARIES ${QT_LIBRARIES} ${Qt5MacExtras_LIBRARIES})
-    endif(APPLE)
+    endif()
 
+if(NOT BUILD_LIBRARIES_ONLY)
     macro(qt_wrap_ui)
 	qt5_wrap_ui(${ARGN})
     endmacro()
+else()
+    # hack
+    SET(QT_UIC_EXECUTABLE "") 
+endif()
 
     macro(qt_add_resources)
 	qt5_add_resources(${ARGN})

csync/src/CMakeLists.txt

@@ -44,11 +44,10 @@ if(HAVE_ICONV AND WITH_ICONV)
     list(APPEND CSYNC_LINK_LIBRARIES ${ICONV_LIBRARIES})
 endif()
 
-set(BLACKLIST_ON_ERROR 0 CACHE BOOL
+# Specific option for builds tied to servers that do not support renaming extensions
-  "If an errors occurs three times on the same file, do not attempt to process that file any further.")
+set(NO_RENAME_EXTENSION 0 CACHE BOOL "Do not issue rename if the extension changes")
-
+if(NO_RENAME_EXTENSION)
-if(BLACKLIST_ON_ERROR)
+    add_definitions(-DNO_RENAME_EXTENSION)
-    add_definitions(-DBLACKLIST_ON_ERROR)
 endif()
 
 set(csync_SRCS
@@ -110,17 +109,29 @@ set_target_properties(
       SOVERSION
         ${LIBRARY_SOVERSION}
 )
-
+if(BUILD_OWNCLOUD_OSX_BUNDLE)
-INSTALL(
+  INSTALL(
+    TARGETS
+      ${CSYNC_LIBRARY}
+    LIBRARY DESTINATION
+	${LIB_INSTALL_DIR}
+    ARCHIVE DESTINATION
+	${LIB_INSTALL_DIR}
+    RUNTIME DESTINATION
+	${BIN_INSTALL_DIR}
+    )
+else()
+  INSTALL(
   TARGETS
     ${CSYNC_LIBRARY}
   LIBRARY DESTINATION
-    ${LIB_INSTALL_DIR}
+    ${LIB_INSTALL_DIR}/${APPLICATION_EXECUTABLE}
   ARCHIVE DESTINATION
-    ${LIB_INSTALL_DIR}
+    ${LIB_INSTALL_DIR}/${APPLICATION_EXECUTABLE}
   RUNTIME DESTINATION
-    ${BIN_INSTALL_DIR}
+    ${BIN_INSTALL_DIR}/${APPLICATION_EXECUTABLE}
-)
+  )
+endif()
 
 # INSTALL(
 #   FILES

csync/src/csync.c

@@ -197,9 +197,6 @@ int csync_init(CSYNC *ctx) {
     ctx->remote.type = LOCAL_REPLICA;
   }
 
-  if (ctx->options.timeout)
-    csync_vio_set_property(ctx, "timeout", &ctx->options.timeout);
-
   if (c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp) < 0) {
     ctx->status_code = CSYNC_STATUS_TREE_ERROR;
     rc = -1;
@@ -447,14 +444,15 @@ static int _csync_treewalk_visitor(void *obj, void *data) {
       trav.rename_path  = cur->destpath;
       trav.etag         = cur->etag;
       trav.file_id      = cur->file_id;
+      trav.inode        = cur->inode;
 
       trav.error_status = cur->error_status;
       trav.should_update_etag = cur->should_update_etag;
 
       if( other_node ) {
           csync_file_stat_t *other_stat = (csync_file_stat_t*)other_node->data;
-          trav.other.etag = other_stat->etag ? c_strdup(other_stat->etag) : NULL;
+          trav.other.etag = other_stat->etag;
-          trav.other.file_id = c_strdup(other_stat->file_id);
+          trav.other.file_id = other_stat->file_id;
           trav.other.instruction = other_stat->instruction;
           trav.other.modtime = other_stat->modtime;
           trav.other.size = other_stat->size;
@@ -629,6 +627,8 @@ int csync_commit(CSYNC *ctx) {
   _csync_clean_ctx(ctx);
 
   ctx->remote.read_from_db = 0;
+  ctx->read_from_db_disabled = 0;
+
 
   /* Create new trees */
   rc = c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp);
@@ -923,3 +923,10 @@ int csync_set_module_property(CSYNC* ctx, const char* key, void* value)
     return csync_vio_set_property(ctx, key, value);
 }
 
+
+int csync_set_read_from_db(CSYNC* ctx, int enabled)
+{
+    ctx->read_from_db_disabled = !enabled;
+    return 0;
+}
+

csync/src/csync.h

@@ -102,7 +102,8 @@ enum csync_status_codes_e {
     /* Codes for file individual status: */
     CSYNC_STATUS_INDIVIDUAL_IS_SYMLINK,
     CSYNC_STATUS_INDIVIDUAL_IGNORE_LIST,
-    CSYNC_STATUS_INDIVIDUAL_IS_INVALID_CHARS
+    CSYNC_STATUS_INDIVIDUAL_IS_INVALID_CHARS,
+    CYSNC_STATUS_FILE_LOCKED_OR_OPEN
 };
 
 typedef enum csync_status_codes_e CSYNC_STATUS;
@@ -130,10 +131,7 @@ enum csync_instructions_e {
   CSYNC_INSTRUCTION_IGNORE     = 0x00000020,  /* The file is ignored (UPDATE|RECONCILE) */
   CSYNC_INSTRUCTION_SYNC       = 0x00000040,  /* The file need to be pushed to the other remote (RECONCILE) */
   CSYNC_INSTRUCTION_STAT_ERROR = 0x00000080,
-  CSYNC_INSTRUCTION_ERROR      = 0x00000100,
+  CSYNC_INSTRUCTION_ERROR      = 0x00000100
-  /* instructions for the propagator */
-  CSYNC_INSTRUCTION_DELETED    = 0x00000200,
-  CSYNC_INSTRUCTION_UPDATED    = 0x00000400
 };
 
 enum csync_ftw_type_e {
@@ -172,6 +170,7 @@ enum csync_notify_type_e {
 struct csync_tree_walk_file_s {
     const char *path;
     int64_t     size;
+    int64_t     inode;
     time_t      modtime;
 #ifdef _WIN32
     uint32_t    uid;
@@ -591,6 +590,11 @@ void csync_resume(CSYNC *ctx);
  */
 int  csync_abort_requested(CSYNC *ctx);
 
+/**
+ * Specify if it is allowed to read the remote tree from the DB (default to enabled)
+ */
+int csync_set_read_from_db(CSYNC* ctx, int enabled);
+
 #ifdef __cplusplus
 }
 #endif

csync/src/csync_exclude.c

@@ -144,6 +144,7 @@ CSYNC_EXCLUDE_TYPE csync_excluded(CSYNC *ctx, const char *path, int filetype) {
   char *bname = NULL;
   char *dname = NULL;
   char *prev_dname = NULL;
+  char *conflict = NULL;
   int rc = -1;
   CSYNC_EXCLUDE_TYPE match = CSYNC_NOT_EXCLUDED;
   CSYNC_EXCLUDE_TYPE type  = CSYNC_NOT_EXCLUDED;
@@ -200,6 +201,19 @@ CSYNC_EXCLUDE_TYPE csync_excluded(CSYNC *ctx, const char *path, int filetype) {
       goto out;
   }
 
+  if (getenv("CSYNC_CONFLICT_FILE_USERNAME")) {
+      asprintf(&conflict, "*_conflict_%s-*", getenv("CSYNC_CONFLICT_FILE_USERNAME"));
+      rc = csync_fnmatch(conflict, path, 0);
+      if (rc == 0) {
+          match = CSYNC_FILE_SILENTLY_EXCLUDED;
+          SAFE_FREE(conflict);
+          SAFE_FREE(bname);
+          SAFE_FREE(dname);
+          goto out;
+      }
+      SAFE_FREE(conflict);
+  }
+
   SAFE_FREE(bname);
   SAFE_FREE(dname);
 

csync/src/csync_owncloud.c

@@ -508,10 +508,10 @@ static int dav_connect(const char *base_url) {
         goto out;
     }
 
-    if (dav_session.read_timeout == 0)
+    if (dav_session.read_timeout != 0) {
-        dav_session.read_timeout = 300;  // set 300 seconds as default.
+        ne_set_read_timeout(dav_session.ctx, dav_session.read_timeout);
-
+        DEBUG_WEBDAV("Timeout set to %u seconds", dav_session.read_timeout );
-    ne_set_read_timeout(dav_session.ctx, dav_session.read_timeout);
+    }
 
     snprintf( uaBuf, sizeof(uaBuf), "Mozilla/5.0 (%s) csyncoC/%s",
               get_platform(), CSYNC_STRINGIFY( LIBCSYNC_VERSION ));

csync/src/csync_private.h

@@ -161,6 +161,7 @@ struct csync_s {
   int status;
   volatile int abort;
   void *rename_info;
+  int  read_from_db_disabled;
 };
 
 

csync/src/csync_reconcile.c

@@ -183,6 +183,7 @@ static int _csync_merge_algorithm_visitor(void *obj, void *data) {
                     if( !c_streq(cur->file_id, "") ) {
                         csync_vio_set_file_id( other->file_id, cur->file_id );
                     }
+                    other->inode = cur->inode;
                     cur->instruction = CSYNC_INSTRUCTION_NONE;
                 } else if (other->instruction == CSYNC_INSTRUCTION_REMOVE) {
                     other->instruction = CSYNC_INSTRUCTION_RENAME;
@@ -191,7 +192,7 @@ static int _csync_merge_algorithm_visitor(void *obj, void *data) {
                     if( !c_streq(cur->file_id, "") ) {
                         csync_vio_set_file_id( other->file_id, cur->file_id );
                     }
-
+                    other->inode = cur->inode;
                     cur->instruction = CSYNC_INSTRUCTION_NONE;
                 } else if (other->instruction == CSYNC_INSTRUCTION_NEW) {
                     CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "OOOO=> NEW detected in other tree!");
@@ -223,6 +224,16 @@ static int _csync_merge_algorithm_visitor(void *obj, void *data) {
         /* file on current replica is changed or new */
         case CSYNC_INSTRUCTION_EVAL:
         case CSYNC_INSTRUCTION_NEW:
+            // This operation is usually a no-op and will by default return false
+            if (csync_file_locked_or_open(ctx->local.uri, cur->path)) {
+                CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "[Reconciler] IGNORING file %s/%s since it is locked / open", ctx->local.uri, cur->path);
+                cur->instruction = CSYNC_INSTRUCTION_ERROR;
+                if (cur->error_status == CSYNC_STATUS_OK) // don't overwrite error
+                    cur->error_status = CYSNC_STATUS_FILE_LOCKED_OR_OPEN;
+                break;
+            } else {
+                //CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "[Reconciler] not ignoring file %s/%s", ctx->local.uri, cur->path);
+            }
             switch (other->instruction) {
             /* file on other replica is changed or new */
             case CSYNC_INSTRUCTION_NEW:
@@ -235,10 +246,11 @@ static int _csync_merge_algorithm_visitor(void *obj, void *data) {
                 }
                 if (is_equal_files) {
                     /* The files are considered equal. */
-                    cur->instruction = CSYNC_INSTRUCTION_UPDATED; /* update the DB */
+                    cur->instruction = CSYNC_INSTRUCTION_NONE;
                     other->instruction = CSYNC_INSTRUCTION_NONE;
 
                     if( !cur->etag && other->etag ) cur->etag = c_strdup(other->etag);
+                    cur->should_update_etag = true; /* update DB */
                 } else if(ctx->current == REMOTE_REPLICA) {
                         cur->instruction = CSYNC_INSTRUCTION_CONFLICT;
                         other->instruction = CSYNC_INSTRUCTION_NONE;

csync/src/csync_update.c

@@ -79,6 +79,26 @@ static uint64_t _hash_of_file(CSYNC *ctx, const char *file) {
   return h;
 }
 
+#ifdef NO_RENAME_EXTENSION
+/* Return true if the two path have the same extension. false otherwise. */
+static bool _csync_sameextension(const char *p1, const char *p2) {
+    /* Find pointer to the extensions */
+    const char *e1 = strrchr(p1, '.');
+    const char *e2 = strrchr(p2, '.');
+
+    /* If the found extension contains a '/', it is because the . was in the folder name
+     *            => no extensions */
+    if (e1 && strchr(e1, '/')) e1 = NULL;
+    if (e2 && strchr(e2, '/')) e2 = NULL;
+
+    /* If none have extension, it is the same extension */
+    if (!e1 && !e2)
+        return true;
+
+    /* c_streq takes care of the rest */
+    return c_streq(e1, e2);
+}
+#endif
 
 static int _csync_detect_update(CSYNC *ctx, const char *file,
     const csync_vio_file_stat_t *fs, const int type) {
@@ -235,18 +255,29 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
             goto out;
         }
         if (type == CSYNC_FTW_TYPE_DIR && ctx->current == REMOTE_REPLICA
-                && c_streq(fs->file_id, tmp->file_id)) {
+                && c_streq(fs->file_id, tmp->file_id) && !ctx->read_from_db_disabled) {
             /* If both etag and file id are equal for a directory, read all contents from
-             * the database. */
+             * the database.
+             * The comparison of file id ensure that we fetch all the file id when upgrading from
+             * owncloud 5 to owncloud 6.
+             */
             CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Reading from database: %s", path);
             ctx->remote.read_from_db = true;
         }
+
+        if (!c_streq(fs->file_id, tmp->file_id) && ctx->current == REMOTE_REPLICA) {
+            /* file id has changed. Which means we need to update the DB.
+             * (upgrade from owncloud 5 to owncloud 6 for instence) */
+            st->should_update_etag = true;
+        }
         st->instruction = CSYNC_INSTRUCTION_NONE;
     } else {
         enum csync_vio_file_type_e tmp_vio_type = CSYNC_VIO_FILE_TYPE_UNKNOWN;
 
         /* check if it's a file and has been renamed */
         if (ctx->current == LOCAL_REPLICA) {
+            CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Checking for rename based on inode # %" PRId64 "", (uint64_t) fs->inode);
+
             tmp = csync_statedb_get_stat_by_inode(ctx, fs->inode);
 
             /* translate the file type between the two stat types csync has. */
@@ -259,8 +290,12 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
             }
 
             if (tmp && tmp->inode == fs->inode && tmp_vio_type == fs->type
-                    && (tmp->modtime == fs->mtime || fs->type == CSYNC_VIO_FILE_TYPE_DIRECTORY)) {
+                    && (tmp->modtime == fs->mtime || fs->type == CSYNC_VIO_FILE_TYPE_DIRECTORY)
-                CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "inodes: %" PRId64 " <-> %" PRId64, (uint64_t) tmp->inode, (uint64_t) fs->inode);
+#ifdef NO_RENAME_EXTENSION
+                    && _csync_sameextension(tmp->path, path)
+#endif
+               ) {
+                CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "pot rename detected based on inode # %" PRId64 "", (uint64_t) fs->inode);
                 /* inode found so the file has been renamed */
                 st->instruction = CSYNC_INSTRUCTION_EVAL_RENAME;
                 if (fs->type == CSYNC_VIO_FILE_TYPE_DIRECTORY) {
@@ -443,7 +478,6 @@ static bool fill_tree_from_db(CSYNC *ctx, const char *uri)
 /* File tree walker */
 int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
     unsigned int depth) {
-  char errbuf[256] = {0};
   char *filename = NULL;
   char *d_name = NULL;
   csync_vio_handle_t *dh = NULL;
@@ -487,10 +521,7 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
               CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "asprintf failed!");
           }
       } else {
-          C_STRERROR(errno, errbuf, sizeof(errbuf));
+          CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "opendir failed for %s - errno %d", uri, errno);
-          CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR,
-                    "opendir failed for %s - %s (errno %d)",
-                    uri, errbuf, errno);
       }
       goto error;
   }

csync/src/csync_util.c

@@ -55,8 +55,6 @@ static const _instr_code_struct _instr[] =
   { "INSTRUCTION_SYNC", CSYNC_INSTRUCTION_SYNC },
   { "INSTRUCTION_STAT_ERR", CSYNC_INSTRUCTION_STAT_ERROR },
   { "INSTRUCTION_ERROR", CSYNC_INSTRUCTION_ERROR },
-  { "INSTRUCTION_DELETED", CSYNC_INSTRUCTION_DELETED },
-  { "INSTRUCTION_UPDATED", CSYNC_INSTRUCTION_UPDATED },
   { NULL, CSYNC_INSTRUCTION_ERROR }
 };
 
@@ -182,3 +180,22 @@ csync_vio_file_stat_t *csync_vio_convert_file_stat(csync_file_stat_t *st) {
 
   return vfs;
 }
+
+bool (*csync_file_locked_or_open_ext) (const char*) = 0; // filled in by library user
+void set_csync_file_locked_or_open_ext(bool (*f) (const char*));
+void set_csync_file_locked_or_open_ext(bool (*f) (const char*)) {
+    csync_file_locked_or_open_ext = f;
+}
+
+bool csync_file_locked_or_open( const char *dir, const char *fname) {
+    char *tmp_uri = NULL;
+    bool ret;
+    if (!csync_file_locked_or_open_ext) {
+        return false;
+    }
+    asprintf(&tmp_uri, "%s/%s", dir, fname);
+    CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "csync_file_locked_or_open %s", tmp_uri);
+    ret = csync_file_locked_or_open_ext(tmp_uri);
+    SAFE_FREE(tmp_uri);
+    return ret;
+}

csync/src/csync_util.h

@@ -35,4 +35,5 @@ void csync_win32_set_file_hidden( const char *file, bool hidden );
 /* Convert a csync_file_stat_t to csync_vio_file_stat_t */
 csync_vio_file_stat_t *csync_vio_convert_file_stat(csync_file_stat_t *st);
 
+bool csync_file_locked_or_open( const char *dir, const char *fname);
 #endif /* _CSYNC_UTIL_H */

csync/src/std/c_macro.h

@@ -55,9 +55,6 @@
 /** Get the size of an array */
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
 
-/** Macro to make strerror_r work with -Werror=unused-result */
-#define C_STRERROR(errno, buf, size) if(strerror_r(errno, buf, size)) {}
-
 /**
  * This is a hack to fix warnings. The idea is to use this everywhere that we
  * get the "discarding const" warning by the compiler. That doesn't actually

csync/src/vio/csync_vio.c

@@ -113,11 +113,6 @@ int csync_vio_stat(CSYNC *ctx, const char *uri, csync_vio_file_stat_t *buf) {
       if (rc < 0) {
         CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Local stat failed, errno %d", errno);
       }
-#ifdef _WIN32
-      else {
-        CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Win32: STAT-inode for %s: %llu", uri, buf->inode );
-      }
-#endif
       break;
     default:
       break;

csync/src/vio/csync_vio_local.c

@@ -240,6 +240,9 @@ int csync_vio_local_stat(const char *uri, csync_vio_file_stat_t *buf) {
     /* printf("Index: %I64i\n", FileIndex.QuadPart); */
     buf->inode = FileIndex.QuadPart;
 
+    buf->size = (fileInfo.nFileSizeHigh * (int64_t)(MAXDWORD+1)) + fileInfo.nFileSizeLow;
+    buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_SIZE;
+
     /* Get the file time with a win32 call rather than through stat. See
       * http://www.codeproject.com/Articles/1144/Beating-the-Daylight-Savings-Time-bug-and-getting
       * for deeper explanation.

csync/tests/csync_tests/check_csync_statedb_query.c

@@ -243,19 +243,6 @@ static void check_csync_statedb_get_stat_by_hash_not_found(void **state)
     free(tmp);
 }
 
-static void check_csync_statedb_get_stat_by_inode(void **state)
-{
-    CSYNC *csync = *state;
-    csync_file_stat_t *tmp;
-
-    tmp = csync_statedb_get_stat_by_inode(csync, (ino_t) 23);
-    assert_non_null(tmp);
-
-    assert_int_equal(tmp->phash, 42);
-    assert_int_equal(tmp->inode, 23);
-
-    free(tmp);
-}
 
 static void check_csync_statedb_get_stat_by_inode_not_found(void **state)
 {
@@ -272,14 +259,10 @@ int torture_run_tests(void)
         unit_test_setup_teardown(check_csync_statedb_query_statement, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_create_error, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_insert_statement, setup, teardown),
-      /*  unit_test_setup_teardown(check_csync_statedb_is_empty, setup, teardown), */
-      /*  unit_test_setup_teardown(check_csync_statedb_create_tables, setup, teardown), */
         unit_test_setup_teardown(check_csync_statedb_drop_tables, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_insert_metadata, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_write, setup, teardown),
-     /*   unit_test_setup_teardown(check_csync_statedb_get_stat_by_hash, setup_db, teardown), */
         unit_test_setup_teardown(check_csync_statedb_get_stat_by_hash_not_found, setup_db, teardown),
-      /* unit_test_setup_teardown(check_csync_statedb_get_stat_by_inode, setup_db, teardown), */
         unit_test_setup_teardown(check_csync_statedb_get_stat_by_inode_not_found, setup_db, teardown),
     };
 

csync/tests/csync_tests/check_csync_update.c

@@ -233,8 +233,6 @@ static void check_csync_detect_update_db_none(void **state)
     st = c_rbtree_node_data(csync->local.tree->root);
     assert_int_equal(st->instruction, CSYNC_INSTRUCTION_NEW);
 
-    /* set the instruction to UPDATED that it gets written to the statedb */
-    st->instruction = CSYNC_INSTRUCTION_UPDATED;
 
     /* create a statedb */
     csync_set_status(csync, 0xFFFF);
@@ -262,9 +260,6 @@ static void check_csync_detect_update_db_eval(void **state)
     st = c_rbtree_node_data(csync->local.tree->root);
     assert_int_equal(st->instruction, CSYNC_INSTRUCTION_NEW);
 
-    /* set the instruction to UPDATED that it gets written to the statedb */
-    st->instruction = CSYNC_INSTRUCTION_UPDATED;
-
     /* create a statedb */
     csync_set_status(csync, 0xFFFF);
 
@@ -344,8 +339,6 @@ static void check_csync_detect_update_db_new(void **state)
     st = c_rbtree_node_data(csync->local.tree->root);
     assert_int_equal(st->instruction, CSYNC_INSTRUCTION_NEW);
 
-    /* set the instruction to UPDATED that it gets written to the statedb */
-    st->instruction = CSYNC_INSTRUCTION_UPDATED;
 
     /* create a statedb */
     csync_set_status(csync, 0xFFFF);

csync/tests/ownCloud/t1.pl

@@ -56,13 +56,13 @@ assertLocalDirs( 'toremote1', localDir().'remoteToLocal1' );
 
 # Check if the synced files from ownCloud have the same timestamp as the local ones.
 print "\nNow assert remote 'toremote1' with local " . localDir() . " :\n";
-assertLocalAndRemoteDir( 'remoteToLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # remove a local file.
 printInfo( "\nRemove a local file\n" );
-unlink( localDir() . 'remoteToLocal1/kernelcrash.txt' );
+unlink( localDir() . 'remoteToLocal1/rtl4/quitte.pdf' );
 csync();
-assertLocalAndRemoteDir( 'remoteToLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # add local files to a new dir1
 printInfo( "Add some more files to local:");
@@ -76,34 +76,46 @@ foreach my $file ( <./tolocal1/*> ) {
 }
 csync( );
 print "\nAssert local and remote dirs.\n";
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # move a local file
 printInfo( "Move a file locally." );
 move( "$locDir/kramer.jpg", "$locDir/oldtimer.jpg" );
 csync( );
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # move a local directory.
 printInfo( "Move a local directory." );
 move( localDir() . 'remoteToLocal1/rtl1', localDir(). 'remoteToLocal1/rtlX');
 csync();
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # remove a local dir
 printInfo( "Remove a local directory.");
 localCleanup( 'remoteToLocal1/rtlX' );
 csync();
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 assert( ! -e localDir().'remoteToLocal1/rtlX' );
 
-# create a false conflict, only the mtimes are changed, by content are equal.
+# create twos false conflict, only the mtimes are changed, by content are equal.
-printInfo( "Create a false conflict.");
+printInfo( "Create two false conflict.");
-my $srcFile = 'toremote1/kernelcrash.txt';
+put_to_dir( 'toremote1/kernelcrash.txt', 'remoteToLocal1' );
-put_to_dir( $srcFile, 'remoteToLocal1' );
+put_to_dir( 'toremote1/kraft_logo.gif', 'remoteToLocal1' );
+# don't wait so mtime are likely the same on the client and the server.
+system( "touch " . localDir() . "remoteToLocal1/kraft_logo.gif" );
+# wait two second so the mtime are different
 system( "sleep 2 && touch " . localDir() . "remoteToLocal1/kernelcrash.txt" );
+
+
 csync( );
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
+
+# The previous sync should have updated the etags, and this should NOT be a conflict
+printInfo( "Update the file again");
+system("echo more data >> " .  localDir() . "remoteToLocal1/kernelcrash.txt");
+system("echo corruption >> " .  localDir() . "remoteToLocal1/kraft_logo.gif");
+csync( );
+assertLocalAndRemoteDir( '', 0);
 
 # create a true conflict.
 printInfo( "Create a conflict." );
@@ -111,13 +123,14 @@ system( "echo \"This is more stuff\" >> /tmp/kernelcrash.txt" );
 put_to_dir( '/tmp/kernelcrash.txt', 'remoteToLocal1' );
 system( "sleep 2 && touch " . localDir() . "remoteToLocal1/kernelcrash.txt" );
 csync();
-assertLocalAndRemoteDir( 'remoteToLocal1', 1);
+assertLocalAndRemoteDir( '', 1);
 
 my $localMD5 = md5OfFile( localDir().'remoteToLocal1/kernelcrash.txt' );
 my $realMD5 = md5OfFile( '/tmp/kernelcrash.txt' );
 print "MD5 compare $localMD5 <-> $realMD5\n";
 assert( $localMD5 eq $realMD5 );
 assert(  glob(localDir().'remoteToLocal1/kernelcrash_conflict-*.txt' ) );
+system("rm " . localDir().'remoteToLocal1/kernelcrash_conflict-*.txt' );
 
 
 # prepare test for issue 1329, rtlX need to be modified
@@ -125,13 +138,13 @@ assert(  glob(localDir().'remoteToLocal1/kernelcrash_conflict-*.txt' ) );
 printInfo( "Add a local directory");
 system("cp -r 'toremote1/rtl1/'  '" . localDir(). "remoteToLocal1/rtlX'");
 csync();
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 
 # remove a local dir (still for issue 1329)
 printInfo( "Remove that directory.");
 localCleanup( 'remoteToLocal1/rtlX' );
 csync();
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 assert( ! -e localDir().'remoteToLocal1/rtlX' );
 
 
@@ -141,7 +154,7 @@ system("cp -r 'toremote1/rtl1/'  '" . localDir(). "remoteToLocal1/rtlX'");
 assert( -e localDir().'remoteToLocal1/rtlX' );
 assert( -e localDir().'remoteToLocal1/rtlX/rtl11/file.txt' );
 csync();
-assertLocalAndRemoteDir( 'fromLocal1', 0);
+assertLocalAndRemoteDir( '', 0);
 assert( -e localDir().'remoteToLocal1/rtlX' );
 assert( -e localDir().'remoteToLocal1/rtlX/rtl11/file.txt' );
 

csync/tests/ownCloud/t2.pl

@@ -80,7 +80,6 @@ assert( $inode == $inode2, "Inode has changed!");
 
 printInfo("Move a file into a sub directory.");
 # now move the file into a sub directory
-$inode = getInode('remoteToLocal1/kernel.txt');
 moveRemoteFile( 'remoteToLocal1/kernel.txt', 'remoteToLocal1/rtl1/');
 
 csync();
@@ -175,6 +174,24 @@ createLocalFile( localDir(). 'remoteToLocal1/rtl2/newRemoteDir/donat.txt', 8021
 csync();
 assertLocalAndRemoteDir( 'remoteToLocal1', 1);
 
+printInfo("simulate a owncloud 5 update by removing all the fileid");
+## simulate a owncloud 5 update by removing all the fileid
+system( "sqlite3 " . localDir() . ".csync_journal.db \"UPDATE metadata SET fileid='';\"");
+#refresh the ids
+csync();
+assertLocalAndRemoteDir( 'remoteToLocal1', 1);
+
+
+printInfo("Move a file from the server");
+$inode = getInode('remoteToLocal1/rtl2/kb1_local_gone.jpg');
+moveRemoteFile( 'remoteToLocal1/rtl2/kb1_local_gone.jpg', 'remoteToLocal1/rtl2/kb1_local_gone2.jpg');
+csync();
+assertLocalAndRemoteDir( 'remoteToLocal1', 1);
+$inode2 = getInode('remoteToLocal1/rtl2/kb1_local_gone2.jpg');
+assert( $inode == $inode2, "Inode has changed 3!");
+
+
+
 cleanup();
 
 # --

csync/tests/ownCloud/toremote1/My Document.doc

@@ -0,0 +1 @@
+A nice document.

csync/tests/ownCloud/toremote1/kernelcrash.txt

@@ -0,0 +1,16 @@
+freitag@zora:~> 
+Message from syslogd@zora at Sep 20 21:35:41 ...
+ kernel:[ 6702.458047] general protection fault: 0000 [#1] PREEMPT SMP 
+
+Message from syslogd@zora at Sep 20 21:35:41 ...
+ kernel:[ 6702.458060] last sysfs file: /sys/devices/LNXSYSTM:00/device:00/PNP0A08:00/device:03/ATK0110:00/hwmon/hwmon0/temp1_label
+
+Message from syslogd@zora at Sep 20 21:35:41 ...
+ kernel:[ 6702.458232] Stack:
+
+Message from syslogd@zora at Sep 20 21:35:41 ...
+ kernel:[ 6702.458262] Call Trace:
+
+Message from syslogd@zora at Sep 20 21:35:41 ...
+ kernel:[ 6702.458375] Code: 00 00 80 00 00 00 48 b9 00 00 00 00 80 ff ff ff 4e 8d 34 30 49 21 ce 48 8b 4c 24 38 49 8d 56 ff 48 3b 54 24 48 4c 0f 43 74 24 40 <48> 8b 11 48 85 d2 0f 84 d4 01 00 00 48 b9 fb 0f 00 00 00 c0 ff 
+

csync/tests/ownCloud/toremote1/rtl2/mettre.xls

@@ -1 +0,0 @@
-some content.

doc/CMakeLists.txt

@@ -12,12 +12,15 @@ if(SPHINX_FOUND)
     # assets
     set(LATEX_LOGO          "${CMAKE_CURRENT_SOURCE_DIR}/logo-blue.pdf")
 
+    install(DIRECTORY ${SPHINX_HTML_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+    install(DIRECTORY ${SPHINX_MAN_DIR} DESTINATION ${CMAKE_INSTALL_MANDIR} OPTIONAL)
+    install(DIRECTORY ${SPHINX_PDF_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+    install(DIRECTORY ${SPHINX_QCH_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in" conf.py @ONLY)
 
     if(WITH_DOC)
        add_custom_target(doc ALL DEPENDS doc-html doc-man COMMENT "Building documentation...")
-       install(DIRECTORY ${SPHINX_HTML_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR})
-       install(DIRECTORY ${SPHINX_MAN_DIR} DESTINATION ${CMAKE_INSTALL_MANDIR})
     else(WITH_DOC)
        add_custom_target(doc DEPENDS doc-html doc-man COMMENT "Building documentation...")
     endif(WITH_DOC)
@@ -39,9 +42,6 @@ if(SPHINX_FOUND)
         add_custom_target(doc-pdf $(MAKE) -C ${SPHINX_PDF_DIR} all-pdf
 		                  DEPENDS doc-latex )
         add_dependencies(doc doc-pdf)
-        if (WITH_DOC)
-           install(DIRECTORY ${SPHINX_PDF_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR})
-        endif (WITH_DOC)
     endif(PDFLATEX_FOUND)
     if (EXISTS ${QT_QCOLLECTIONGENERATOR_EXECUTABLE})
         add_custom_target( doc-qch-sphinx ${SPHINX_EXECUTABLE}
@@ -53,9 +53,6 @@ if(SPHINX_FOUND)
 		                   ${SPHINX_QCH_DIR}/*.qhcp
 				   DEPENDS doc-qch-sphinx )
         add_dependencies(doc doc-qch)
-        if (WITH_DOC)
-            install(DIRECTORY ${SPHINX_QCH_DIR} DESTINATION ${CMAKE_INSTALL_DOCDIR})
-        endif (WITH_DOC)
     endif()
     add_custom_target( doc-html ${SPHINX_EXECUTABLE}
 	                        -q -c . -b html

doc/troubleshooting.rst

@@ -134,3 +134,25 @@ log line contains a lot of information of every request and it's result.
 More information about the apache logging can be found at
 ``http://httpd.apache.org/docs/current/logs.html``.
 
+Core Dumps
+----------
+
+In case of crashes of the client software, having a core dump helps to
+debug the issue tremendously. 
+
+The client is able to write a core dump in case of crashing on Linux and 
+MacOSX. To enable that, the environment variable ``OWNCLOUD_CORE_DUMP`` has
+to be defined.
+
+For example
+
+```
+OWNCLOUD_CORE_DUMP=1 owncloud
+```
+
+starts the client with core dumping enabled. Core dumps appear in the 
+current working directory, and since they can be fairly large, it is 
+important to have plenty of disk space when running with dumps enabled.
+
+If a core dump file should be transfered back to the developers it 
+should be compressed properly before.

doc/visualtour.rst

@@ -80,7 +80,7 @@ Adding a Folder
 Adding a new sync is initiated by clicking ``Add Folder...`` in the ``Account``
 settings.
 
-..note: To add a folder, you must not already sync a folder that contains this
+..note:: To add a folder, you must not already sync a folder that contains this
         folder. By default, the wizard sets up the root folder of the ownCloud
         server to sync all of your ownCloud account. In consequence, you will
         first need to remove this folder prior to specifying new syncs.

src/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(CMAKE_AUTOMOC TRUE)
+include(GenerateExportHeader)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
@@ -27,9 +28,9 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
     )
 ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
 
-if(SPARKLE_FOUND)
+if(SPARKLE_FOUND AND NOT BUILD_LIBRARIES_ONLY)
     list (APPEND OS_SPECIFIC_LINK_LIBRARIES ${SPARKLE_LIBRARY})
-endif(SPARKLE_FOUND)
+endif()
 
 set(3rdparty_SRC
 3rdparty/qtsingleapplication/qtsingleapplication.cpp
@@ -103,6 +104,7 @@ set(libsync_SRCS
     mirall/quotainfo.cpp
     mirall/clientproxy.cpp
     mirall/syncrunfilelog.cpp
+    mirall/cookiejar.cpp
     creds/dummycredentials.cpp
     creds/abstractcredentials.cpp
     creds/credentialsfactory.cpp
@@ -115,19 +117,16 @@ if(TOKEN_AUTH_ONLY)
 		${libsync_SRCS}
 		creds/tokencredentials.cpp
 	)
-	else()
+else()
-		set (libsync_SRCS
+    set (libsync_SRCS
-			${libsync_SRCS}
+        ${libsync_SRCS}
-	    	creds/httpcredentials.cpp		
+        creds/httpcredentials.cpp
-	    	creds/shibbolethcredentials.cpp
+        creds/shibbolethcredentials.cpp
-	    	creds/shibboleth/shibbolethaccessmanager.cpp
+        creds/shibboleth/shibbolethwebview.cpp
-	    	creds/shibboleth/shibbolethcookiejar.cpp
+        creds/shibboleth/shibbolethrefresher.cpp
-	    	creds/shibboleth/shibbolethwebview.cpp
+        creds/shibboleth/authenticationdialog.cpp
-	    	creds/shibboleth/shibbolethrefresher.cpp
+        creds/shibboleth/shibbolethuserjob.cpp
-	    	creds/shibboleth/shibbolethconfigfile.cpp
+    )
-	    	creds/shibboleth/authenticationdialog.cpp
-	    	creds/shibboleth/shibbolethuserjob.cpp
-	)	
 endif()
 
 IF( NOT WIN32 AND NOT APPLE )
@@ -195,25 +194,39 @@ if(NEON_FOUND)
 endif()
 
 add_library(${synclib_NAME} SHARED ${libsync_SRCS} ${syncMoc})
-qt5_use_modules(${synclib_NAME} Widgets Network Xml WebKitWidgets Sql)
+GENERATE_EXPORT_HEADER( ${synclib_NAME}
+	BASE_NAME ${synclib_NAME}
+	EXPORT_MACRO_NAME OWNCLOUDSYNC_EXPORT
+        EXPORT_FILE_NAME owncloudlib.h
+	STATIC_DEFINE OWNCLOUD_BUILT_AS_STATIC
+)
+
+
+if(TOKEN_AUTH_ONLY)
+    qt5_use_modules(${synclib_NAME} Network Xml Sql)
+else()
+    qt5_use_modules(${synclib_NAME} Widgets Network Xml WebKitWidgets Sql)
+endif()
 
 set_target_properties( ${synclib_NAME}  PROPERTIES
 	VERSION ${MIRALL_VERSION}
 	SOVERSION ${MIRALL_SOVERSION}
 )
+set_target_properties( ${synclib_NAME} PROPERTIES
+	INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/${APPLICATION_EXECUTABLE}" )
 
 target_link_libraries(${synclib_NAME} ${libsync_LINK_TARGETS} )
 
 if(BUILD_LIBRARIES_ONLY)
-    add_library(${synclib_NAME}_static STATIC ${libsync_SRCS} ${syncMoc})
+    #add_library(${synclib_NAME}_static STATIC ${libsync_SRCS} ${syncMoc})
-    qt5_use_modules(${synclib_NAME}_static Widgets Network Xml WebKitWidgets Sql)
+    #qt5_use_modules(${synclib_NAME}_static Widgets Network Xml Sql)
 
-    set_target_properties( ${synclib_NAME}_static  PROPERTIES
+    #set_target_properties( ${synclib_NAME}_static  PROPERTIES
-        VERSION ${MIRALL_VERSION}
+    #    VERSION ${MIRALL_VERSION}
-        SOVERSION ${MIRALL_SOVERSION}
+    #    SOVERSION ${MIRALL_SOVERSION}
-    )
+    #)
 
-    target_link_libraries(${synclib_NAME}_static ${libsync_LINK_TARGETS} )
+    #target_link_libraries(${synclib_NAME}_static ${libsync_LINK_TARGETS} )
 endif()
 
 
@@ -376,17 +389,17 @@ if (WITH_DBUS)
     set(ADDITIONAL_APP_MODULES DBus)
 endif(WITH_DBUS)
 
-if(NOT BUILD_OWNCLOUD_OSX_BUNDLE)
+if(NOT BUILD_OWNCLOUD_OSX_BUNDLE AND NOT BUILD_LIBRARIES_ONLY)
     set(BIN_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 
-if(NOT WIN32 AND NOT BUILD_LIBRARIES_ONLY)
+    if(NOT WIN32)
-	file( GLOB _icons "${theme_dir}/colored/${ICON_APP_NAME}-icon-*.png" )
+        file( GLOB _icons "${theme_dir}/colored/${ICON_APP_NAME}-icon-*.png" )
-    foreach( _file ${_icons} )
+        foreach( _file ${_icons} )
-	    string( REPLACE "${theme_dir}/colored/${ICON_APP_NAME}-icon-" "" _res ${_file} )
+            string( REPLACE "${theme_dir}/colored/${ICON_APP_NAME}-icon-" "" _res ${_file} )
-        string( REPLACE ".png" "" _res ${_res} )
+            string( REPLACE ".png" "" _res ${_res} )
-	install( FILES ${_file} RENAME ${ICON_APP_NAME}.png DESTINATION ${DATADIR}/icons/hicolor/${_res}x${_res}/apps )
+        install( FILES ${_file} RENAME ${ICON_APP_NAME}.png DESTINATION ${DATADIR}/icons/hicolor/${_res}x${_res}/apps )
-    endforeach( _file )
+        endforeach( _file )
-endif(NOT WIN32 AND NOT BUILD_LIBRARIES_ONLY)
+    endif(NOT WIN32)
 
     install(FILES ${mirall_I18N} DESTINATION share/${APPLICATION_EXECUTABLE}/i18n)
 
@@ -418,14 +431,17 @@ elseif(NOT BUILD_LIBRARIES_ONLY)
     install(FILES ${qtkeychain_I18N} DESTINATION ${QM_DIR})
 endif()
 
-add_library(updater STATIC ${updater_SRCS} ${updaterMoc})
-target_link_libraries(updater ${synclib_NAME})
-qt5_use_modules(updater Widgets Network Xml)
-
 if(NOT BUILD_LIBRARIES_ONLY)
+  add_library(updater STATIC ${updater_SRCS} ${updaterMoc})
+  target_link_libraries(updater ${synclib_NAME})
+  qt5_use_modules(updater Widgets Network Xml)
+
   set_target_properties( ${APPLICATION_EXECUTABLE} PROPERTIES
           RUNTIME_OUTPUT_DIRECTORY  ${BIN_OUTPUT_DIRECTORY}
   )
+  set_target_properties( ${APPLICATION_EXECUTABLE} PROPERTIES
+	  INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/${APPLICATION_EXECUTABLE}" )
+
   target_link_libraries( ${APPLICATION_EXECUTABLE} ${QT_LIBRARIES} )
   target_link_libraries( ${APPLICATION_EXECUTABLE} ${synclib_NAME} )
   target_link_libraries( ${APPLICATION_EXECUTABLE} updater )
@@ -464,10 +480,14 @@ endif()
 set(owncloudcmd_NAME ${APPLICATION_EXECUTABLE}cmd)
 set(OWNCLOUDCMD_SRC owncloudcmd/simplesslerrorhandler.cpp owncloudcmd/owncloudcmd.cpp)
 if(NOT BUILD_LIBRARIES_ONLY)
+
    add_executable(${owncloudcmd_NAME}  ${OWNCLOUDCMD_SRC})
 	qt5_use_modules(${owncloudcmd_NAME} Network Sql)
 	set_target_properties(${owncloudcmd_NAME} PROPERTIES
-		        RUNTIME_OUTPUT_DIRECTORY  ${BIN_OUTPUT_DIRECTORY} )
+	        RUNTIME_OUTPUT_DIRECTORY  ${BIN_OUTPUT_DIRECTORY} )
+        set_target_properties(${owncloudcmd_NAME} PROPERTIES
+		INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/${APPLICATION_EXECUTABLE}" )
+
 	target_link_libraries(${owncloudcmd_NAME} ${synclib_NAME})
 endif()
 

src/creds/abstractcredentials.h

@@ -17,6 +17,8 @@
 #include <QObject>
 
 #include <csync.h>
+#include "owncloudlib.h"
+
 
 class QNetworkAccessManager;
 class QNetworkReply;
@@ -24,7 +26,7 @@ namespace Mirall
 {
 class Account;
 
-class AbstractCredentials : public QObject
+class OWNCLOUDSYNC_EXPORT AbstractCredentials : public QObject
 {
     Q_OBJECT
 

src/creds/credentialsfactory.cpp

@@ -13,6 +13,7 @@
 
 #include <QString>
 
+#include "creds/credentialsfactory.h"
 #ifdef TOKEN_AUTH_ONLY
 #include "creds/tokencredentials.h"
 #else

src/creds/credentialsfactory.h

@@ -14,16 +14,18 @@
 #ifndef MIRALL_CREDS_CREDENTIALS_FACTORY_H
 #define MIRALL_CREDS_CREDENTIALS_FACTORY_H
 
-class AbstractCredentials;
+#include "owncloudlib.h"
+
 class QString;
 
 namespace Mirall
 {
+class AbstractCredentials;
 
 namespace CredentialsFactory
 {
 
-AbstractCredentials* create(const QString& type);
+OWNCLOUDSYNC_EXPORT AbstractCredentials* create(const QString& type);
 
 } // ns CredentialsFactory
 

src/creds/httpcredentials.cpp

@@ -141,7 +141,11 @@ void HttpCredentials::syncContextPreStart (CSYNC* ctx)
 
 bool HttpCredentials::changed(AbstractCredentials* credentials) const
 {
-    HttpCredentials* other(dynamic_cast< HttpCredentials* >(credentials));
+    HttpCredentials* other(qobject_cast< HttpCredentials* >(credentials));
+
+    if (!other) {
+        return true;
+    }
 
     if (!other || (other->user() != this->user())) {
         return true;

src/creds/httpcredentials.h

@@ -30,7 +30,7 @@ class Job;
 namespace Mirall
 {
 
-class HttpCredentials : public AbstractCredentials
+class OWNCLOUDSYNC_EXPORT HttpCredentials : public AbstractCredentials
 {
     Q_OBJECT
 

src/creds/shibboleth/shibbolethaccessmanager.cpp

@@ -1,55 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#include <QDebug>
-#include <QNetworkRequest>
-#include <QNetworkCookieJar>
-
-#include "creds/shibboleth/shibbolethaccessmanager.h"
-
-namespace Mirall
-{
-
-ShibbolethAccessManager::ShibbolethAccessManager(const QNetworkCookie& cookie, QObject* parent)
-    : MirallAccessManager (parent),
-      _cookie(cookie)
-{}
-
-QNetworkReply* ShibbolethAccessManager::createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData)
-{
-    if (!_cookie.name().isEmpty()) {
-        QNetworkCookieJar* jar(cookieJar());
-        QUrl url(request.url());
-        QList<QNetworkCookie> cookies;
-        Q_FOREACH(const QNetworkCookie& cookie, jar->cookiesForUrl(url)) {
-            if (!cookie.name().startsWith("_shibsession_")) {
-                cookies << cookie;
-            }
-        }
-
-        cookies << _cookie; // this line and the line above replace all cookies with self and then add the shibboleth cookie (filtering the current shib cookie)
-        jar->setCookiesFromUrl(cookies, url);
-    }
-
-    qDebug() << "Creating a request to " << request.url().toString() << " with shibboleth cookie:" << _cookie.name();
-
-    return MirallAccessManager::createRequest (op, request, outgoingData);
-}
-
-void ShibbolethAccessManager::setCookie(const QNetworkCookie& cookie)
-{
-    qDebug() << "Got new shibboleth cookie:" << cookie.name();
-    _cookie = cookie;
-}
-
-} // ns Mirall

src/creds/shibboleth/shibbolethaccessmanager.h

@@ -1,43 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#ifndef MIRALL_WIZARD_SHIBBOLETH_ACCESS_MANAGER_H
-#define MIRALL_WIZARD_SHIBBOLETH_ACCESS_MANAGER_H
-
-#include <QNetworkCookie>
-
-#include "mirall/mirallaccessmanager.h"
-
-namespace Mirall
-{
-
-class ShibbolethAccessManager : public MirallAccessManager
-{
-    Q_OBJECT
-
-public:
-    ShibbolethAccessManager(const QNetworkCookie& cookie, QObject* parent = 0);
-
-public Q_SLOTS:
-    void setCookie(const QNetworkCookie& cookie);
-
-protected:
-    QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData = 0);
-
-private:
-    QNetworkCookie _cookie;
-};
-
-} // ns Mirall
-
-#endif

src/creds/shibboleth/shibbolethconfigfile.cpp

@@ -1,104 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#include <QDebug>
-#include <QTextStream>
-
-#include "creds/shibboleth/shibbolethconfigfile.h"
-#include "creds/shibboleth/shibbolethcookiejar.h"
-
-namespace Mirall
-{
-
-namespace
-{
-
-const char otherCookiesC[] = "otherCookies";
-
-} // ns
-
-void ShibbolethConfigFile::storeCookies(const QMap<QUrl, QList<QNetworkCookie> >& cookiesForUrl)
-{
-    if (cookiesForUrl.isEmpty()) {
-        removeData(QString(), QString::fromLatin1(otherCookiesC));
-    } else {
-        QByteArray data;
-        QTextStream stream(&data);
-
-        Q_FOREACH (const QUrl& url, cookiesForUrl.keys()) {
-            const QList<QNetworkCookie>& cookies(cookiesForUrl[url]);
-
-            if (cookies.isEmpty()) {
-                continue;
-            }
-            stream << "URL: " << url.toString().toUtf8() << "\n";
-            qDebug() << "URL: " << url.toString().toUtf8();
-
-            Q_FOREACH (const QNetworkCookie& cookie, cookies) {
-                stream << cookie.toRawForm(QNetworkCookie::NameAndValueOnly) << "\n";
-                qDebug() << cookie.toRawForm(QNetworkCookie::NameAndValueOnly);
-            }
-        }
-
-        stream.flush();
-
-        const QByteArray encodedCookies(data.toBase64());
-
-        qDebug() << "Raw cookies:\n" << data;
-        qDebug() << "Encoded cookies: " << encodedCookies;
-
-        storeData(QString(), QString::fromLatin1(otherCookiesC), QVariant(encodedCookies));
-    }
-}
-
-ShibbolethCookieJar* ShibbolethConfigFile::createCookieJar() const
-{
-    ShibbolethCookieJar* jar = new ShibbolethCookieJar();
-    const QVariant variant(retrieveData(QString(), QString::fromLatin1(otherCookiesC)));
-
-    if (variant.isValid()) {
-        QByteArray data(QByteArray::fromBase64(variant.toByteArray()));
-        QTextStream stream (&data);
-        const QString urlHeader(QString::fromLatin1("URL: "));
-        QUrl currentUrl;
-        QList<QNetworkCookie> currentCookies;
-
-        qDebug() << "Got valid cookies variant: " << data;
-
-        while (!stream.atEnd()) {
-            const QString line(stream.readLine());
-
-            qDebug() << line;
-
-            if (line.startsWith(urlHeader)) {
-                if (!currentUrl.isEmpty() && !currentCookies.isEmpty()) {
-                    jar->setCookiesFromUrl(currentCookies, currentUrl);
-                    currentCookies.clear();
-                    currentUrl.clear();
-                }
-                currentUrl = QUrl(line.mid(5));
-            } else if (!currentUrl.isEmpty()) {
-                const int equalPos(line.indexOf('='));
-
-                currentCookies << QNetworkCookie(line.left(equalPos).toUtf8(), line.mid(equalPos + 1).toUtf8());
-            }
-        }
-        if (!currentUrl.isEmpty() && !currentCookies.isEmpty()) {
-            jar->setCookiesFromUrl(currentCookies, currentUrl);
-        }
-    }
-
-    return jar;
-}
-
-} // ns Mirall

src/creds/shibboleth/shibbolethconfigfile.h

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#ifndef MIRALL_CREDS_SHIBBOLETH_CONFIG_FILE_H
-#define MIRALL_CREDS_SHIBBOLETH_CONFIG_FILE_H
-
-#include <QList>
-#include <QMap>
-#include <QNetworkCookie>
-#include <QUrl>
-
-#include "mirall/mirallconfigfile.h"
-
-namespace Mirall
-{
-
-class ShibbolethCookieJar;
-
-class ShibbolethConfigFile : public MirallConfigFile
-{
-public:
-    void storeCookies(const QMap<QUrl, QList<QNetworkCookie> >& cookies);
-    ShibbolethCookieJar* createCookieJar() const;
-};
-
-} // ns Mirall
-
-#endif

src/creds/shibboleth/shibbolethcookiejar.cpp

@@ -1,34 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#include "creds/shibboleth/shibbolethcookiejar.h"
-
-namespace Mirall
-{
-
-ShibbolethCookieJar::ShibbolethCookieJar (QObject* parent)
-  : QNetworkCookieJar (parent)
-{}
-
-bool ShibbolethCookieJar::setCookiesFromUrl (const QList<QNetworkCookie>& cookieList, const QUrl& url)
-{
-  if (QNetworkCookieJar::setCookiesFromUrl (cookieList, url)) {
-    Q_EMIT newCookiesForUrl (cookieList, url);
-
-    return true;
-  }
-
-  return false;
-}
-
-} // ns Mirall

src/creds/shibboleth/shibbolethcookiejar.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (C) by Krzesimir Nowak <krzesimir@endocode.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- */
-
-#ifndef MIRALL_WIZARD_SHIBBOLETH_COOKIE_JAR_H
-#define MIRALL_WIZARD_SHIBBOLETH_COOKIE_JAR_H
-
-#include <QNetworkCookieJar>
-#include <QList>
-
-class QUrl;
-class QNetworkCookie;
-
-namespace Mirall
-{
-
-class ShibbolethCookieJar : public QNetworkCookieJar
-{
-  Q_OBJECT
-
-public:
-  ShibbolethCookieJar (QObject* parent = 0);
-
-  virtual bool setCookiesFromUrl (const QList<QNetworkCookie>& cookieList, const QUrl& url);
-
-Q_SIGNALS:
-  void newCookiesForUrl (const QList<QNetworkCookie>& cookieList, const QUrl& url);
-};
-
-} // ns Mirall
-
-#endif

src/creds/shibboleth/shibbolethuserjob.cpp

@@ -35,7 +35,7 @@ void ShibbolethUserJob::start()
     AbstractNetworkJob::start();
 }
 
-void ShibbolethUserJob::finished()
+bool ShibbolethUserJob::finished()
 {
     bool success = false;
     QVariantMap json = QtJson::parse(QString::fromUtf8(reply()->readAll()), success).toMap();
@@ -43,12 +43,13 @@ void ShibbolethUserJob::finished()
     if (!success || json.isEmpty()) {
         qDebug() << "cloud/user: invalid JSON!";
         emit userFetched(QString());
-        return;
+        return true;
     }
 
     QString user =  json.value("ocs").toMap().value("data").toMap().value("id").toString();
-    qDebug() << "cloud/user: " << json << "->" << user;
+    //qDebug() << "cloud/user: " << json << "->" << user;
     emit userFetched(user);
+    return true;
 }
 
 

src/creds/shibboleth/shibbolethuserjob.h

@@ -36,7 +36,7 @@ signals:
     void tryAgain();
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 };
 
 

src/creds/shibboleth/shibbolethwebview.cpp

@@ -14,15 +14,16 @@
 #include <QApplication>
 #include <QDebug>
 #include <QNetworkCookie>
+#include <QNetworkCookieJar>
 #include <QWebFrame>
 #include <QWebPage>
 #include <QMessageBox>
 #include <QAuthenticator>
 #include <QNetworkReply>
 
-#include "creds/shibboleth/shibbolethcookiejar.h"
-#include "creds/shibboleth/shibbolethwebview.h"
 #include "creds/shibboleth/authenticationdialog.h"
+#include "creds/shibboleth/shibbolethwebview.h"
+#include "creds/shibbolethcredentials.h"
 #include "mirall/account.h"
 #include "mirall/mirallaccessmanager.h"
 #include "mirall/theme.h"
@@ -30,80 +31,53 @@
 namespace Mirall
 {
 
-void ShibbolethWebView::setup(Account *account, ShibbolethCookieJar* jar)
+ShibbolethWebView::ShibbolethWebView(Account* account, QWidget* parent)
+    : QWebView(parent)
+    , _account(account)
+    , _accepted(false)
 {
-    _account = account;
+    // no minimize
-    MirallAccessManager* nm = new MirallAccessManager(this);
+    setWindowFlags(Qt::Dialog);
-    // we need our own QNAM, but the we offload the SSL error handling to
+    setAttribute(Qt::WA_DeleteOnClose);
-    // the account object, which already can do this
-    connect(nm, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
-            account, SLOT(slotHandleErrors(QNetworkReply*,QList<QSslError>)));
-    connect(nm, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
-            SLOT(slotHandleAuthentication(QNetworkReply*,QAuthenticator*)));
-
     QWebPage* page = new QWebPage(this);
-
+    page->setNetworkAccessManager(account->networkAccessManager());
-    jar->setParent(this);
-    connect(jar, SIGNAL (newCookiesForUrl (QList<QNetworkCookie>, QUrl)),
-            this, SLOT (onNewCookiesForUrl (QList<QNetworkCookie>, QUrl)));
     connect(page, SIGNAL(loadStarted()),
             this, SLOT(slotLoadStarted()));
     connect(page, SIGNAL(loadFinished(bool)),
             this, SLOT(slotLoadFinished(bool)));
 
-    nm->setCookieJar(jar);
+
-    page->setNetworkAccessManager(nm);
+    connect(page->networkAccessManager()->cookieJar(),
+            SIGNAL(newCookiesForUrl (QList<QNetworkCookie>, QUrl)),
+            this, SLOT(onNewCookiesForUrl (QList<QNetworkCookie>, QUrl)));
     page->mainFrame()->load(account->url());
     this->setPage(page);
     setWindowTitle(tr("%1 - Authenticate").arg(Theme::instance()->appNameGUI()));
 }
 
-ShibbolethWebView::ShibbolethWebView(Account* account, QWidget* parent)
-  : QWebView(parent)
-{
-    setup(account, new ShibbolethCookieJar(this));
-}
-
 ShibbolethWebView::~ShibbolethWebView()
 {
     slotLoadFinished();
 }
 
-ShibbolethWebView::ShibbolethWebView(Account* account, ShibbolethCookieJar* jar, QWidget* parent)
-  : QWebView(parent)
-{
-    setup(account, jar);
-}
-
 void ShibbolethWebView::onNewCookiesForUrl (const QList<QNetworkCookie>& cookieList, const QUrl& url)
 {
-  QList<QNetworkCookie> otherCookies;
+    if (url.host() == _account->url().host()) {
-  QNetworkCookie shibCookie;
+        QNetworkCookie shibCookie = ShibbolethCredentials::findShibCookie(_account, cookieList);
-
+        if (shibCookie != QNetworkCookie()) {
-  Q_FOREACH (const QNetworkCookie& cookie, cookieList) {
+            Q_EMIT shibbolethCookieReceived(shibCookie, _account);
-    if (cookie.name().startsWith ("_shibsession_")) {
+            accept();
-      if (shibCookie.name().isEmpty()) {
+            close();
-        shibCookie = cookie;
+        }
-      } else {
-        qWarning() << "Too many Shibboleth session cookies at once!";
-      }
-    } else {
-      otherCookies << cookie;
     }
-  }
-
-  if (!otherCookies.isEmpty()) {
-    Q_EMIT otherCookiesReceived(otherCookies, url);
-  }
-  if (!shibCookie.name().isEmpty()) {
-    Q_EMIT shibbolethCookieReceived(shibCookie, _account);
-  }
 }
 
-void ShibbolethWebView::hideEvent(QHideEvent* event)
+void ShibbolethWebView::closeEvent(QCloseEvent *event)
 {
-    Q_EMIT viewHidden();
+    if (!_accepted) {
-    QWebView::hideEvent(event);
+        Q_EMIT rejected();
+    }
+    QWebView::closeEvent(event);
 }
 
 void ShibbolethWebView::slotLoadStarted()
@@ -142,4 +116,10 @@ void ShibbolethWebView::slotHandleAuthentication(QNetworkReply *reply, QAuthenti
     }
 }
 
+void ShibbolethWebView::accept()
+{
+    _accepted = true;
+    Q_EMIT accepted();
+}
+
 } // ns Mirall

src/creds/shibboleth/shibbolethwebview.h

@@ -14,6 +14,7 @@
 #ifndef MIRALL_WIZARD_SHIBBOLETH_WEB_VIEW_H
 #define MIRALL_WIZARD_SHIBBOLETH_WEB_VIEW_H
 
+#include "owncloudlib.h"
 #include <QList>
 #include <QPointer>
 #include <QWebView>
@@ -27,7 +28,7 @@ namespace Mirall
 class ShibbolethCookieJar;
 class Account;
 
-class ShibbolethWebView : public QWebView
+class OWNCLOUDSYNC_EXPORT ShibbolethWebView : public QWebView
 {
   Q_OBJECT
 
@@ -36,13 +37,12 @@ public:
   ShibbolethWebView(Account *account, ShibbolethCookieJar* jar, QWidget* parent = 0);
   ~ShibbolethWebView();
 
-protected:
+  void closeEvent(QCloseEvent *event);
-  void hideEvent(QHideEvent* event);
 
 Q_SIGNALS:
-  void shibbolethCookieReceived(const QNetworkCookie& cookie, Account* account);
+  void shibbolethCookieReceived(const QNetworkCookie &cookie, Account *account);
-  void viewHidden();
+  void accepted();
-  void otherCookiesReceived(const QList<QNetworkCookie>& cookieList, const QUrl& url);
+  void rejected();
 
 private Q_SLOTS:
   void onNewCookiesForUrl(const QList<QNetworkCookie>& cookieList, const QUrl& url);
@@ -50,9 +50,13 @@ private Q_SLOTS:
   void slotLoadFinished(bool success = true);
   void slotHandleAuthentication(QNetworkReply*,QAuthenticator*);
 
+protected:
+  void accept();
+
 private:
   void setup(Account *account, ShibbolethCookieJar* jar);
   QPointer<Account> _account;
+  bool _accepted;
 };
 
 } // ns Mirall

src/creds/shibbolethcredentials.cpp

@@ -16,18 +16,19 @@
 #include <QSettings>
 #include <QNetworkReply>
 #include <QMessageBox>
-#include <qdebug.h>
+#include <QDebug>
 
 #include "creds/shibbolethcredentials.h"
-#include "creds/shibboleth/shibbolethaccessmanager.h"
 #include "creds/shibboleth/shibbolethwebview.h"
 #include "creds/shibboleth/shibbolethrefresher.h"
-#include "creds/shibboleth/shibbolethconfigfile.h"
+#include "creds/shibbolethcredentials.h"
 #include "shibboleth/shibbolethuserjob.h"
 #include "creds/credentialscommon.h"
 
+#include "mirall/mirallaccessmanager.h"
 #include "mirall/account.h"
 #include "mirall/theme.h"
+#include "mirall/cookiejar.h"
 
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #include <qt5keychain/keychain.h>
@@ -43,7 +44,9 @@ namespace Mirall
 namespace
 {
 
-const char userC[] = "user";
+// Not "user" because it has a special meaning for http
+const char userC[] = "shib_user";
+const char shibCookieNameC[] = "_shibsession_";
 
 int shibboleth_redirect_callback(CSYNC* csync_ctx,
                                  const char* uri)
@@ -65,7 +68,6 @@ int shibboleth_redirect_callback(CSYNC* csync_ctx,
     Account *account = AccountManager::instance()->account();
     ShibbolethCredentials* creds = qobject_cast<ShibbolethCredentials*>(account->credentials());
 
-
     if (!creds) {
       qDebug() << "Not a Shibboleth creds instance!";
       return 1;
@@ -84,18 +86,9 @@ int shibboleth_redirect_callback(CSYNC* csync_ctx,
 ShibbolethCredentials::ShibbolethCredentials()
     : AbstractCredentials(),
       _url(),
-      _shibCookie(),
       _ready(false),
       _stillValid(false),
-      _browser(0),
+      _browser(0)
-      _otherCookies()
-{}
-
-ShibbolethCredentials::ShibbolethCredentials(const QNetworkCookie& cookie, const QMap<QUrl, QList<QNetworkCookie> >& otherCookies)
-    : _shibCookie(cookie),
-      _ready(true),
-      _browser(0),
-      _otherCookies(otherCookies)
 {}
 
 void ShibbolethCredentials::syncContextPreInit(CSYNC* ctx)
@@ -110,29 +103,11 @@ QByteArray ShibbolethCredentials::prepareCookieData() const
     // have any way to get "session_key" module property from
     // csync. Had we have it, then we could just append shibboleth
     // cookies to the "session_key" value and set it in csync module.
-    QList<QNetworkCookie> cookies(AccountManager::instance()->account()->lastAuthCookies());
+    Account *account = AccountManager::instance()->account();
-    QMap<QString, QString> uniqueCookies;
+    QList<QNetworkCookie> cookies = accountCookies(account);
 
-    cookies << _shibCookie;
+    foreach(const QNetworkCookie &cookie, cookies) {
-    // Stuff cookies inside csync, then we can avoid the intermediate HTTP 401 reply
+        cookiesAsString  += cookie.toRawForm(QNetworkCookie::NameAndValueOnly) + QLatin1String("; ");
-    // when https://github.com/owncloud/core/pull/4042 is merged.
-    foreach(QNetworkCookie c, cookies) {
-        const QString cookieName(c.name());
-
-        if (cookieName.startsWith("_shibsession_")) {
-            continue;
-        }
-        uniqueCookies.insert(cookieName, c.value());
-    }
-
-    if (!_shibCookie.name().isEmpty()) {
-        uniqueCookies.insert(_shibCookie.name(), _shibCookie.value());
-    }
-    foreach(const QString& cookieName, uniqueCookies.keys()) {
-        cookiesAsString += cookieName;
-        cookiesAsString += '=';
-        cookiesAsString += uniqueCookies[cookieName];
-        cookiesAsString += "; ";
     }
 
     return cookiesAsString.toLatin1();
@@ -150,9 +125,13 @@ void ShibbolethCredentials::syncContextPreStart (CSYNC* ctx)
 
 bool ShibbolethCredentials::changed(AbstractCredentials* credentials) const
 {
-    ShibbolethCredentials* other(dynamic_cast< ShibbolethCredentials* >(credentials));
+    ShibbolethCredentials* other(qobject_cast< ShibbolethCredentials* >(credentials));
 
-    if (!other || other->cookie() != this->cookie()) {
+    if (!other) {
+        return true;
+    }
+
+    if (_shibCookie != other->_shibCookie || _user != other->_user) {
         return true;
     }
 
@@ -169,17 +148,9 @@ QString ShibbolethCredentials::user() const
     return _user;
 }
 
-QNetworkCookie ShibbolethCredentials::cookie() const
-{
-    return _shibCookie;
-}
-
 QNetworkAccessManager* ShibbolethCredentials::getQNAM() const
 {
-    ShibbolethAccessManager* qnam(new ShibbolethAccessManager(_shibCookie));
+    QNetworkAccessManager* qnam(new MirallAccessManager);
-
-    connect(this, SIGNAL(newCookie(QNetworkCookie)),
-            qnam, SLOT(setCookie(QNetworkCookie)));
     connect(qnam, SIGNAL(finished(QNetworkReply*)),
             this, SLOT(slotReplyFinished(QNetworkReply*)));
     return qnam;
@@ -230,44 +201,30 @@ bool ShibbolethCredentials::stillValid(QNetworkReply *reply)
 
 void ShibbolethCredentials::persist(Account* account)
 {
-    ShibbolethConfigFile cfg;
-
-    cfg.storeCookies(_otherCookies);
-
     storeShibCookie(_shibCookie, account);
-    if (!_user.isEmpty())
+    if (!_user.isEmpty()) {
         account->setCredentialSetting(QLatin1String(userC), _user);
+    }
 }
 
 // only used by Application::slotLogout(). Use invalidateAndFetch for normal usage
 void ShibbolethCredentials::invalidateToken(Account *account)
 {
     Q_UNUSED(account)
+    if (!removeFromCookieJar(_shibCookie)) {
+        qDebug() << "invalidateToken() called but no shibCookie in in cookie jar!";
+    }
+    removeShibCookie(account);
     _shibCookie = QNetworkCookie();
-    storeShibCookie(_shibCookie, account); // store/erase cookie
-
     // ### access to ctx missing, but might not be required at all
     //csync_set_module_property(ctx, "session_key", "");
 }
 
-void ShibbolethCredentials::disposeBrowser()
+void ShibbolethCredentials::onShibbolethCookieReceived(const QNetworkCookie& shibCookie, Account *account)
 {
-    qDebug() << Q_FUNC_INFO;
+    storeShibCookie(shibCookie, account);
-    disconnect(_browser, SIGNAL(viewHidden()),
+    _shibCookie = shibCookie;
-               this, SLOT(slotBrowserHidden()));
+    addToCookieJar(shibCookie);
-    disconnect(_browser, SIGNAL(shibbolethCookieReceived(QNetworkCookie, Account*)),
-               this, SLOT(onShibbolethCookieReceived(QNetworkCookie, Account*)));
-    _browser->hide();
-    _browser->deleteLater();
-    _browser = 0;
-}
-
-void ShibbolethCredentials::onShibbolethCookieReceived(const QNetworkCookie& cookie, Account* account)
-{
-    disposeBrowser();
-    _shibCookie = cookie;
-    storeShibCookie(_shibCookie, account);
-    Q_EMIT newCookie(_shibCookie);
 
     // Now fetch the user...
     // But we must first do a request to webdav so the session is enabled.
@@ -308,11 +265,9 @@ void ShibbolethCredentials::slotUserFetched(const QString &user)
 }
 
 
-void ShibbolethCredentials::slotBrowserHidden()
+void ShibbolethCredentials::slotBrowserAccepted()
 {
-    disposeBrowser();
     _ready = false;
-    _shibCookie = QNetworkCookie();
     Q_EMIT fetched();
 }
 
@@ -355,16 +310,16 @@ void ShibbolethCredentials::slotReadJobDone(QKeychain::Job *job)
     if (job->error() == QKeychain::NoError) {
         ReadPasswordJob *readJob = static_cast<ReadPasswordJob*>(job);
         delete readJob->settings();
-        qDebug() << Q_FUNC_INFO;
         QList<QNetworkCookie> cookies = QNetworkCookie::parseCookies(readJob->textData().toUtf8());
         if (cookies.count() > 0) {
             _shibCookie = cookies.first();
+            addToCookieJar(_shibCookie);
         }
+        // access
         job->setSettings(account->settingsWithGroup(Theme::instance()->appName(), job));
 
         _ready = true;
         _stillValid = true;
-        Q_EMIT newCookie(_shibCookie);
         Q_EMIT fetched();
     } else {
         showLoginWindow(account);
@@ -373,24 +328,47 @@ void ShibbolethCredentials::slotReadJobDone(QKeychain::Job *job)
 
 void ShibbolethCredentials::showLoginWindow(Account* account)
 {
-    if (_browser) {
+    if (!_browser.isNull()) {
         _browser->activateWindow();
         _browser->raise();
         // FIXME On OS X this does not raise properly
         return;
     }
-    ShibbolethConfigFile cfg;
+    _browser = new ShibbolethWebView(account);
-    _browser = new ShibbolethWebView(account, cfg.createCookieJar());
     connect(_browser, SIGNAL(shibbolethCookieReceived(QNetworkCookie, Account*)),
             this, SLOT(onShibbolethCookieReceived(QNetworkCookie, Account*)));
-    connect(_browser, SIGNAL(viewHidden()),
+    connect(_browser, SIGNAL(accepted()),
-            this, SLOT(slotBrowserHidden()));
+            this, SLOT(slotBrowserAccepted()));
     // FIXME If the browser was hidden (e.g. user closed it) without us logging in, the logic gets stuck
     // and can only be unstuck by restarting the app or pressing "Sign in" (we should switch to offline but we don't)
 
     _browser->show();
 }
 
+QList<QNetworkCookie> ShibbolethCredentials::accountCookies(Account *account)
+{
+    return account->networkAccessManager()->cookieJar()->cookiesForUrl(account->url());
+}
+
+QNetworkCookie ShibbolethCredentials::findShibCookie(Account *account, QList<QNetworkCookie> cookies)
+{
+    if(cookies.isEmpty()) {
+        cookies = accountCookies(account);
+    }
+
+    Q_FOREACH(QNetworkCookie cookie, cookies) {
+        if (cookie.name().startsWith(shibCookieNameC)) {
+            return cookie;
+        }
+    }
+    return QNetworkCookie();
+}
+
+QByteArray ShibbolethCredentials::shibCookieName()
+{
+    return QByteArray(shibCookieNameC);
+}
+
 void ShibbolethCredentials::storeShibCookie(const QNetworkCookie &cookie, Account *account)
 {
     WritePasswordJob *job = new WritePasswordJob(Theme::instance()->appName());
@@ -402,5 +380,31 @@ void ShibbolethCredentials::storeShibCookie(const QNetworkCookie &cookie, Accoun
     job->start();
 }
 
+void ShibbolethCredentials::removeShibCookie(Account *account)
+{
+    DeletePasswordJob *job = new DeletePasswordJob(Theme::instance()->appName());
+    job->setSettings(account->settingsWithGroup(Theme::instance()->appName(), job));
+    job->setKey(keychainKey(account->url().toString(), "shibAssertion"));
+    job->start();
+}
+
+void ShibbolethCredentials::addToCookieJar(const QNetworkCookie &cookie)
+{
+    QList<QNetworkCookie> cookies;
+    cookies << cookie;
+    Account *account = AccountManager::instance()->account();
+    QNetworkCookieJar *jar = account->networkAccessManager()->cookieJar();
+    jar->blockSignals(true); // otherwise we'd call ourselves
+    jar->setCookiesFromUrl(cookies, account->url());
+    jar->blockSignals(false);
+}
+
+bool ShibbolethCredentials::removeFromCookieJar(const QNetworkCookie &cookie)
+{
+    Account *account = AccountManager::instance()->account();
+    CookieJar *jar = qobject_cast<CookieJar*>(account->networkAccessManager()->cookieJar());
+    return jar->deleteCookie(cookie);
+}
+
 
 } // ns Mirall

src/creds/shibbolethcredentials.h

@@ -18,6 +18,7 @@
 #include <QMap>
 #include <QNetworkCookie>
 #include <QUrl>
+#include <QPointer>
 
 #include "creds/abstractcredentials.h"
 
@@ -30,13 +31,12 @@ namespace Mirall
 
 class ShibbolethWebView;
 
-class ShibbolethCredentials : public AbstractCredentials
+class OWNCLOUDSYNC_EXPORT ShibbolethCredentials : public AbstractCredentials
 {
 Q_OBJECT
 
 public:
     ShibbolethCredentials();
-    ShibbolethCredentials(const QNetworkCookie& cookie, const QMap<QUrl, QList<QNetworkCookie> >& otherCookies);
 
     void syncContextPreInit(CSYNC* ctx);
     void syncContextPreStart(CSYNC* ctx);
@@ -50,16 +50,18 @@ public:
     void persist(Account *account);
     void invalidateToken(Account *account);
 
-    QNetworkCookie cookie() const;
-
     void showLoginWindow(Account*);
 
+    static QList<QNetworkCookie> accountCookies(Account*);
+    static QNetworkCookie findShibCookie(Account*, QList<QNetworkCookie> cookies = QList<QNetworkCookie>());
+    static QByteArray shibCookieName();
+
 public Q_SLOTS:
     void invalidateAndFetch(Account *account);
 
 private Q_SLOTS:
-    void onShibbolethCookieReceived(const QNetworkCookie& cookie, Account*);
+    void onShibbolethCookieReceived(const QNetworkCookie&, Account*);
-    void slotBrowserHidden();
+    void slotBrowserAccepted();
     void onFetched();
     void slotReadJobDone(QKeychain::Job*);
     void slotInvalidateAndFetchInvalidateDone(QKeychain::Job*);
@@ -73,15 +75,16 @@ Q_SIGNALS:
 
 private:
     void storeShibCookie(const QNetworkCookie &cookie, Account *account);
+    void removeShibCookie(Account *account);
+    void addToCookieJar(const QNetworkCookie &cookie);
+    bool removeFromCookieJar(const QNetworkCookie &cookie);
     QUrl _url;
     QByteArray prepareCookieData() const;
-    void disposeBrowser();
 
-    QNetworkCookie _shibCookie;
     bool _ready;
     bool _stillValid;
-    ShibbolethWebView* _browser;
+    QPointer<ShibbolethWebView> _browser;
-    QMap<QUrl, QList<QNetworkCookie> > _otherCookies;
+    QNetworkCookie _shibCookie;
     QString _user;
 };
 

src/creds/tokencredentials.cpp

@@ -17,8 +17,6 @@
 #include <QDebug>
 #include <QNetworkReply>
 #include <QSettings>
-#include <QInputDialog>
-
 
 #include "mirall/account.h"
 #include "mirall/mirallaccessmanager.h"
@@ -70,6 +68,7 @@ int getauth(const char *prompt,
 }
 
 const char userC[] = "user";
+const char authenticationFailedC[] = "owncloud-authentication-failed";
 
 } // ns
 
@@ -174,22 +173,13 @@ bool TokenCredentials::stillValid(QNetworkReply *reply)
 {
     return ((reply->error() != QNetworkReply::AuthenticationRequiredError)
             // returned if user or password is incorrect
-            && (reply->error() != QNetworkReply::OperationCanceledError));
+            && (reply->error() != QNetworkReply::OperationCanceledError
+                || !reply->property(authenticationFailedC).toBool()));
 }
 
 QString TokenCredentials::queryPassword(bool *ok)
 {
-    qDebug() << AccountManager::instance()->account()->state();
+    return QString();
-    if (ok) {
-        QString str = QInputDialog::getText(0, tr("Enter Password"),
-                                     tr("Please enter %1 password for user '%2':")
-                                     .arg(Theme::instance()->appNameGUI(), _user),
-                                     QLineEdit::Password, QString(), ok);
-        qDebug() << AccountManager::instance()->account()->state();
-        return str;
-    } else {
-        return QString();
-    }
 }
 
 void TokenCredentials::invalidateToken(Account *account)
@@ -221,6 +211,7 @@ void TokenCredentials::slotAuthentication(QNetworkReply* reply, QAuthenticator*
     // instead of utf8 encoding. Instead, we send it manually. Thus, if we reach this signal,
     // those credentials were invalid and we terminate.
     qDebug() << "Stop request: Authentication failed for " << reply->url().toString();
+    reply->setProperty(authenticationFailedC, true);
     reply->close();
 }
 

src/creds/tokencredentials.h

@@ -31,7 +31,7 @@ namespace Mirall
 {
 
 class TokenCredentialsAccessManager;
-class TokenCredentials : public AbstractCredentials
+class OWNCLOUDSYNC_EXPORT TokenCredentials : public AbstractCredentials
 {
     Q_OBJECT
 

src/main.cpp

@@ -1,4 +1,5 @@
 /*
+ *
  * Copyright (C) by Duncan Mac-Vicar P. <duncan@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -11,8 +12,15 @@
  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  * for more details.
  */
+#include <QtGlobal>
+
 #include <signal.h>
 
+#ifdef Q_OS_UNIX
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
 #include "mirall/application.h"
 #include "mirall/theme.h"
 #include "mirall/utility.h"
@@ -51,6 +59,20 @@ int main(int argc, char **argv)
         return 0;
     }
 
+    // check a environment variable for core dumps
+#ifdef Q_OS_UNIX
+    if( !qgetenv("OWNCLOUD_CORE_DUMP").isEmpty() ) {
+        struct rlimit core_limit;
+        core_limit.rlim_cur = RLIM_INFINITY;
+        core_limit.rlim_max = RLIM_INFINITY;
+
+        if (setrlimit(RLIMIT_CORE, &core_limit) < 0) {
+            fprintf(stderr, "Unable to set core dump limit\n");
+        } else {
+            qDebug() << "Core dumps enabled";
+        }
+    }
+#endif
     // if handleStartup returns true, main()
     // needs to terminate here, e.g. because
     // the updater is triggered

src/mirall/account.cpp

@@ -12,9 +12,11 @@
  */
 
 #include "mirall/account.h"
+#include "mirall/cookiejar.h"
 #include "mirall/theme.h"
 #include "mirall/networkjobs.h"
 #include "mirall/mirallconfigfile.h"
+#include "mirall/mirallaccessmanager.h"
 #include "mirall/quotainfo.h"
 #include "creds/abstractcredentials.h"
 #include "creds/credentialsfactory.h"
@@ -75,6 +77,7 @@ Account::Account(AbstractSslErrorHandler *sslErrorHandler, QObject *parent)
 
 Account::~Account()
 {
+    delete _am;
 }
 
 void Account::save()
@@ -161,7 +164,11 @@ AbstractCredentials *Account::credentials() const
 void Account::setCredentials(AbstractCredentials *cred)
 {
     // set active credential manager
+    QNetworkCookieJar *jar = 0;
     if (_am) {
+        jar = _am->cookieJar();
+        jar->setParent(0);
+
         _am->deleteLater();
     }
 
@@ -170,6 +177,9 @@ void Account::setCredentials(AbstractCredentials *cred)
     }
     _credentials = cred;
     _am = _credentials->getQNAM();
+    if (jar) {
+        _am->setCookieJar(jar);
+    }
     connect(_am, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
             SLOT(slotHandleErrors(QNetworkReply*,QList<QSslError>)));
 }
@@ -186,7 +196,12 @@ QList<QNetworkCookie> Account::lastAuthCookies() const
 
 void Account::clearCookieJar()
 {
-    _am->setCookieJar(new QNetworkCookieJar);
+    _am->setCookieJar(new CookieJar);
+}
+
+QNetworkAccessManager *Account::networkAccessManager()
+{
+    return _am;
 }
 
 QNetworkReply *Account::headRequest(const QString &relPath)

src/mirall/account.h

@@ -22,6 +22,7 @@
 #include <QSslCertificate>
 #include <QSslConfiguration>
 #include <QSslError>
+#include "utility.h"
 
 class QSettings;
 class QNetworkReply;
@@ -33,8 +34,9 @@ namespace Mirall {
 class AbstractCredentials;
 class Account;
 class QuotaInfo;
+class MirallAccessManager;
 
-class AccountManager : public QObject {
+class OWNCLOUDSYNC_EXPORT AccountManager : public QObject {
     Q_OBJECT
 public:
     static AccountManager *instance();
@@ -63,7 +65,7 @@ public:
 /**
  * @brief This class represents an account on an ownCloud Server
  */
-class Account : public QObject {
+class OWNCLOUDSYNC_EXPORT Account : public QObject {
     Q_OBJECT
 public:
     enum State { Disconnected = 0, /// no network connection
@@ -142,6 +144,8 @@ public:
 
     void clearCookieJar();
 
+    QNetworkAccessManager* networkAccessManager();
+
     QuotaInfo *quotaInfo();
 signals:
     void stateChanged(int state);

src/mirall/accountsettings.cpp

@@ -241,6 +241,10 @@ void AccountSettings::slotButtonsSetEnabled()
 void AccountSettings::setGeneralErrors( const QStringList& errors )
 {
     _generalErrors = errors;
+    if (_account) {
+        // this will update the message
+        slotAccountStateChanged(_account->state());
+    }
 }
 
 void AccountSettings::folderToModelItem( QStandardItem *item, Folder *f )
@@ -357,7 +361,7 @@ void AccountSettings::slotResetCurrentFolder()
         if( ret == QMessageBox::Yes ) {
             FolderMan *folderMan = FolderMan::instance();
             Folder *f = folderMan->folder(alias);
-            f->slotTerminateSync(true);
+            f->slotTerminateSync();
             f->wipe();
             folderMan->slotScheduleAllFolders();
         }
@@ -380,6 +384,7 @@ void AccountSettings::showConnectionLabel( const QString& message, const QString
     if( _generalErrors.isEmpty() ) {
         ui->connectLabel->setText( message );
         ui->connectLabel->setToolTip(tooltip);
+        ui->connectLabel->setStyleSheet(QString());
     } else {
         const QString msg = _generalErrors.join(QLatin1String("\n"));
         ui->connectLabel->setText( msg );
@@ -473,7 +478,7 @@ void AccountSettings::slotEnableCurrentFolder()
             // message box can return at any time while the thread keeps running,
             // so better check again after the user has responded.
             if ( f->isBusy() && terminate ) {
-                f->slotTerminateSync(false);
+                f->slotTerminateSync();
             }
 
             folderMan->slotEnableFolder( alias, !folderEnabled );
@@ -628,8 +633,9 @@ void AccountSettings::slotSetProgress(const QString& folder, const Progress::Inf
     item->setData( overallSyncString, FolderStatusDelegate::SyncProgressOverallString );
 
     int overallPercent = 0;
-    if( progress._totalSize > 0 ) {
+    if( progress._totalFileCount > 0 ) {
-        overallPercent = qRound(double(completedSize)/double(progress._totalSize) * 100.0);
+        // Add one 'byte' for each files so the percentage is moving when deleting or renaming files
+        overallPercent = qRound(double(completedSize + progress._completedFileCount)/double(progress._totalSize + progress._totalFileCount) * 100.0);
     }
     item->setData( overallPercent, FolderStatusDelegate::SyncProgressOverallPercent);
 }

src/mirall/application.cpp

@@ -64,14 +64,12 @@ static const char optionsC[] =
 
 QString applicationTrPath()
 {
-#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
+#if defined(Q_OS_WIN)
-    return QString::fromLatin1(DATADIR"/"APPLICATION_EXECUTABLE"/i18n/");
-#endif
-#ifdef Q_OS_MAC
-    return QApplication::applicationDirPath()+QLatin1String("/../Resources/Translations"); // path defaults to app dir.
-#endif
-#ifdef Q_OS_WIN
    return QApplication::applicationDirPath();
+#elif defined(Q_OS_MAC)
+    return QApplication::applicationDirPath()+QLatin1String("/../Resources/Translations"); // path defaults to app dir.
+#elif defined(Q_OS_UNIX)
+    return QString::fromLatin1(DATADIR"/"APPLICATION_EXECUTABLE"/i18n/");
 #endif
 }
 }
@@ -139,6 +137,10 @@ Application::Application(int &argc, char **argv) :
             this, SLOT(slotAccountChanged(Account*,Account*)));
 
     // startup procedure.
+    connect(&_checkConnectionTimer, SIGNAL(timeout()), this, SLOT(slotCheckConnection()));
+    _checkConnectionTimer.setInterval(32 * 1000); // check for connection every 32 seconds.
+    _checkConnectionTimer.start();
+    // Also check immediatly
     QTimer::singleShot( 0, this, SLOT( slotCheckConnection() ));
 
     if( cfg.skipUpdateCheck() ) {
@@ -155,6 +157,7 @@ Application::Application(int &argc, char **argv) :
 
 Application::~Application()
 {
+    delete AccountManager::instance()->account();
     // qDebug() << "* Mirall shutdown";
 }
 
@@ -226,8 +229,9 @@ void Application::slotCheckConnection()
         if (account->state() == Account::InvalidCredidential
                 || account->state() == Account::SignedOut) {
             //Do not try to connect if we are logged out
-            if (!_userTriggeredConnect)
+            if (!_userTriggeredConnect) {
                 return;
+            }
         }
 
         if (_conValidator)
@@ -269,6 +273,8 @@ void Application::slotToggleFolderman(int state)
         folderMan->slotScheduleAllFolders();
         break;
     case Account::Disconnected:
+        _checkConnectionTimer.start();
+        // fall through
     case Account::SignedOut:
     case Account::InvalidCredidential:
         folderMan->setSyncEnabled(false);
@@ -289,6 +295,7 @@ void Application::slotConnectionValidatorResult(ConnectionValidator::Status stat
         folderMan->setSyncEnabled(true);
         // queue up the sync for all folders.
         folderMan->slotScheduleAllFolders();
+        _checkConnectionTimer.stop();
     } else {
         // if we have problems here, it's unlikely that syncing will work.
         FolderMan::instance()->setSyncEnabled(false);
@@ -298,7 +305,6 @@ void Application::slotConnectionValidatorResult(ConnectionValidator::Status stat
         if (_userTriggeredConnect) {
             _userTriggeredConnect = false;
         }
-        QTimer::singleShot(30*1000, this, SLOT(slotCheckConnection()));
     }
     _gui->startupConnected( (status == ConnectionValidator::Connected), startupFails);
 

src/mirall/application.h

@@ -18,6 +18,7 @@
 #include <QApplication>
 #include <QPointer>
 #include <QQueue>
+#include <QTimer>
 
 #include "qtsingleapplication.h"
 
@@ -103,6 +104,8 @@ private:
 
     ClientProxy _proxy;
 
+    QTimer _checkConnectionTimer;
+
     friend class ownCloudGui; // for _startupNetworkError
 };
 

src/mirall/clientproxy.h

@@ -18,12 +18,13 @@
 #include <QNetworkProxy>
 
 #include <csync.h>
+#include "utility.h"
 
 namespace Mirall {
 
 class MirallConfigFile;
 
-class ClientProxy : public QObject
+class OWNCLOUDSYNC_EXPORT ClientProxy : public QObject
 {
     Q_OBJECT
 public:

src/mirall/connectionvalidator.h

@@ -14,6 +14,7 @@
 #ifndef CONNECTIONVALIDATOR_H
 #define CONNECTIONVALIDATOR_H
 
+#include "owncloudlib.h"
 #include <QObject>
 #include <QStringList>
 #include <QVariantMap>
@@ -23,7 +24,7 @@ namespace Mirall {
 
 class Account;
 
-class ConnectionValidator : public QObject
+class OWNCLOUDSYNC_EXPORT ConnectionValidator : public QObject
 {
     Q_OBJECT
 public:

src/mirall/cookiejar.cpp

@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) by Daniel Molkentin <danimo@owncloud.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ */
+
+#include "cookiejar.h"
+
+#include "mirall/mirallconfigfile.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QDateTime>
+#include <QNetworkCookie>
+
+namespace Mirall {
+
+namespace {
+  const unsigned int JAR_VERSION = 23;
+}
+
+QDataStream &operator<<(QDataStream &stream, const QList<QNetworkCookie> &list)
+{
+    stream << JAR_VERSION;
+    stream << quint32(list.size());
+    for (int i = 0; i < list.size(); ++i)
+        stream << list.at(i).toRawForm();
+    return stream;
+}
+
+QDataStream &operator>>(QDataStream &stream, QList<QNetworkCookie> &list)
+{
+    list.clear();
+
+    quint32 version;
+    stream >> version;
+
+    if (version != JAR_VERSION)
+        return stream;
+
+    quint32 count;
+    stream >> count;
+    for(quint32 i = 0; i < count; ++i)
+    {
+        QByteArray value;
+        stream >> value;
+        QList<QNetworkCookie> newCookies = QNetworkCookie::parseCookies(value);
+        if (newCookies.count() == 0 && value.length() != 0) {
+            qWarning() << "CookieJar: Unable to parse saved cookie:" << value;
+        }
+        for (int j = 0; j < newCookies.count(); ++j)
+            list.append(newCookies.at(j));
+        if (stream.atEnd())
+            break;
+    }
+    return stream;
+}
+
+CookieJar::CookieJar(QObject *parent) :
+    QNetworkCookieJar(parent)
+{
+    restore();
+}
+
+CookieJar::~CookieJar()
+{
+    save();
+}
+
+bool CookieJar::setCookiesFromUrl(const QList<QNetworkCookie>& cookieList, const QUrl& url)
+{
+  if (QNetworkCookieJar::setCookiesFromUrl(cookieList, url)) {
+    Q_EMIT newCookiesForUrl(cookieList, url);
+    return true;
+  }
+
+  return false;
+}
+
+QList<QNetworkCookie> CookieJar::cookiesForUrl(const QUrl &url) const
+{
+    QList<QNetworkCookie> cookies = QNetworkCookieJar::cookiesForUrl(url);
+    qDebug() << url << "requests:" << cookies;
+    return cookies;
+}
+
+bool CookieJar::deleteCookie(const QNetworkCookie &delCookie)
+{
+    QList<QNetworkCookie> cookies = allCookies();
+    bool removeSucceeded = false;
+    foreach(const QNetworkCookie &cookie, cookies) {
+        // ### cookies are not identical in attriutes, why?
+        if (cookie.name() == delCookie.name()) {
+            cookies.removeOne(cookie);
+            removeSucceeded = true;
+        }
+    }
+    setAllCookies(cookies);
+    return removeSucceeded;
+}
+
+void CookieJar::save()
+{
+    QFile file;
+    file.setFileName(storagePath());
+    qDebug() << storagePath();
+    file.open(QIODevice::WriteOnly);
+    QDataStream stream(&file);
+    stream << allCookies();
+    file.close();
+}
+
+void CookieJar::restore()
+{
+    QFile file;
+    file.setFileName(storagePath());
+    file.open(QIODevice::ReadOnly);
+    QDataStream stream(&file);
+    QList<QNetworkCookie> list;
+    stream >> list;
+    setAllCookies(removeExpired(list));
+    file.close();
+}
+
+QList<QNetworkCookie> CookieJar::removeExpired(const QList<QNetworkCookie> &cookies)
+{
+    QList<QNetworkCookie> updatedList;
+    foreach(const QNetworkCookie &cookie, cookies) {
+        if (cookie.expirationDate() > QDateTime::currentDateTime()) {
+            updatedList << cookie;
+        }
+    }
+    return updatedList;
+}
+
+QString CookieJar::storagePath() const
+{
+  MirallConfigFile cfg;
+  return cfg.configPath() + "/cookies.db";
+}
+
+} // namespace Mirall

src/mirall/cookiejar.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) by Daniel Molkentin <danimo@owncloud.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ */
+
+#ifndef MIRALL_COOKIEJAR_H
+#define MIRALL_COOKIEJAR_H
+
+#include <QNetworkCookieJar>
+
+namespace Mirall {
+
+class CookieJar : public QNetworkCookieJar
+{
+    Q_OBJECT
+public:
+    explicit CookieJar(QObject *parent = 0);
+    ~CookieJar();
+    bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url);
+    QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const;
+
+    virtual bool deleteCookie(const QNetworkCookie & cookie);
+
+signals:
+    void newCookiesForUrl(const QList<QNetworkCookie>& cookieList, const QUrl& url);
+private:
+    void save();
+    void restore();
+    QList<QNetworkCookie> removeExpired(const QList<QNetworkCookie> &cookies);
+    QString storagePath() const;
+
+};
+
+} // namespace Mirall
+
+#endif // MIRALL_COOKIEJAR_H

src/mirall/folder.cpp

@@ -49,8 +49,11 @@ CSYNC_EXCLUDE_TYPE csync_excluded(CSYNC *ctx, const char *path, int filetype);
 #include <QTimer>
 #include <QUrl>
 #include <QDir>
+
+#ifndef TOKEN_AUTH_ONLY
 #include <QMessageBox>
 #include <QPushButton>
+#endif
 
 namespace Mirall {
 
@@ -298,7 +301,7 @@ void Folder::bubbleUpSyncResult()
 
     SyncRunFileLog syncFileLog;
 
-    syncFileLog.start(path(),  _engine->stopWatch() );
+    syncFileLog.start(path(), _engine ? _engine->stopWatch() : Utility::StopWatch() );
 
     QElapsedTimer timer;
     timer.start();
@@ -463,7 +466,7 @@ void Folder::slotThreadTreeWalkResult(const SyncFileItemVector& items)
     _syncResult.setSyncFileItemVector(items);
 }
 
-void Folder::slotTerminateSync(bool block)
+void Folder::slotTerminateSync()
 {
     qDebug() << "folder " << alias() << " Terminating!";
 
@@ -473,14 +476,10 @@ void Folder::slotTerminateSync(bool block)
         // Do not display an error message, user knows his own actions.
         // _errors.append( tr("The CSync thread terminated.") );
         // _csyncError = true;
-        if (!block) {
+        setSyncEnabled(false);
-            setSyncState(SyncResult::SyncAbortRequested);
+        setSyncState(SyncResult::SyncAbortRequested);
-            return;
+        return;
-        }
-
-        slotSyncFinished();
     }
-    setSyncEnabled(false);
 }
 
 // This removes the csync File database
@@ -670,6 +669,7 @@ void Folder::slotTransmissionProgress(const Progress::Info &pi)
 
 void Folder::slotAboutToRemoveAllFiles(SyncFileItem::Direction direction, bool *cancel)
 {
+#ifndef TOKEN_AUTH_ONLY
     QString msg = direction == SyncFileItem::Down ?
         tr("This sync would remove all the files in the local sync folder '%1'.\n"
            "If you or your administrator have reset your account on the server, choose "
@@ -689,7 +689,11 @@ void Folder::slotAboutToRemoveAllFiles(SyncFileItem::Direction direction, bool *
     *cancel = msgBox.clickedButton() == keepBtn;
     if (*cancel) {
         wipe();
+        // speed up next sync
+        _lastEtag = QString();
+        QTimer::singleShot(50, this, SLOT(slotPollTimerTimeout()));
     }
+#endif
 }
 
 SyncFileStatus Folder::fileStatus( const QString& fileName )

src/mirall/folder.h

@@ -59,7 +59,7 @@ typedef enum SyncFileStatus_s {
 } SyncFileStatus;
 
 
-class Folder : public QObject
+class OWNCLOUDSYNC_EXPORT Folder : public QObject
 {
     Q_OBJECT
 
@@ -148,10 +148,8 @@ public slots:
 
      /**
        * terminate the current sync run
-       *
-       * If block is true, this will block synchroniously for the sync thread to finish.
        */
-     void slotTerminateSync(bool block);
+     void slotTerminateSync();
 
      void slotAboutToRemoveAllFiles(SyncFileItem::Direction, bool*);
 

src/mirall/folderman.cpp

@@ -27,8 +27,10 @@
 #include <shlobj.h>
 #endif
 
-#include <QDesktopServices>
+#ifndef TOKEN_AUTH_ONLY
 #include <QMessageBox>
+#endif
+
 #include <QtCore>
 
 namespace Mirall {
@@ -143,13 +145,13 @@ int FolderMan::setupFolders()
   unloadAllFolders();
 
   QDir dir( _folderConfigPath );
-  dir.setFilter(QDir::Files);
+  //We need to include hidden files just in case the alias starts with '.'
+  dir.setFilter(QDir::Files | QDir::Hidden);
   QStringList list = dir.entryList();
 
   foreach ( const QString& alias, list ) {
     Folder *f = setupFolderFromConfigFile( alias );
     if( f ) {
-        registerFolderMonitor(f);
         slotScheduleSync(alias);
         emit( folderSyncStateChange( f->alias() ) );
     }
@@ -163,7 +165,8 @@ int FolderMan::setupFolders()
 
 bool FolderMan::ensureJournalGone(const QString &localPath)
 {
-
+	// FIXME move this to UI, not libowncloudsync
+#ifndef TOKEN_AUTH_ONLY
     // remove old .csync_journal file
     QString stateDbFile = localPath+QLatin1String("/.csync_journal.db");
     while (QFile::exists(stateDbFile) && !QFile::remove(stateDbFile)) {
@@ -177,6 +180,7 @@ bool FolderMan::ensureJournalGone(const QString &localPath)
             return false;
         }
     }
+#endif
     return true;
 }
 
@@ -297,6 +301,7 @@ Folder* FolderMan::setupFolderFromConfigFile(const QString &file) {
     qDebug() << "Adding folder to Folder Map " << folder;
     _folderMap[alias] = folder;
     if (paused) {
+        folder->setSyncEnabled(!paused);
         _disabledFolders.insert(folder);
     }
 
@@ -307,6 +312,8 @@ Folder* FolderMan::setupFolderFromConfigFile(const QString &file) {
     connect(folder, SIGNAL(syncFinished(SyncResult)), SLOT(slotFolderSyncFinished(SyncResult)));
 
     _folderChangeSignalMapper->setMapping( folder, folder->alias() );
+
+    registerFolderMonitor(folder);
     return folder;
 }
 
@@ -347,9 +354,10 @@ void FolderMan::terminateSyncProcess( const QString& alias )
     if( ! folderAlias.isEmpty() && _folderMap.contains(folderAlias) ) {
         Folder *f = _folderMap[folderAlias];
         if( f ) {
-            f->slotTerminateSync(true);
+            f->slotTerminateSync();
-            if(_currentSyncFolder == folderAlias )
+            if(_currentSyncFolder == folderAlias ) {
                 _currentSyncFolder.clear();
+            }
         }
     }
 }

src/mirall/folderman.h

@@ -30,7 +30,7 @@ class SyncResult;
 
 namespace Mirall {
 
-class FolderMan : public QObject
+class OWNCLOUDSYNC_EXPORT FolderMan : public QObject
 {
     Q_OBJECT
 public:

src/mirall/folderwatcher.cpp

@@ -29,7 +29,7 @@
 #include "mirall/folderwatcher_win.h"
 #elif defined(Q_OS_MAC)
 #include "mirall/folderwatcher_mac.h"
-#elif defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
+#elif defined(Q_OS_UNIX)
 #include "mirall/folderwatcher_linux.h"
 #endif
 
@@ -115,7 +115,7 @@ void FolderWatcher::changeDetected( const QString& path )
 
 void FolderWatcher::changeDetected( const QStringList& paths )
 {
-    qDebug() << Q_FUNC_INFO << paths;
+    // qDebug() << Q_FUNC_INFO << paths;
 
     // TODO: this shortcut doesn't look very reliable:
     //   - why is the timeout only 1 second?

src/mirall/folderwatcher_linux.cpp

@@ -172,7 +172,7 @@ void FolderWatcherPrivate::slotReceivedNotification(int fd)
         if (event->len > 0 && event->wd > -1) {
             // qDebug() << Q_FUNC_INFO << event->name;
             if (QByteArray(event->name).startsWith(".csync") ||
-                    QByteArray(event->name) == ".owncloudsync.log") {
+                    QByteArray(event->name).startsWith(".owncloudsync.log")) {
                 // qDebug() << "ignore journal";
             } else {
                 const QString p = _watches[event->wd];

src/mirall/logger.h

@@ -22,6 +22,8 @@
 #include <QTextStream>
 #include <qmutex.h>
 
+#include "utility.h"
+
 namespace Mirall {
 
 struct Log{
@@ -35,7 +37,7 @@ struct Log{
   QString message;
 };
 
-class Logger : public QObject
+class OWNCLOUDSYNC_EXPORT Logger : public QObject
 {
   Q_OBJECT
 public:

src/mirall/mirallaccessmanager.cpp

@@ -14,7 +14,9 @@
 #include <QNetworkRequest>
 #include <QNetworkProxy>
 #include <QAuthenticator>
+#include <QSslConfiguration>
 
+#include "mirall/cookiejar.h"
 #include "mirall/mirallaccessmanager.h"
 #include "mirall/utility.h"
 
@@ -24,12 +26,13 @@ namespace Mirall
 MirallAccessManager::MirallAccessManager(QObject* parent)
     : QNetworkAccessManager (parent)
 {
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) && defined(Q_OS_MAC)
     // FIXME Workaround http://stackoverflow.com/a/15707366/2941 https://bugreports.qt-project.org/browse/QTBUG-30434
     QNetworkProxy proxy = this->proxy();
     proxy.setHostName(" ");
     setProxy(proxy);
 #endif
+    setCookieJar(new CookieJar);
     QObject::connect(this, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                      this, SLOT(slotProxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
 }

src/mirall/mirallaccessmanager.h

@@ -14,12 +14,13 @@
 #ifndef MIRALL_ACCESS_MANAGER_H
 #define MIRALL_ACCESS_MANAGER_H
 
+#include "owncloudlib.h"
 #include <QNetworkAccessManager>
 
 namespace Mirall
 {
 
-class MirallAccessManager : public QNetworkAccessManager
+class OWNCLOUDSYNC_EXPORT MirallAccessManager : public QNetworkAccessManager
 {
     Q_OBJECT
 

src/mirall/mirallconfigfile.cpp

@@ -22,7 +22,11 @@
 #include "creds/abstractcredentials.h"
 #include "creds/credentialsfactory.h"
 
+#ifndef TOKEN_AUTH_ONLY
 #include <QWidget>
+#include <QHeaderView>
+#endif
+
 #include <QCoreApplication>
 #include <QDir>
 #include <QFile>
@@ -30,7 +34,6 @@
 #include <QSettings>
 #include <QDebug>
 #include <QNetworkProxy>
-#include <QHeaderView>
 
 #define DEFAULT_REMOTE_POLL_INTERVAL 30000 // default remote poll time in milliseconds
 #define DEFAULT_MAX_LOG_LINES 20000
@@ -109,20 +112,25 @@ void MirallConfigFile::setOptionalDesktopNotifications(bool show)
 
 void MirallConfigFile::saveGeometry(QWidget *w)
 {
+#ifndef TOKEN_AUTH_ONLY
     Q_ASSERT(!w->objectName().isNull());
     QSettings settings(configFile(), QSettings::IniFormat);
     settings.beginGroup(w->objectName());
     settings.setValue(QLatin1String(geometryC), w->saveGeometry());
     settings.sync();
+#endif
 }
 
 void MirallConfigFile::restoreGeometry(QWidget *w)
 {
+#ifndef TOKEN_AUTH_ONLY
     w->restoreGeometry(getValue(geometryC, w->objectName()).toByteArray());
+#endif
 }
 
 void MirallConfigFile::saveGeometryHeader(QHeaderView *header)
 {
+#ifndef TOKEN_AUTH_ONLY
     if(!header) return;
     Q_ASSERT(!header->objectName().isNull());
 
@@ -130,16 +138,19 @@ void MirallConfigFile::saveGeometryHeader(QHeaderView *header)
     settings.beginGroup(header->objectName());
     settings.setValue(QLatin1String(geometryC), header->saveState());
     settings.sync();
+#endif
 }
 
 void MirallConfigFile::restoreGeometryHeader(QHeaderView *header)
 {
+#ifndef TOKEN_AUTH_ONLY
     if(!header) return;
     Q_ASSERT(!header->objectName().isNull());
 
     QSettings settings(configFile(), QSettings::IniFormat);
     settings.beginGroup(header->objectName());
     header->restoreState(getValue(geometryC, header->objectName()).toByteArray());
+#endif
 }
 
 QVariant MirallConfigFile::getPolicySetting(const QString &setting, const QVariant& defaultValue) const

src/mirall/mirallconfigfile.h

@@ -15,6 +15,7 @@
 #ifndef MIRALLCONFIGFILE_H
 #define MIRALLCONFIGFILE_H
 
+#include "owncloudlib.h"
 #include <QSharedPointer>
 #include <QString>
 #include <QVariant>
@@ -26,7 +27,7 @@ namespace Mirall {
 
 class AbstractCredentials;
 
-class MirallConfigFile
+class OWNCLOUDSYNC_EXPORT MirallConfigFile
 {
 public:
     MirallConfigFile();

src/mirall/networkjobs.cpp

@@ -34,7 +34,6 @@
 
 #include "creds/credentialsfactory.h"
 #include "creds/abstractcredentials.h"
-#include "creds/shibbolethcredentials.h"
 
 Q_DECLARE_METATYPE(QTimer*)
 
@@ -148,7 +147,7 @@ void AbstractNetworkJob::slotFinished()
     _responseTimestamp = QString::fromAscii(_reply->rawHeader("Date"));
     _duration = _durationTimer.elapsed();
 
-    finished();
+    bool discard = finished();
     AbstractCredentials *creds = _account->credentials();
     if (!creds->stillValid(_reply) &&! _ignoreCredentialFailure
             && _account->state() != Account::InvalidCredidential) {
@@ -164,7 +163,9 @@ void AbstractNetworkJob::slotFinished()
             creds->fetch(_account);
         }
     }
-    deleteLater();
+    if (discard) {
+        deleteLater();
+    }
 }
 
 quint64 AbstractNetworkJob::duration()
@@ -228,7 +229,7 @@ void RequestEtagJob::start()
     AbstractNetworkJob::start();
 }
 
-void RequestEtagJob::finished()
+bool RequestEtagJob::finished()
 {
     if (reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 207) {
         // Parse DAV response
@@ -247,6 +248,7 @@ void RequestEtagJob::finished()
         }
         emit etagRetreived(etag);
     }
+    return true;
 }
 
 /*********************************************************************************************/
@@ -265,9 +267,10 @@ void MkColJob::start()
    AbstractNetworkJob::start();
 }
 
-void MkColJob::finished()
+bool MkColJob::finished()
 {
     emit finished(reply()->error());
+    return true;
 }
 
 /*********************************************************************************************/
@@ -297,7 +300,7 @@ void LsColJob::start()
     AbstractNetworkJob::start();
 }
 
-void LsColJob::finished()
+bool LsColJob::finished()
 {
     if (reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 207) {
         // Parse DAV response
@@ -323,13 +326,20 @@ void LsColJob::finished()
         }
         emit directoryListing(folders);
     }
+    return true;
 }
 
 /*********************************************************************************************/
 
+namespace {
+const char statusphpC[] = "status.php";
+const char owncloudDirC[] = "owncloud/";
+}
+
 CheckServerJob::CheckServerJob(Account *account, bool followRedirect, QObject *parent)
-    : AbstractNetworkJob(account, QLatin1String("status.php") , parent)
+    : AbstractNetworkJob(account, QLatin1String(statusphpC) , parent)
     , _followRedirects(followRedirect)
+    , _subdirFallback(false)
     , _redirectCount(0)
 {
     setIgnoreCredentialFailure(true);
@@ -364,7 +374,7 @@ bool CheckServerJob::installed(const QVariantMap &info)
     return info.value(QLatin1String("installed")).toBool();
 }
 
-void CheckServerJob::finished()
+bool CheckServerJob::finished()
 {
     account()->setSslConfiguration(reply()->sslConfiguration());
 
@@ -383,10 +393,20 @@ void CheckServerJob::finished()
             resetTimeout();
             setReply(getRequest(redirectUrl));
             setupConnections(reply());
-            return;
+            return false;
         }
     }
 
+    // The serverInstalls to /owncloud. Let's try that if the file wasn't found
+    // at the original location
+    if ((reply()->error() == QNetworkReply::ContentNotFoundError) && (!_subdirFallback)) {
+        _subdirFallback = true;
+        setPath(QLatin1String(owncloudDirC)+QLatin1String(statusphpC));
+        start();
+        qDebug() << "Retrying with" << reply()->url();
+        return false;
+    }
+
     bool success = false;
     QVariantMap status = QtJson::parse(QString::fromUtf8(reply()->readAll()), success).toMap();
     // empty or invalid response
@@ -401,7 +421,9 @@ void CheckServerJob::finished()
         emit instanceFound(reply()->url(), status);
     } else {
         qDebug() << "No proper answer on " << requestedUrl;
+        emit instanceNotFound(reply());
     }
+    return true;
 }
 
 /*********************************************************************************************/
@@ -451,7 +473,7 @@ QList<QByteArray> PropfindJob::properties() const
     return _properties;
 }
 
-void PropfindJob::finished()
+bool PropfindJob::finished()
 {
     int http_result_code = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 
@@ -486,6 +508,7 @@ void PropfindJob::finished()
         qDebug() << "Quota request *not* successful, http result code is" << http_result_code
                  << (http_result_code == 302 ? reply()->header(QNetworkRequest::LocationHeader).toString()  : QLatin1String(""));
     }
+    return true;
 }
 
 /*********************************************************************************************/
@@ -502,9 +525,10 @@ void EntityExistsJob::start()
     AbstractNetworkJob::start();
 }
 
-void EntityExistsJob::finished()
+bool EntityExistsJob::finished()
 {
     emit exists(reply());
+    return true;
 }
 
 /*********************************************************************************************/
@@ -535,7 +559,7 @@ void CheckQuotaJob::start()
     AbstractNetworkJob::start();
 }
 
-void CheckQuotaJob::finished()
+bool CheckQuotaJob::finished()
 {
     if (reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 207) {
         // Parse DAV response
@@ -560,6 +584,7 @@ void CheckQuotaJob::finished()
         qint64 total = quotaUsedBytes + quotaAvailableBytes;
         emit quotaRetrieved(total, quotaUsedBytes);
     }
+    return true;
 }
 
 NetworkJobTimeoutPauser::NetworkJobTimeoutPauser(QNetworkReply *reply)

src/mirall/networkjobs.h

@@ -16,6 +16,7 @@
 #ifndef NETWORKJOBS_H
 #define NETWORKJOBS_H
 
+#include "owncloudlib.h"
 #include <QObject>
 #include <QNetworkRequest>
 #include <QNetworkReply>
@@ -46,7 +47,7 @@ private:
 /**
  * @brief The AbstractNetworkJob class
  */
-class AbstractNetworkJob : public QObject {
+class OWNCLOUDSYNC_EXPORT AbstractNetworkJob : public QObject {
     Q_OBJECT
 public:
     explicit AbstractNetworkJob(Account *account, const QString &path, QObject* parent = 0);
@@ -62,8 +63,6 @@ public:
     void setReply(QNetworkReply *reply);
     QNetworkReply* reply() const { return _reply; }
 
-    void setTimeout(qint64 msec);
-    void resetTimeout();
 
     void setIgnoreCredentialFailure(bool ignore);
     bool ignoreCredentialFailure() const { return _ignoreCredentialFailure; }
@@ -71,6 +70,9 @@ public:
     QString responseTimestamp();
     quint64 duration();
 
+public slots:
+    void setTimeout(qint64 msec);
+    void resetTimeout();
 signals:
     void networkError(QNetworkReply *reply);
 protected:
@@ -87,7 +89,7 @@ protected:
     QNetworkReply* headRequest(const QUrl &url);
 
     int maxRedirects() const { return 10; }
-    virtual void finished() = 0;
+    virtual bool finished() = 0;
     QString       _responseTimestamp;
     QElapsedTimer _durationTimer;
     quint64       _duration;
@@ -108,7 +110,7 @@ private:
 /**
  * @brief The EntityExistsJob class
  */
-class EntityExistsJob : public AbstractNetworkJob {
+class OWNCLOUDSYNC_EXPORT EntityExistsJob : public AbstractNetworkJob {
     Q_OBJECT
 public:
     explicit EntityExistsJob(Account *account, const QString &path, QObject* parent = 0);
@@ -118,13 +120,13 @@ signals:
     void exists(QNetworkReply*);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 };
 
 /**
  * @brief The LsColJob class
  */
-class LsColJob : public AbstractNetworkJob {
+class OWNCLOUDSYNC_EXPORT LsColJob : public AbstractNetworkJob {
     Q_OBJECT
 public:
     explicit LsColJob(Account *account, const QString &path, QObject *parent = 0);
@@ -134,7 +136,7 @@ signals:
     void directoryListing(const QStringList &items);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 };
 
 /**
@@ -152,7 +154,7 @@ signals:
     void result(const QVariantMap &values);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 
 private:
     QList<QByteArray> _properties;
@@ -161,7 +163,7 @@ private:
 /**
  * @brief The MkColJob class
  */
-class MkColJob : public AbstractNetworkJob {
+class OWNCLOUDSYNC_EXPORT MkColJob : public AbstractNetworkJob {
     Q_OBJECT
 public:
     explicit MkColJob(Account *account, const QString &path, QObject *parent = 0);
@@ -171,13 +173,13 @@ signals:
     void finished(QNetworkReply::NetworkError);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 };
 
 /**
  * @brief The CheckServerJob class
  */
-class CheckServerJob : public AbstractNetworkJob {
+class OWNCLOUDSYNC_EXPORT CheckServerJob : public AbstractNetworkJob {
     Q_OBJECT
 public:
     explicit CheckServerJob(Account *account, bool followRedirect = false, QObject *parent = 0);
@@ -189,14 +191,16 @@ public:
 
 signals:
     void instanceFound(const QUrl&url, const QVariantMap &info);
+    void instanceNotFound(QNetworkReply *reply);
     void timeout(const QUrl&url);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
     virtual void slotTimeout();
 
 private:
     bool _followRedirects;
+    bool _subdirFallback;
     int _redirectCount;
 };
 
@@ -214,7 +218,7 @@ signals:
     void etagRetreived(const QString &etag);
 
 private slots:
-    virtual void finished();
+    virtual bool finished();
 };
 
 /**
@@ -230,7 +234,8 @@ signals:
     void quotaRetrieved(qint64 totalBytes, qint64 availableBytes);
 
 private slots:
-    virtual void finished();
+    /** Return true if you want the job to be deleted after this slot has finished running. */
+    virtual bool finished();
 };
 
 } // namespace Mirall

src/mirall/owncloudgui.cpp

@@ -146,6 +146,7 @@ void ownCloudGui::slotOpenPath(const QString &path)
 void ownCloudGui::slotAccountStateChanged()
 {
     setupContextMenu();
+    slotComputeOverallSyncStatus();
 }
 
 void ownCloudGui::startupConnected( bool connected, const QStringList& fails )
@@ -160,6 +161,8 @@ void ownCloudGui::startupConnected( bool connected, const QStringList& fails )
     }
 
     _startupFails = fails; // store that for the settings dialog once it appears.
+    if( !_settingsDialog.isNull() )
+        _settingsDialog->setGeneralErrors( _startupFails );
 
 }
 
@@ -171,6 +174,11 @@ void ownCloudGui::slotComputeOverallSyncStatus()
             _tray->setToolTip(tr("Please sign in"));
             return;
         }
+        if (a->state() == Account::Disconnected) {
+            _tray->setIcon(Theme::instance()->syncStateIcon( SyncResult::Unavailable, true));
+            _tray->setToolTip(tr("Disconnected from server"));
+            return;
+        }
     }
     // display the info of the least successful sync (eg. not just display the result of the latest sync
     QString trayMessage;

src/mirall/owncloudpropagator.cpp

@@ -60,6 +60,13 @@ void PropagateItemJob::done(SyncFileItem::Status status, const QString &errorStr
         break;
     case SyncFileItem::FatalError:
     case SyncFileItem::NormalError:
+#ifdef OWNCLOUD_5XX_NO_BLACKLIST
+        if (_item._httpErrorCode / 100 == 5) {
+            // In this configuration, never blacklist error 5xx
+            qDebug() << "Do not blacklist error " << _item._httpErrorCode;
+            break;
+        }
+#endif
         _propagator->_journal->updateBlacklistEntry( record );
         break;
     case SyncFileItem::Success:
@@ -124,7 +131,7 @@ bool PropagateItemJob::checkForProblemsWithShared(int httpStatusCode, const QStr
             _restoreJob.reset(newJob);
             connect(_restoreJob.data(), SIGNAL(completed(SyncFileItem)),
                     this, SLOT(slotRestoreJobCompleted(SyncFileItem)));
-            _restoreJob->start();
+            QMetaObject::invokeMethod(newJob, "start");
         }
         return true;
     }
@@ -332,5 +339,17 @@ void PropagateDirectory::slotSubJobReady()
     }
 }
 
+int OwncloudPropagator::httpTimeout()
+{
+    static int timeout;
+    if (!timeout) {
+        timeout = qgetenv("OWNCLOUD_TIMEOUT").toUInt();
+        if (timeout == 0) {
+            timeout = 300; // default to 300 secs
+        }
+    }
+    return timeout;
+}
+
 
 }

src/mirall/owncloudpropagator.h

@@ -210,17 +210,18 @@ public:
     /* The number of currently active jobs */
     int _activeJobs;
 
-
     bool isInSharedDirectory(const QString& file);
 
-
     void abort() {
         _abortRequested.fetchAndStoreOrdered(true);
-        if (_rootJob)
+        if (_rootJob) {
             _rootJob->abort();
+        }
         emit finished();
     }
 
+    // timeout in seconds
+    static int httpTimeout();
 
 signals:
     void completed(const SyncFileItem &);

src/mirall/owncloudsetupwizard.cpp

@@ -138,7 +138,7 @@ void OwncloudSetupWizard::slotDetermineAuthType(const QString &urlString)
     CheckServerJob *job = new CheckServerJob(_ocWizard->account(), false, this);
     job->setIgnoreCredentialFailure(true);
     connect(job, SIGNAL(instanceFound(QUrl,QVariantMap)), SLOT(slotOwnCloudFoundAuth(QUrl,QVariantMap)));
-    connect(job, SIGNAL(networkError(QNetworkReply*)), SLOT(slotNoOwnCloudFoundAuth(QNetworkReply*)));
+    connect(job, SIGNAL(instanceNotFound(QNetworkReply*)), SLOT(slotNoOwnCloudFoundAuth(QNetworkReply*)));
     connect(job, SIGNAL(timeout(const QUrl&)), SLOT(slotNoOwnCloudFoundAuthTimeout(const QUrl&)));
     job->setTimeout(10*1000);
     job->start();
@@ -152,7 +152,8 @@ void OwncloudSetupWizard::slotOwnCloudFoundAuth(const QUrl& url, const QVariantM
                                         .arg(CheckServerJob::versionString(info))
                                         .arg(CheckServerJob::version(info)));
 
-    if (url.path().endsWith("/status.php")) {
+    QString p = url.path();
+    if (p.endsWith("/status.php")) {
         // We might be redirected, update the account
         QUrl redirectedUrl = url;
         redirectedUrl.setPath(url.path().left(url.path().length() - 11));
@@ -186,7 +187,8 @@ void OwncloudSetupWizard::slotNoOwnCloudFoundAuthTimeout(const QUrl&url)
 void OwncloudSetupWizard::slotConnectToOCUrl( const QString& url )
 {
     qDebug() << "Connect to url: " << url;
-    _ocWizard->account()->setCredentials(_ocWizard->getCredentials());
+    AbstractCredentials *creds = _ocWizard->getCredentials();
+    _ocWizard->account()->setCredentials(creds);
     _ocWizard->setField(QLatin1String("OCUrl"), url );
     _ocWizard->appendToConfigurationLog(tr("Trying to connect to %1 at %2...")
                                         .arg( Theme::instance()->appNameGUI() ).arg(url) );
@@ -196,7 +198,9 @@ void OwncloudSetupWizard::slotConnectToOCUrl( const QString& url )
 
 void OwncloudSetupWizard::testOwnCloudConnect()
 {
-    ValidateDavAuthJob *job = new ValidateDavAuthJob(_ocWizard->account(), this);
+    Account *account = _ocWizard->account();
+
+    ValidateDavAuthJob *job = new ValidateDavAuthJob(account, this);
     job->setIgnoreCredentialFailure(true);
     connect(job, SIGNAL(authResult(QNetworkReply*)), SLOT(slotConnectionCheck(QNetworkReply*)));
     job->start();
@@ -355,7 +359,7 @@ bool OwncloudSetupWizard::ensureStartFromScratch(const QString &localFolder) {
             QMessageBox::StandardButton but;
             but = QMessageBox::question( 0, tr("Folder rename failed"),
                                          tr("Can't remove and back up the folder because the folder or a file in it is open in another program."
-                                            "Please close the folder or file and hit retry or cancel the setup."), QMessageBox::Retry | QMessageBox::Abort, QMessageBox::Retry);
+                                            " Please close the folder or file and hit retry or cancel the setup."), QMessageBox::Retry | QMessageBox::Abort, QMessageBox::Retry);
             if( but == QMessageBox::Abort ) {
                 break;
             }
@@ -446,7 +450,7 @@ void DetermineAuthTypeJob::start()
     AbstractNetworkJob::start();
 }
 
-void DetermineAuthTypeJob::finished()
+bool DetermineAuthTypeJob::finished()
 {
     QUrl redirection = reply()->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
     qDebug() << Q_FUNC_INFO << redirection.toString();
@@ -472,6 +476,7 @@ void DetermineAuthTypeJob::finished()
             emit authType(WizardCommon::HttpCreds);
         }
     }
+    return true;
 }
 
 ValidateDavAuthJob::ValidateDavAuthJob(Account *account, QObject *parent)
@@ -481,15 +486,17 @@ ValidateDavAuthJob::ValidateDavAuthJob(Account *account, QObject *parent)
 
 void ValidateDavAuthJob::start()
 {
-    QNetworkReply *reply = getRequest(account()->davPath());
+    QString p = account()->davPath();
+    QNetworkReply *reply = getRequest(p);
     setReply(reply);
     setupConnections(reply);
     AbstractNetworkJob::start();
 }
 
-void ValidateDavAuthJob::finished()
+bool ValidateDavAuthJob::finished()
 {
     emit authResult(reply());
+    return true;
 }
 
 } // ns Mirall

src/mirall/owncloudsetupwizard.h

@@ -39,7 +39,7 @@ public:
 signals:
     void authResult(QNetworkReply*);
 private slots:
-    void finished();
+    bool finished();
 };
 
 class DetermineAuthTypeJob : public AbstractNetworkJob {
@@ -50,7 +50,7 @@ public:
 signals:
     void authType(WizardCommon::AuthType);
 private slots:
-    void finished();
+    bool finished();
 private:
     int _redirects;
 };

src/mirall/owncloudtheme.cpp

@@ -16,10 +16,13 @@
 
 #include <QString>
 #include <QVariant>
+#ifndef TOKEN_AUTH_ONLY
 #include <QPixmap>
 #include <QIcon>
 #include <QStyle>
 #include <QApplication>
+#endif
+#include <QCoreApplication>
 
 #include <QDebug>
 
@@ -47,7 +50,7 @@ QString ownCloudTheme::about() const
     const QString gitSha1(QLatin1String(GIT_SHA1));
     devString = QCoreApplication::translate("ownCloudTheme::about()",
                    "<p><small>Built from Git revision <a href=\"%1\">%2</a>"
-                   " on %3, %4 using Qt %5.</small><p>")
+                   " on %3, %4 using Qt %5.</small></p>")
             .arg(githubPrefix+gitSha1).arg(gitSha1.left(6))
             .arg(__DATE__).arg(__TIME__)
             .arg(QT_VERSION_STR);
@@ -66,6 +69,7 @@ QString ownCloudTheme::about() const
 
 }
 
+#ifndef TOKEN_AUTH_ONLY
 QIcon ownCloudTheme::trayFolderIcon( const QString& ) const
 {
     QPixmap fallback = qApp->style()->standardPixmap(QStyle::SP_FileDialogNewFolder);
@@ -83,6 +87,8 @@ QIcon ownCloudTheme::applicationIcon( ) const
     return themeIcon( QLatin1String("owncloud-icon") );
 }
 
+#endif
+
 QVariant ownCloudTheme::customMedia(Theme::CustomMediaType type)
 {
     if (type == Theme::oCSetupTop) {
@@ -100,6 +106,7 @@ QString ownCloudTheme::helpUrl() const
     return QString::fromLatin1("http://doc.owncloud.org/desktop/%1.%2/").arg(MIRALL_VERSION_MAJOR).arg(MIRALL_VERSION_MINOR);
 }
 
+#ifndef TOKEN_AUTH_ONLY
 QColor ownCloudTheme::wizardHeaderBackgroundColor() const
 {
     return QColor("#1d2d42");
@@ -114,7 +121,7 @@ QPixmap ownCloudTheme::wizardHeaderLogo() const
 {
     return QPixmap(":/mirall/theme/colored/wizard_logo.png");
 }
-
+#endif
 
 
 }

src/mirall/progressdispatcher.cpp

@@ -25,21 +25,31 @@ ProgressDispatcher* ProgressDispatcher::_instance = 0;
 QString Progress::asResultString( const SyncFileItem& item)
 {
     switch(item._instruction) {
-        case CSYNC_INSTRUCTION_CONFLICT:
+    case CSYNC_INSTRUCTION_CONFLICT:
-        case CSYNC_INSTRUCTION_SYNC:
+    case CSYNC_INSTRUCTION_SYNC:
-        case CSYNC_INSTRUCTION_NEW:
+    case CSYNC_INSTRUCTION_NEW:
-            if (item._direction != SyncFileItem::Up)
+        if (item._direction != SyncFileItem::Up) {
-                return QCoreApplication::translate( "progress", "Downloaded");
+            return QCoreApplication::translate( "progress", "Downloaded");
-            else
+        } else {
-                return QCoreApplication::translate( "progress", "Uploaded");
+            return QCoreApplication::translate( "progress", "Uploaded");
-        case CSYNC_INSTRUCTION_REMOVE:
+        }
-            return QCoreApplication::translate( "progress", "Deleted");
+    case CSYNC_INSTRUCTION_REMOVE:
-        case CSYNC_INSTRUCTION_EVAL_RENAME:
+        return QCoreApplication::translate( "progress", "Deleted");
-            return QCoreApplication::translate( "progress", "Moved to %1").arg(item._renameTarget);
+    case CSYNC_INSTRUCTION_EVAL_RENAME:
-        default:
+    case CSYNC_INSTRUCTION_RENAME:
-            // Should normaly not happen
+        return QCoreApplication::translate( "progress", "Moved to %1").arg(item._renameTarget);
-            return QCoreApplication::translate( "progress", "Unknown");
+    case CSYNC_INSTRUCTION_IGNORE:
+        return QCoreApplication::translate( "progress", "Ignored");
+    case CSYNC_INSTRUCTION_STAT_ERROR:
+        return QCoreApplication::translate( "progress", "Filesystem access error");
+    case CSYNC_INSTRUCTION_ERROR:
+        return QCoreApplication::translate( "progress", "Error");
+    case CSYNC_INSTRUCTION_NONE:
+    case CSYNC_INSTRUCTION_EVAL:
+        return QCoreApplication::translate( "progress", "Unknown");
+
     }
+    return QCoreApplication::translate( "progress", "Unknown");
 }
 
 QString Progress::asActionString( const SyncFileItem &item )
@@ -55,11 +65,19 @@ QString Progress::asActionString( const SyncFileItem &item )
     case CSYNC_INSTRUCTION_REMOVE:
         return QCoreApplication::translate( "progress", "deleting");
     case CSYNC_INSTRUCTION_EVAL_RENAME:
+    case CSYNC_INSTRUCTION_RENAME:
         return QCoreApplication::translate( "progress", "moving");
-    default:
+    case CSYNC_INSTRUCTION_IGNORE:
-        // Should normaly not happen
+        return QCoreApplication::translate( "progress", "ignoring");
-        return QCoreApplication::translate( "progress", "processing");
+    case CSYNC_INSTRUCTION_STAT_ERROR:
+        return QCoreApplication::translate( "progress", "error");
+    case CSYNC_INSTRUCTION_ERROR:
+        return QCoreApplication::translate( "progress", "error");
+    case CSYNC_INSTRUCTION_NONE:
+    case CSYNC_INSTRUCTION_EVAL:
+        return QCoreApplication::translate( "progress", "unknown");
     }
+    return QCoreApplication::translate( "progress", "unknown");
 }
 
 bool Progress::isWarningKind( SyncFileItem::Status kind)
@@ -90,7 +108,9 @@ ProgressDispatcher::~ProgressDispatcher()
 
 void ProgressDispatcher::setProgressInfo(const QString& folder, const Progress::Info& progress)
 {
-    if( folder.isEmpty() ) {
+    if( folder.isEmpty() ||
+            (progress._currentItems.size() == 0
+             && progress._totalFileCount == 0) ) {
         return;
     }
     emit progressInfo( folder, progress );

src/mirall/progressdispatcher.h

@@ -14,6 +14,7 @@
 #ifndef PROGRESSDISPATCHER_H
 #define PROGRESSDISPATCHER_H
 
+#include "owncloudlib.h"
 #include <QObject>
 #include <QHash>
 #include <QTime>
@@ -53,10 +54,12 @@ namespace Progress
 
         void setProgressComplete(const SyncFileItem &item) {
             _currentItems.remove(item._file);
-            if (Progress::isSizeDependent(item._instruction)) {
+            if (!item._isDirectory) {
-                _completedSize += item._size;
+                _completedFileCount++;
+                if (Progress::isSizeDependent(item._instruction)) {
+                    _completedSize += item._size;
+                }
             }
-            _completedFileCount++;
             _lastCompletedItem = item;
         }
         void setProgressItem(const SyncFileItem &item, quint64 size) {
@@ -68,16 +71,17 @@ namespace Progress
         quint64 completedSize() const {
             quint64 r = _completedSize;
             foreach(const ProgressItem &i, _currentItems) {
-                r += i._completedSize;
+                if (!i._item._isDirectory)
+                    r += i._completedSize;
             }
             return r;
         }
     };
 
-    QString asActionString( const SyncFileItem& item );
+    OWNCLOUDSYNC_EXPORT QString asActionString( const SyncFileItem& item );
-    QString asResultString(  const SyncFileItem& item );
+    OWNCLOUDSYNC_EXPORT QString asResultString(  const SyncFileItem& item );
 
-    bool isWarningKind( SyncFileItem::Status );
+    OWNCLOUDSYNC_EXPORT bool isWarningKind( SyncFileItem::Status );
 
 }
 
@@ -90,7 +94,7 @@ namespace Progress
  * or the overall sync progress.
  *
  */
-class ProgressDispatcher : public QObject
+class OWNCLOUDSYNC_EXPORT ProgressDispatcher : public QObject
 {
     Q_OBJECT
 

src/mirall/propagator_legacy.cpp

@@ -437,6 +437,8 @@ void PropagateDownloadFileLegacy::notify_status_cb(void* userdata, ne_session_st
     }
 }
 
+extern QString makeConflictFileName(const QString &fn, const QDateTime &dt); // _qnam.cpp
+
 void PropagateDownloadFileLegacy::start()
 {
     if (_propagator->_abortRequested.fetchAndAddRelaxed(0))
@@ -564,15 +566,7 @@ void PropagateDownloadFileLegacy::start()
     //In case of conflict, make a backup of the old file
     if (isConflict) {
         QFile f(fn);
-        QString conflictFileName(fn);
+        QString conflictFileName = makeConflictFileName(fn, Utility::qDateTimeFromTime_t(_item._modtime));
-        // Add _conflict-XXXX  before the extention.
-        int dotLocation = conflictFileName.lastIndexOf('.');
-        // If no extention, add it at the end  (take care of cases like foo/.hidden or foo.bar/file)
-        if (dotLocation <= conflictFileName.lastIndexOf('/') + 1) {
-            dotLocation = conflictFileName.size();
-        }
-        QString timeString = Utility::qDateTimeFromTime_t(_item._modtime).toString("yyyyMMdd-hhmmss");
-        conflictFileName.insert(dotLocation, "_conflict-" + timeString);
         if (!f.rename(conflictFileName)) {
             //If the rename fails, don't replace it.
             done(SyncFileItem::NormalError, f.errorString());

src/mirall/propagator_qnam.cpp

@@ -19,12 +19,24 @@
 #include "syncjournalfilerecord.h"
 #include "utility.h"
 #include "filesystem.h"
+#include "propagatorjobs.h"
 #include <QNetworkAccessManager>
 #include <QFileInfo>
 #include <cmath>
 
 namespace Mirall {
 
+static uint chunkSize() {
+    static uint chunkSize;
+    if (!chunkSize) {
+        chunkSize = qgetenv("OWNCLOUD_CHUNK_SIZE").toUInt();
+        if (chunkSize == 0) {
+            chunkSize = 10*1024*1024; // default to 10 MiB
+        }
+    }
+    return chunkSize;
+}
+
 /**
  * Fiven an error from the network, map to a SyncFileItem::Status error
  */
@@ -60,19 +72,14 @@ void PUTFileJob::start() {
     }
 
     connect(reply(), SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(uploadProgress(qint64,qint64)));
+    connect(reply(), SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(resetTimeout()));
 
     AbstractNetworkJob::start();
 }
 
-static uint chunkSize() {
+void PUTFileJob::slotTimeout() {
-    static uint chunkSize;
+    _errorString =  tr("Connection Timeout");
-    if (!chunkSize) {
+    reply()->abort();
-        chunkSize = qgetenv("OWNCLOUD_CHUNK_SIZE").toUInt();
-        if (chunkSize == 0) {
-            chunkSize = 10*1024*1024; // default to 10 MiB
-        }
-    }
-    return chunkSize;
 }
 
 void PropagateUploadFileQNAM::start()
@@ -110,7 +117,6 @@ void PropagateUploadFileQNAM::start()
 }
 
 struct ChunkDevice : QIODevice {
-    Q_OBJECT
 public:
     QIODevice *_file;
     qint64 _read;
@@ -161,7 +167,6 @@ public:
         return _file->seek(pos + _start);
     }
 };
-#include "propagator_qnam.moc"
 
 void PropagateUploadFileQNAM::startNextChunk()
 {
@@ -216,6 +221,7 @@ void PropagateUploadFileQNAM::startNextChunk()
         device->open(QIODevice::ReadOnly);
 
     _job = new PUTFileJob(AccountManager::instance()->account(), _propagator->_remoteFolder + path, device, headers);
+    _job->setTimeout(_propagator->httpTimeout() * 1000);
     connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotPutFinished()));
     connect(_job, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(slotUploadProgress(qint64,qint64)));
     _job->start();
@@ -241,7 +247,7 @@ void PropagateUploadFileQNAM::slotPutFinished()
                "It is restored and your edit is in the conflict file."))) {
             return;
         }
-        QString errorString = job->reply()->errorString();
+        QString errorString = job->errorString();
 
         QByteArray replyContent = job->reply()->readAll();
         qDebug() << replyContent; // display the XML error in the debug
@@ -287,8 +293,8 @@ void PropagateUploadFileQNAM::slotPutFinished()
         return;
     }
 
-    _propagator->_activeJobs--;
+    // the following code only happens after all chunks were uploaded.
-
+    //
     // the file id should only be empty for new files up- or downloaded
     QByteArray fid = job->reply()->rawHeader("OC-FileID");
     if( !fid.isEmpty() ) {
@@ -299,15 +305,30 @@ void PropagateUploadFileQNAM::slotPutFinished()
     }
 
     _item._etag = parseEtag(job->reply()->rawHeader("ETag"));
+    _item._responseTimeStamp = job->responseTimestamp();
 
     if (job->reply()->rawHeader("X-OC-MTime") != "accepted") {
-        //FIXME
+        // X-OC-MTime is supported since owncloud 5.0.   But not when chunking.
-//             updateMTimeAndETag(uri.data(), _item._modtime);
+        // Normaly Owncloud 6 always put X-OC-MTime
-        done(SyncFileItem::NormalError, tr("No X-OC-MTime extension,  ownCloud 5 is required"));
+        qDebug() << "Server do not support X-OC-MTime";
+        PropagatorJob *newJob = new UpdateMTimeAndETagJob(_propagator, _item);
+        QObject::connect(newJob, SIGNAL(completed(SyncFileItem)), this, SLOT(finalize(SyncFileItem)));
+        QMetaObject::invokeMethod(newJob, "start");
         return;
     }
+    finalize(_item);
+}
+
+void PropagateUploadFileQNAM::finalize(const SyncFileItem &copy)
+{
+    // Normally, copy == _item,   but when it comes from the UpdateMTimeAndETagJob, we need to do
+    // some updates
+    _item._etag = copy._etag;
+    _item._fileId = copy._fileId;
+
+    _propagator->_activeJobs--;
+
     _item._requestDuration = _duration.elapsed();
-    _item._responseTimeStamp = _job->responseTimestamp();
 
     _propagator->_journal->setFileRecord(SyncJournalFileRecord(_item, _propagator->_localDir + _item._file));
     // Remove from the progress database:
@@ -358,17 +379,25 @@ void GETFileJob::start() {
 
 void GETFileJob::slotMetaDataChanged()
 {
+    if (reply()->error() != QNetworkReply::NoError
+            || reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() / 100 != 2) {
+        // We will handle the error when the job is finished.
+        return;
+    }
+
     QByteArray etag = parseEtag(reply()->rawHeader("Etag"));
 
     if (etag.isEmpty()) {
         qDebug() << Q_FUNC_INFO << "No E-Tag reply by server, considering it invalid";
         _errorString = tr("No E-Tag received from server, check Proxy/Gateway");
+        _errorStatus = SyncFileItem::NormalError;
         reply()->abort();
         return;
     } else if (!_expectedEtagForResume.isEmpty() && _expectedEtagForResume != etag) {
         qDebug() << Q_FUNC_INFO <<  "We received a different E-Tag for resuming!"
                 << _expectedEtagForResume << "vs" << etag;
         _errorString = tr("We received a different E-Tag for resuming. Retrying next time.");
+        _errorStatus = SyncFileItem::NormalError;
         reply()->abort();
         return;
     }
@@ -383,6 +412,7 @@ void GETFileJob::slotReadyRead()
         qint64 r = reply()->read(buffer.data(), bufferSize);
         if (r < 0) {
             _errorString = reply()->errorString();
+            _errorStatus = SyncFileItem::NormalError;
             qDebug() << "Error while reading from device: " << _errorString;
             reply()->abort();
             return;
@@ -391,11 +421,13 @@ void GETFileJob::slotReadyRead()
         qint64 w = _device->write(buffer.constData(), r);
         if (w != r) {
             _errorString = _device->errorString();
+            _errorStatus = SyncFileItem::NormalError;
             qDebug() << "Error while writing to file" << w << r <<  _errorString;
             reply()->abort();
             return;
         }
     }
+    resetTimeout();
 }
 
 
@@ -471,6 +503,7 @@ void PropagateDownloadFileQNAM::start()
     _job = new GETFileJob(AccountManager::instance()->account(),
                           _propagator->_remoteFolder + _item._file,
                           &_tmpFile, headers, expectedEtagForResume);
+    _job->setTimeout(_propagator->httpTimeout() * 1000);
     connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotGetFinished()));
     connect(_job, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(slotDownloadProgress(qint64,qint64)));
     _propagator->_activeJobs ++;
@@ -485,7 +518,9 @@ void PropagateDownloadFileQNAM::slotGetFinished()
     GETFileJob *job = qobject_cast<GETFileJob *>(sender());
     Q_ASSERT(job);
 
-    qDebug() << Q_FUNC_INFO << job->reply()->request().url() << "FINISHED WITH STATUS" << job->reply()->error() << job->reply()->errorString();
+    qDebug() << Q_FUNC_INFO << job->reply()->request().url() << "FINISHED WITH STATUS"
+             << job->reply()->error()
+             << (job->reply()->error() == QNetworkReply::NoError ? QLatin1String("") : job->reply()->errorString());
 
     QNetworkReply::NetworkError err = job->reply()->error();
     if (err != QNetworkReply::NoError) {
@@ -497,7 +532,11 @@ void PropagateDownloadFileQNAM::slotGetFinished()
         }
         _item._httpErrorCode = job->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
         _propagator->_activeJobs--;
-        done(classifyError(err, _item._httpErrorCode), job->errorString());
+        SyncFileItem::Status status = job->errorStatus();
+        if (status == SyncFileItem::NoStatus) {
+            status = classifyError(err, _item._httpErrorCode);
+        }
+        done(status, job->errorString());
         return;
     }
 
@@ -510,6 +549,27 @@ void PropagateDownloadFileQNAM::slotGetFinished()
     downloadFinished();
 }
 
+QString makeConflictFileName(const QString &fn, const QDateTime &dt)
+{
+    QString conflictFileName(fn);
+    // Add _conflict-XXXX  before the extention.
+    int dotLocation = conflictFileName.lastIndexOf('.');
+    // If no extention, add it at the end  (take care of cases like foo/.hidden or foo.bar/file)
+    if (dotLocation <= conflictFileName.lastIndexOf('/') + 1) {
+        dotLocation = conflictFileName.size();
+    }
+    QString timeString = dt.toString("yyyyMMdd-hhmmss");
+
+    // Additional marker
+    QByteArray conflictFileUserName = qgetenv("CSYNC_CONFLICT_FILE_USERNAME");
+    if (conflictFileUserName.isEmpty())
+        conflictFileName.insert(dotLocation, "_conflict-" + timeString);
+    else
+        conflictFileName.insert(dotLocation, "_conflict_" + QString::fromUtf8(conflictFileUserName)  + "-" + timeString);
+
+    return conflictFileName;
+}
+
 void PropagateDownloadFileQNAM::downloadFinished()
 {
 
@@ -521,15 +581,7 @@ void PropagateDownloadFileQNAM::downloadFinished()
     //In case of conflict, make a backup of the old file
     if (isConflict) {
         QFile f(fn);
-        QString conflictFileName(fn);
+        QString conflictFileName = makeConflictFileName(fn, Utility::qDateTimeFromTime_t(_item._modtime));
-        // Add _conflict-XXXX  before the extention.
-        int dotLocation = conflictFileName.lastIndexOf('.');
-        // If no extention, add it at the end  (take care of cases like foo/.hidden or foo.bar/file)
-        if (dotLocation <= conflictFileName.lastIndexOf('/') + 1) {
-            dotLocation = conflictFileName.size();
-        }
-        QString timeString = Utility::qDateTimeFromTime_t(_item._modtime).toString("yyyyMMdd-hhmmss");
-        conflictFileName.insert(dotLocation, "_conflict-" + timeString);
         if (!f.rename(conflictFileName)) {
             //If the rename fails, don't replace it.
             done(SyncFileItem::NormalError, f.errorString());
@@ -570,5 +622,13 @@ void PropagateDownloadFileQNAM::abort()
         _job->reply()->abort();
 }
 
+void GETFileJob::slotTimeout()
+{
+    _errorString =  tr("Connection Timeout");
+    _errorStatus = SyncFileItem::FatalError;
+    reply()->abort();
+}
+
+
 
 }

src/mirall/propagator_qnam.h

@@ -53,6 +53,7 @@ class PUTFileJob : public AbstractNetworkJob {
     Q_OBJECT
     QIODevice* _device;
     QMap<QByteArray, QByteArray> _headers;
+    QString _errorString;
 
 public:
     // Takes ownership of the device
@@ -62,10 +63,18 @@ public:
 
     virtual void start();
 
-    virtual void finished() {
+    virtual bool finished() {
         emit finishedSignal();
+        return true;
     }
 
+    QString errorString() {
+        return _errorString.isEmpty() ? reply()->errorString() : _errorString;
+    };
+
+    virtual void slotTimeout();
+
+
 signals:
     void finishedSignal();
     void uploadProgress(qint64,qint64);
@@ -90,7 +99,7 @@ private slots:
     void slotUploadProgress(qint64,qint64);
     void abort();
     void startNextChunk();
-
+    void finalize(const Mirall::SyncFileItem&);
 };
 
 
@@ -100,6 +109,7 @@ class GETFileJob : public AbstractNetworkJob {
     QMap<QByteArray, QByteArray> _headers;
     QString _errorString;
     QByteArray _expectedEtagForResume;
+    SyncFileItem::Status _errorStatus;
 public:
 
     // DOES NOT take owncership of the device.
@@ -107,17 +117,24 @@ public:
                         const QMap<QByteArray, QByteArray> &headers, QByteArray expectedEtagForResume,
                         QObject* parent = 0)
     : AbstractNetworkJob(account, path, parent),
-      _device(device), _headers(headers), _expectedEtagForResume(expectedEtagForResume) {}
+      _device(device), _headers(headers), _expectedEtagForResume(expectedEtagForResume),
+      _errorStatus(SyncFileItem::NoStatus) {}
 
     virtual void start();
-    virtual void finished() {
+    virtual bool finished() {
         emit finishedSignal();
+        return true;
     }
 
     QString errorString() {
         return _errorString.isEmpty() ? reply()->errorString() : _errorString;
     };
 
+    SyncFileItem::Status errorStatus() { return _errorStatus; }
+
+    virtual void slotTimeout();
+
+
 signals:
     void finishedSignal();
     void downloadProgress(qint64,qint64);

src/mirall/propagatorjobs.cpp

@@ -181,7 +181,6 @@ void PropagateLocalRename::start()
         QFile::rename(_propagator->_localDir + _item._file, _propagator->_localDir + _item._renameTarget);
     }
 
-    _item._instruction = CSYNC_INSTRUCTION_DELETED;
     _propagator->_journal->deleteFileRecord(_item._originalFile);
 
     // store the rename file name in the item.
@@ -323,5 +322,15 @@ bool PropagateNeonJob::updateErrorFromSession(int neon_code, ne_request* req, in
     return false;
 }
 
+void UpdateMTimeAndETagJob::start()
+{
+    QScopedPointer<char, QScopedPointerPodDeleter> uri(
+        ne_path_escape((_propagator->_remoteDir + _item._file).toUtf8()));
+    if (!updateMTimeAndETag(uri.data(), _item._modtime))
+        return;
+    done(SyncFileItem::Success);
+}
+
+
 
 }

src/mirall/propagatorjobs.h

@@ -108,4 +108,13 @@ public:
 };
 
 
+// To support older owncloud in the
+class UpdateMTimeAndETagJob : public PropagateNeonJob{
+    Q_OBJECT
+public:
+    UpdateMTimeAndETagJob (OwncloudPropagator* propagator, const SyncFileItem& item)  : PropagateNeonJob(propagator, item) {}
+    void start();
+};
+
+
 }

src/mirall/quotainfo.cpp

@@ -69,8 +69,6 @@ void QuotaInfo::slotRequestFailed()
     _lastQuotaTotalBytes = 0;
     _lastQuotaUsedBytes = 0;
     _jobRestartTimer->start(failIntervalT);
-
-    _jobRestartTimer->start(failIntervalT);
 }
 
 void QuotaInfo::slotCheckQuota()

src/mirall/sslbutton.cpp

@@ -46,19 +46,12 @@ QString SslButton::protoToString(QSsl::SslProtocol proto)
     }
 }
 
-static QString addCertDetailsField(const QString &key, const QString &value, bool tt = false)
+static QString addCertDetailsField(const QString &key, const QString &value)
 {
     if (value.isEmpty())
         return QString();
 
-    QString row = QString::fromLatin1("<tr><td style=\"vertical-align: top;\"><b>%1</b></td><td style=\"vertical-align: bottom;\">%2</td></tr>").arg(key);
+    return QString::fromLatin1("<tr><td style=\"vertical-align: top;\"><b>%1</b></td><td style=\"vertical-align: bottom;\">%2</td></tr>").arg(key).arg(value);
-
-    if (tt) {
-        row = row.arg(QString::fromLatin1("<tt style=\"font-size: small\">%1</tt>").arg(value));
-    } else {
-        row = row.arg(value);
-    }
-    return row;
 }
 
 
@@ -80,8 +73,16 @@ QMenu* SslButton::buildCertMenu(QMenu *parent, const QSslCertificate& cert,
     QString issuer = QStringList(cert.issuerInfo(QSslCertificate::CommonName)).join(QChar(';'));
     if (issuer.isEmpty())
         issuer = QStringList(cert.issuerInfo(QSslCertificate::OrganizationalUnitName)).join(QChar(';'));
-    QString md5 = Utility::formatFingerprint(cert.digest(QCryptographicHash::Md5).toHex());
+    QString sha1 = Utility::formatFingerprint(cert.digest(QCryptographicHash::Sha1).toHex(), false);
-    QString sha1 = Utility::formatFingerprint(cert.digest(QCryptographicHash::Sha1).toHex());
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+    QString md5 = Utility::formatFingerprint(cert.digest(QCryptographicHash::Md5).toHex(), false);
+#else
+    QByteArray sha265hash = cert.digest(QCryptographicHash::Sha256).toHex();
+    QString sha256escaped =
+            Utility::escape(Utility::formatFingerprint(sha265hash.left(sha265hash.length()/2), false)) +
+            QLatin1String("<br/>") +
+            Utility::escape(Utility::formatFingerprint(sha265hash.mid(sha265hash.length()/2), false));
+#endif
     QString serial = QString::fromUtf8(cert.serialNumber(), true);
     QString effectiveDate = cert.effectiveDate().date().toString();
     QString expiryDate = cert.expiryDate().date().toString();
@@ -102,7 +103,7 @@ QMenu* SslButton::buildCertMenu(QMenu *parent, const QSslCertificate& cert,
     stream << addCertDetailsField(tr("Organizational Unit (OU):"), Utility::escape(ou));
     stream << addCertDetailsField(tr("State/Province:"), Utility::escape(state));
     stream << addCertDetailsField(tr("Country:"), Utility::escape(country));
-    stream << addCertDetailsField(tr("Serial:"), Utility::escape(serial), true);
+    stream << addCertDetailsField(tr("Serial:"), Utility::escape(serial));
     stream << QLatin1String("</table>");
 
     stream << tr("<h3>Issuer</h3>");
@@ -116,8 +117,12 @@ QMenu* SslButton::buildCertMenu(QMenu *parent, const QSslCertificate& cert,
     stream << tr("<h3>Fingerprints</h3>");
 
     stream << QLatin1String("<table>");
-    stream << addCertDetailsField(tr("MD 5:"), Utility::escape(md5), true);
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-    stream << addCertDetailsField(tr("SHA-1:"), Utility::escape(sha1), true);
+    stream << addCertDetailsField(tr("MD 5:"), Utility::escape(md5));
+#else
+    stream << addCertDetailsField(tr("SHA-256:"), sha256escaped);
+#endif
+    stream << addCertDetailsField(tr("SHA-1:"), Utility::escape(sha1));
     stream << QLatin1String("</table>");
 
     if (userApproved.contains(cert)) {

src/mirall/syncengine.cpp

@@ -39,7 +39,6 @@
 #include <QStringList>
 #include <QTextStream>
 #include <QTime>
-#include <QApplication>
 #include <QUrl>
 #include <QSslCertificate>
 
@@ -180,7 +179,7 @@ QString SyncEngine::csyncErrorToString(CSYNC_STATUS err)
         break;
 
     default:
-        errStr = tr("An internal error number %1 happend.").arg( (int) err );
+        errStr = tr("An internal error number %1 happened.").arg( (int) err );
     }
 
     return errStr;
@@ -280,6 +279,10 @@ int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
     case CSYNC_STATUS_INDIVIDUAL_IS_INVALID_CHARS:
         item._errorString = tr("File contains invalid characters that can not be synced cross platform.");
         break;
+    case CYSNC_STATUS_FILE_LOCKED_OR_OPEN:
+        item._errorString = QLatin1String("File locked"); // don't translate, internal use!
+        break;
+
     default:
         Q_ASSERT("Non handled error-status");
         /* No error string */
@@ -289,6 +292,8 @@ int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
     item._modtime = file->modtime;
     item._etag = file->etag;
     item._size = file->size;
+    item._inode = file->inode;
+
     item._should_update_etag = file->should_update_etag;
     switch( file->type ) {
     case CSYNC_FTW_TYPE_DIR:
@@ -309,12 +314,12 @@ int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
     int re = 0;
 
     switch(file->instruction) {
-    case CSYNC_INSTRUCTION_UPDATED:
-        // We need to update the database.
-        _journal->setFileRecord(SyncJournalFileRecord(item, _localPath + item._file));
-        item._instruction = CSYNC_INSTRUCTION_NONE;
-        // fall trough
     case CSYNC_INSTRUCTION_NONE:
+        if (file->should_update_etag && !item._isDirectory) {
+            // Update the database now already  (new fileid or etag)
+            _journal->setFileRecord(SyncJournalFileRecord(item, _localPath + item._file));
+            item._should_update_etag = false;
+        }
         if (item._isDirectory && remote) {
             // Because we want still to update etags of directories
             dir = SyncFileItem::None;
@@ -344,7 +349,6 @@ int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
     case CSYNC_INSTRUCTION_NEW:
     case CSYNC_INSTRUCTION_SYNC:
     case CSYNC_INSTRUCTION_STAT_ERROR:
-    case CSYNC_INSTRUCTION_DELETED:
     default:
         dir = remote ? SyncFileItem::Down : SyncFileItem::Up;
         break;
@@ -441,6 +445,7 @@ void SyncEngine::startSync()
         // csync_update also opens the database.
         int fileRecordCount = 0;
         fileRecordCount = _journal->getFileRecordCount();
+        bool isUpdateFrom_1_5 = _journal->isUpdateFrom_1_5();
         _journal->close();
 
         if( fileRecordCount == -1 ) {
@@ -461,6 +466,12 @@ void SyncEngine::startSync()
         } else {
             qDebug() << "=====sync with existing DB";
         }
+
+        if (fileRecordCount > 1 && isUpdateFrom_1_5) {
+            qDebug() << "detected update from 1.5";
+            // Disable the read from DB to be sure to re-read all the fileid and etags.
+            csync_set_read_from_db(_csync_ctx, false);
+        }
     }
 
     csync_set_module_property(_csync_ctx, "csync_context", _csync_ctx);
@@ -490,6 +501,9 @@ void SyncEngine::startSync()
     // csync_set_auth_callback( _csync_ctx, getauth );
     csync_set_log_callback( csyncLogCatcher );
     //csync_set_log_level( 11 ); don't set the loglevel here, it shall be done by folder.cpp or owncloudcmd.cpp
+    int timeout = OwncloudPropagator::httpTimeout();
+    csync_set_module_property(_csync_ctx, "timeout", &timeout);
+
 
     _stopWatch.start();
 
@@ -539,6 +553,7 @@ void SyncEngine::slotUpdateFinished(int updateResult)
     if (!_journal->isConnected()) {
         qDebug() << "Bailing out, DB failure";
         emit csyncError(tr("Cannot open the sync journal"));
+        csync_commit(_csync_ctx);
         emit finished();
         _syncMutex.unlock();
         _thread.quit();
@@ -555,6 +570,7 @@ void SyncEngine::slotUpdateFinished(int updateResult)
         emit aboutToRemoveAllFiles(_syncedItems.first()._direction, &cancel);
         if (cancel) {
             qDebug() << Q_FUNC_INFO << "Abort sync";
+            csync_commit(_csync_ctx);
             emit finished();
             _syncMutex.unlock();
             _thread.quit();
@@ -616,7 +632,7 @@ void SyncEngine::setNetworkLimits()
 #endif
             ;
 
-    if( propDownloadLimit + propUploadLimit > 0 ) {
+    if( propDownloadLimit != 0 || propUploadLimit != 0 ) {
         qDebug() << " N------N Network Limits (down/up) " << propDownloadLimit << propUploadLimit;
     }
 }

src/mirall/syncengine.h

@@ -39,12 +39,12 @@ class SyncJournalDb;
 
 class OwncloudPropagator;
 
-void csyncLogCatcher(int /*verbosity*/,
+void OWNCLOUDSYNC_EXPORT csyncLogCatcher(int /*verbosity*/,
                      const char */*function*/,
                      const char *buffer,
                      void */*userdata*/);
 
-class SyncEngine : public QObject
+class OWNCLOUDSYNC_EXPORT SyncEngine : public QObject
 {
     Q_OBJECT
 public:

src/mirall/syncfileitem.h

@@ -49,7 +49,8 @@ public:
         FileIgnored ///< The file is in the ignored list
     };
 
-    SyncFileItem() : _type(UnknownType), _should_update_etag(false), _blacklistedInDb(false),
+    SyncFileItem() : _type(UnknownType),  _direction(None), _instruction(CSYNC_INSTRUCTION_NONE),
+        _size(0), _should_update_etag(false), _blacklistedInDb(false),
         _status(NoStatus), _httpErrorCode(0), _requestDuration(0) {}
 
     friend bool operator==(const SyncFileItem& item1, const SyncFileItem& item2) {
@@ -82,6 +83,7 @@ public:
     time_t               _modtime;
     QByteArray           _etag;
     quint64              _size;
+    quint64              _inode;
     bool                 _should_update_etag;
     QByteArray           _fileId;
     bool                 _blacklistedInDb;

src/mirall/syncjournaldb.cpp

@@ -22,6 +22,7 @@
 #include "syncjournaldb.h"
 #include "syncjournalfilerecord.h"
 #include "utility.h"
+#include "version.h"
 
 #include "../../csync/src/std/c_jhash.h"
 
@@ -30,7 +31,7 @@
 namespace Mirall {
 
 SyncJournalDb::SyncJournalDb(const QString& path, QObject *parent) :
-    QObject(parent), _transaction(0)
+    QObject(parent), _transaction(0), _possibleUpgradeFromMirall_1_5(false)
 {
 
     _dbFile = path;
@@ -192,6 +193,35 @@ bool SyncJournalDb::checkConnect()
         return sqlFail("Create table blacklist", createQuery);
     }
 
+    createQuery.prepare("CREATE TABLE IF NOT EXISTS version("
+                               "major INTEGER(8),"
+                               "minor INTEGER(8),"
+                               "patch INTEGER(8),"
+                               "custom VARCHAR(256)"
+                               ");");
+    if (!createQuery.exec()) {
+        return sqlFail("Create table blacklist", createQuery);
+    }
+
+    QSqlQuery versionQuery("SELECT major, minor FROM version;", _db);
+    if (!versionQuery.next()) {
+        // If there was no entry in the table, it means we are likely upgrading from 1.5
+        _possibleUpgradeFromMirall_1_5 = true;
+    } else {
+        // Delete the existing entry so we can replace it by the new one
+        createQuery.prepare("DELETE FROM version;");
+        if (!createQuery.exec()) {
+            return sqlFail("Remove version", createQuery);
+        }
+    }
+    createQuery.prepare("INSERT INTO version (major, minor, patch) VALUES ( ? , ? , ? );");
+    createQuery.bindValue(0, MIRALL_VERSION_MAJOR);
+    createQuery.bindValue(1, MIRALL_VERSION_MINOR);
+    createQuery.bindValue(2, MIRALL_VERSION_PATCH);
+    if (!createQuery.exec()) {
+        return sqlFail("Insert Version", createQuery);
+    }
+
     commitInternal("checkConnect");
 
     bool rc = updateDatabaseStructure();
@@ -260,6 +290,7 @@ void SyncJournalDb::close()
     _deleteFileRecordPhash.reset(0);
     _deleteFileRecordRecursively.reset(0);
     _blacklistQuery.reset(0);
+    _possibleUpgradeFromMirall_1_5 = false;
 
     _db.close();
     _db = QSqlDatabase(); // avoid the warning QSqlDatabasePrivate::removeDatabase: connection [...] still in use
@@ -825,6 +856,13 @@ bool SyncJournalDb::isConnected()
     return checkConnect();
 }
 
+bool SyncJournalDb::isUpdateFrom_1_5()
+{
+    QMutexLocker lock(&_mutex);
+    checkConnect();
+    return _possibleUpgradeFromMirall_1_5;
+}
+
 
 
 } // namespace Mirall

src/mirall/syncjournaldb.h

@@ -21,6 +21,8 @@
 #include <QHash>
 #include <QSqlQuery>
 
+#include "utility.h"
+
 namespace Mirall {
 class SyncJournalFileRecord;
 class SyncJournalBlacklistRecord;
@@ -30,7 +32,7 @@ class SyncJournalBlacklistRecord;
  *
  * This class is thread safe. All public function are locking the mutex.
  */
-class SyncJournalDb : public QObject
+class OWNCLOUDSYNC_EXPORT SyncJournalDb : public QObject
 {
     Q_OBJECT
 public:
@@ -85,6 +87,12 @@ public:
      */
     bool isConnected();
 
+    /**
+     * Tell the sync engine if we need to disable the fetch from db to be sure that the fileid
+     * are updated.
+     */
+    bool isUpdateFrom_1_5();
+
 
 
 
@@ -106,6 +114,7 @@ private:
     QString _dbFile;
     QMutex _mutex; // Public functions are protected with the mutex.
     int _transaction;
+    bool _possibleUpgradeFromMirall_1_5;
     QScopedPointer<QSqlQuery> _getFileRecordQuery;
     QScopedPointer<QSqlQuery> _setFileRecordQuery;
     QScopedPointer<QSqlQuery> _getDownloadInfoQuery;

src/mirall/syncjournalfilerecord.cpp

@@ -36,15 +36,20 @@ SyncJournalFileRecord::SyncJournalFileRecord(const SyncFileItem &item, const QSt
       _type(item._type), _etag(item._etag), _fileId(item._fileId),
       _uid(0), _gid(0), _mode(0)
 {
+    // use the "old" inode coming with the item for the case where the
+    // filesystem stat fails. That can happen if the the file was removed
+    // or renamed meanwhile. For the rename case we still need the inode to
+    // detect the rename tough.
+    _inode = item._inode;
 
-    // Query the inode:
-    //   based on code from csync_vio_local.c (csync_vio_local_stat)
 #ifdef Q_OS_WIN
-    /* Get the Windows file id as an inode replacement. */
+    /* Query the inode:
+       based on code from csync_vio_local.c (csync_vio_local_stat)
+       Get the Windows file id as an inode replacement. */
     HANDLE h = CreateFileW( (wchar_t*)localFileName.utf16(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
                      FILE_ATTRIBUTE_NORMAL+FILE_FLAG_BACKUP_SEMANTICS, NULL );
+
     if( h == INVALID_HANDLE_VALUE ) {
-        _inode = 0;
         qWarning() << "Failed to query the 'inode' because CreateFileW failed for file " << localFileName;
     } else {
         BY_HANDLE_FILE_INFORMATION fileInfo;
@@ -60,7 +65,7 @@ SyncJournalFileRecord::SyncJournalFileRecord(const SyncFileItem &item, const QSt
             _inode = FileIndex.QuadPart;
         } else {
             qWarning() << "Failed to query the 'inode' for file " << localFileName;
-            _inode = 0;
+
         }
         CloseHandle(h);
     }
@@ -68,7 +73,6 @@ SyncJournalFileRecord::SyncJournalFileRecord(const SyncFileItem &item, const QSt
     struct stat sb;
     if( stat(QFile::encodeName(localFileName).constData(), &sb) < 0) {
         qWarning() << "Failed to query the 'inode' for file " << localFileName;
-        _inode = 0;
     } else {
         _inode = sb.st_ino;
     }