Merge pull request #2391 from owncloud/ignore_windows_reserved_characters

Ignore reserved words on Windows

.gitmodules

@@ -3,7 +3,7 @@
 	url = https://github.com/owncloud/documentation
 [submodule "src/3rdparty/qtmacgoodies"]
 	path = src/3rdparty/qtmacgoodies
-	url = git://github.com/guruz/qtmacgoodies.git
+	url = git://github.com/shadone/qtmacgoodies.git
 [submodule "binary"]
 	path = binary
 	url = git://github.com/owncloud/owncloud-client-binary.git

CMakeLists.txt

@@ -123,6 +123,12 @@ find_package(Sphinx)
 find_package(PdfLatex)
 
 
+find_package(SQLite3 3.8.0 REQUIRED)
+# On some OS, we want to use our own, not the system sqlite
+if (USE_OUR_OWN_SQLITE3)
+    include_directories(BEFORE ${SQLITE3_INCLUDE_DIR})
+endif()
+
 
 configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 

ChangeLog

@@ -1,5 +1,51 @@
 ChangeLog
 =========
+version 1.7.0 (release 2014-10-xx)
+
+* oC7 Sharing: Handle new sharing options of ownCloud 7 correctly.
+ * Added Selective sync: Ability to unselect server folders which are
+   excluded from syncing, plus GUI and setup GUI
+ * Improved local change detection: consider file size, detect files
+   with ongoing changes and do not upload immediately
+ * Improved HTTP request timeout handler: all successful requests reset
+   the timeout counter
+ * Improvements for syncing command line tool: netrc support, improved
+   SSL support, non interactive mode
+ * Added a socket based API to provide file management shells with status
+   information about the sync status of files. That is a prerequisite for
+   the overlay icons in the file managers.
+ * Permission system: ownCloud 7 delivers file and folder permissions,
+   added ability to deal with it for shared folders and more.
+ * Ignore handling: Do not recurse into ignored or excluded directories
+ * Major sync journal database improvements for more stability and performance
+ * New library interface to sqlite3
+ * Improve "resync handling" if errors occur
+ * Blacklist improvements
+ * Improved logging: more useful meta info, removed noise
+ * Updated to latest Qt5 versions on Windows and OS X
+ * OS X: Sparkle update to provide pkg format properly
+ * OS X: Change distribution format from dmg to pkg with new installer.
+ * Win: Fix handling of filenames with trailing dot or space
+
+version 1.6.4 (release 2014-10-22)
+ * Fix startup logic, fixes bug #1989
+ * Fix raise dialog on X11
+ * Win32: fix overflow when computing the size of file > 4GiB
+ * Use a fixed function to get files modification time, the
+   original one was broken for certain timezone issues, see
+   core bug #9781 for details
+ * Added some missing copyright headers
+ * Avoid data corruption due to wrong error handling, bug #2280
+ * Do improved request timeout handling to reduce the number of
+   timed out jobs, bug #2155
+   version 1.6.3 (release 2014-09-03)
+ * Fixed updater on OS X
+ * Fixed memory leak in SSL button that could lead to quick memory draining
+ * Fixed upload problem with files >4 GB
+ * MacOSX, Linux: Bring Settings window to front properly
+ * Branded clients: If no configuration is detected, try to import the data
+    from a previously configured community edition.
+
 version 1.6.2 (release 2014-07-28 )
  * Limit the HTTP buffer size when downloading to limit memory consumption.
  * Another small mem leak fixed in HTTP Credentials.

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 "beta2") #e.g. beta1, beta2, rc1
+    set( MIRALL_VERSION_SUFFIX "rc1") #e.g. beta1, beta2, rc1
 endif( NOT DEFINED MIRALL_VERSION_SUFFIX )
 
 if( NOT DEFINED MIRALL_VERSION_BUILD )

admin/osx/installer-background.svg

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   enable-background="new 0 0 595.275 311.111"
+   xml:space="preserve"
+   height="200"
+   width="320"
+   version="1.1"
+   y="0px"
+   x="0px"
+   viewBox="0 0 35 0"
+   id="svg2"
+   inkscape:version="0.48.4 r9939"
+   sodipodi:docname="installer-background.svg"><metadata
+     id="metadata12"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs10" /><sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1002"
+     id="namedview8"
+     showgrid="false"
+     inkscape:zoom="0.734375"
+     inkscape:cx="-49.141255"
+     inkscape:cy="236.17459"
+     inkscape:window-x="0"
+     inkscape:window-y="34"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg2"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0" /><path
+     style="text-indent:0;text-transform:none;block-progression:tb;color:#000000;fill:#ffffff;fill-opacity:1;enable-background:accumulate"
+     d="m 75.63384,28.421489 c -29.36582,0 -53.09172,23.724901 -53.09172,53.091701 0,12.1047 4.03087,23.2455 10.82647,32.1667 14.74225,-17.0631 36.50138,-27.8988 60.79508,-27.8988 11.88546,0 23.15644,2.6467 33.31219,7.2871 0.82221,-3.7185 1.24924,-7.5856 1.24924,-11.555 0,-29.3658 -23.72491,-53.091701 -53.09172,-53.091701 z M 6.30358,52.98809 c -15.29297,0 -27.58645,12.3977 -27.58645,27.6906 0,4.9515 1.27738,9.6301 3.53933,13.6373 9.22826,-5.206 19.89756,-8.2239 31.23002,-8.2239 1.09366,0 2.14708,0.039 3.22713,0.1052 -0.12231,-1.5502 -0.20806,-3.103 -0.20806,-4.6844 0,-8.5178 1.85002,-16.6223 5.10106,-23.9429 -4.37708,-2.9351 -9.62115,-4.5803 -15.30284,-4.5803 z m 130.95716,19.0502 c -1.12983,0 -2.21885,0.1381 -3.33122,0.2078 0.48121,3.0338 0.83274,6.097 0.83274,9.2651 0,4.9298 -0.62692,9.6869 -1.7697,14.2616 13.39754,7.4144 24.52385,18.5084 31.8547,31.9586 7.60342,-3.9586 16.08566,-6.4754 25.08804,-7.0787 -2.32015,-27.2093 -24.86184,-48.6137 -52.67416,-48.6137 z m -43.09675,19.7789 c -41.09117,0 -74.32775,33.2333 -74.32775,74.3278 0,41.0911 33.23329,74.3277 74.32775,74.3277 41.09447,0 74.32775,-33.2366 74.32775,-74.3277 0,-41.0945 -33.23657,-74.3278 -74.32775,-74.3278 z m -80.67652,0.3117 c -31.87937,0 -57.67166,25.792 -57.67166,57.6717 0,18.7668 8.94156,35.3802 22.79774,45.9078 5.84147,-11.2667 17.57406,-18.9461 31.1258,-18.9461 1.63789,0 3.21,0.1986 4.78871,0.4169 -0.49554,-3.6054 -0.72871,-7.2937 -0.72871,-11.0346 0,-17.8847 5.82174,-34.4234 15.71907,-47.7819 -5.92466,-7.4133 -10.1643,-16.321 -11.97162,-26.025 -1.33935,-0.092 -2.69673,-0.2078 -4.05979,-0.2078 z m 180.71831,34.3544 c -9.68,0 -18.74781,2.4714 -26.75364,6.6625 4.54607,10.0696 7.07867,21.2422 7.07867,32.9998 0,22.0146 -8.85114,42.0052 -23.21431,56.5275 10.5516,11.7145 25.861,19.0503 42.88961,19.0503 31.87937,0 57.67165,-25.7916 57.67165,-57.6717 0,-31.8793 -25.79195,-57.5664 -57.67165,-57.5664 z m -244.00885,7.5998 c -29.3701,0 -53.19693,23.6164 -53.19693,52.9832 0,29.3669 23.82815,53.1937 53.19364,53.1937 11.17727,0 21.53161,-3.4825 30.08487,-9.369 -3.5344,-5.492 -5.62151,-12.0581 -5.62151,-19.0503 0,-3.6291 0.53552,-7.1158 1.56148,-10.4099 -16.01267,-11.5721 -26.44131,-30.4034 -26.44131,-51.6319 0,-5.394 0.71083,-10.6098 1.97792,-15.6152 -0.52591,-0.013 -1.03171,-0.1052 -1.56152,-0.1052 z m 312.19495,45.5955 c -1.56661,0 -3.08252,0.1789 -4.58026,0.4169 0.0829,1.3242 0.1039,2.6108 0.1039,3.9559 0,16.9326 -6.68118,32.3015 -17.4889,43.7214 5.31706,6.1831 13.12695,10.0976 21.96526,10.0976 16.09849,0 29.14785,-12.9451 29.14785,-29.0439 0,-16.0985 -13.04936,-29.1479 -29.14785,-29.1479 z m -252.64924,3.1229 c -16.09783,0 -29.04395,12.9461 -29.04395,29.044 0,16.0978 12.94612,29.1478 29.04395,29.1478 12.33919,0 22.81287,-7.6994 27.06599,-18.5298 -10.378,-10.57 -17.83675,-24.0544 -21.13213,-39.0363 -1.92854,-0.3985 -3.88588,-0.6247 -5.93386,-0.6247 z"
+     id="path6"
+     inkscape:connector-curvature="0" /></svg>

admin/osx/macdeployqt.py

@@ -23,7 +23,7 @@ import sys
 from glob import glob
 
 def QueryQMake(attrib):
-    return subprocess.check_output(['qmake', '-query', attrib]).rstrip('\n')
+    return subprocess.check_output([qmake_path, '-query', attrib]).rstrip('\n')
 
 FRAMEWORK_SEARCH_PATH=[
     '/Library/Frameworks',
@@ -68,14 +68,18 @@ class CouldNotFindQtPluginError(Error):
 class CouldNotFindScriptPluginError(Error):
   pass
 
-if len(sys.argv) < 2:
+class CouldNotFindFrameworkError(Error):
-  print 'Usage: %s <bundle.app>' % sys.argv[0]
+  pass
+
+if len(sys.argv) < 3:
+  print 'Usage: %s <bundle.app> <path-to-qmake>' % sys.argv[0]
   exit()
 
 def is_exe(fpath):
   return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
 bundle_dir = sys.argv[1]
+qmake_path = sys.argv[2]
 
 bundle_name = os.path.basename(bundle_dir).split('.')[0]
 
@@ -246,8 +250,10 @@ def CopyFramework(path):
   parts = path.split(os.sep)
   print "CopyFramework:", path
   for i, part in enumerate(parts):
-    if re.match(r'\w+\.framework', part):
+    matchObj = re.match(r'(\w+\.framework)', part)
+    if matchObj:
       full_path = os.path.join(frameworks_dir, *parts[i:-1])
+      framework = matchObj.group(1)
       break
   args = ['mkdir', '-p', full_path]
   commands.append(args)
@@ -255,12 +261,13 @@ def CopyFramework(path):
   commands.append(args)
   args = ['chmod', 'u+w', os.path.join(full_path, parts[-1])]
   commands.append(args)
+  args = ['chmod', 'u+w', os.path.join(frameworks_dir, framework, "Resources")]
+  commands.append(args)
 
   info_plist = os.path.join(os.path.split(path)[0], '..', '..', 'Contents', 'Info.plist')
   if os.path.exists(info_plist):
-    args = ['cp', '-r', info_plist, resources_dir]
+    args = ['cp', '-r', info_plist, os.path.join(frameworks_dir, framework, "Resources")]
     commands.append(args)
-
   return os.path.join(full_path, parts[-1])
 
 def FixId(path, library_name):

admin/osx/macosx.pkgproj

@@ -491,7 +491,7 @@
 				<key>OVERWRITE_PERMISSIONS</key>
 				<false/>
 				<key>VERSION</key>
-				<string>1.6.2</string>
+				<string>@MIRALL_VERSION_FULL@</string>
 			</dict>
 			<key>UUID</key>
 			<string>7D7219B7-1897-48C3-8533-842BDEC46F71</string>
@@ -793,7 +793,7 @@
 													<key>GID</key>
 													<integer>0</integer>
 													<key>PATH</key>
-													<string>Library/ScriptingAdditions/OwnCloudFinder.osax/Contents</string>
+													<string>Library/ScriptingAdditions/SyncStateFinder.osax/Contents</string>
 													<key>PATH_TYPE</key>
 													<integer>3</integer>
 													<key>PERMISSIONS</key>
@@ -807,7 +807,7 @@
 											<key>GID</key>
 											<integer>0</integer>
 											<key>PATH</key>
-											<string>OwnCloudFinder.osax</string>
+											<string>SyncStateFinder.osax</string>
 											<key>PATH_TYPE</key>
 											<integer>0</integer>
 											<key>PERMISSIONS</key>
@@ -1019,7 +1019,7 @@
 				<key>OVERWRITE_PERMISSIONS</key>
 				<false/>
 				<key>VERSION</key>
-				<string>1.6.2</string>
+				<string>@MIRALL_VERSION_FULL@</string>
 			</dict>
 			<key>TYPE</key>
 			<integer>0</integer>
@@ -1041,7 +1041,7 @@
 			ZW50LVN0eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIj4KPHRp
 			dGxlPjwvdGl0bGU+CjxtZXRhIG5hbWU9IkdlbmVyYXRvciIgY29u
 			dGVudD0iQ29jb2EgSFRNTCBXcml0ZXIiPgo8bWV0YSBuYW1lPSJD
-			b2NvYVZlcnNpb24iIGNvbnRlbnQ9IjExMzguNTEiPgo8c3R5bGUg
+			b2NvYVZlcnNpb24iIGNvbnRlbnQ9IjEzNDMuMTQiPgo8c3R5bGUg
 			dHlwZT0idGV4dC9jc3MiPgo8L3N0eWxlPgo8L2hlYWQ+Cjxib2R5
 			Pgo8L2JvZHk+CjwvaHRtbD4K
 			</data>
@@ -1055,9 +1055,9 @@
 				<key>BACKGROUND_PATH</key>
 				<dict>
 					<key>PATH</key>
-				<string>./@APPLICATION_EXECUTABLE@.app/Contents/Resources/owncloud_logo_blue.png</string>
+					<string>@CMAKE_SOURCE_DIR@/admin/osx/installer-background.png</string>
 					<key>PATH_TYPE</key>
-				<integer>3</integer>
+					<integer>0</integer>
 				</dict>
 				<key>CUSTOM</key>
 				<integer>1</integer>
@@ -1415,7 +1415,7 @@
 			<key>NAME</key>
 			<string>ownCloud Installer</string>
 			<key>REFERENCE_FOLDER_PATH</key>
-			<string>/Users/mackie/install</string>
+			<string>@CMAKE_INSTALL_DIR@</string>
 		</dict>
 	</dict>
 	<key>TYPE</key>

cmake/modules/DefineCompilerFlags.cmake

@@ -14,7 +14,8 @@ if (${CMAKE_C_COMPILER_ID} MATCHES "(GNU|Clang)")
 
     # add -Wconversion ?
     # cannot be pedantic with sqlite3 directly linked
-    if (NOT CSYNC_STATIC_COMPILE_DIR)
+    # FIXME Can we somehow not use those flags for sqlite3.* but use them for the rest of csync?
+    if (NOT USE_OUR_OWN_SQLITE3)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -pedantic -pedantic-errors")
     endif()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wshadow -Wmissing-prototypes")

cmake/modules/FindSQLite3.cmake

@@ -50,8 +50,18 @@ if (SQLite3_FIND_VERSION AND _SQLITE3_VERSION)
     set(SQLite3_VERSION _SQLITE3_VERSION)
 endif (SQLite3_FIND_VERSION AND _SQLITE3_VERSION)
 
+if (APPLE OR WIN32)
+    set(USE_OUR_OWN_SQLITE3 TRUE)
+    set(SQLITE3_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/src/3rdparty/sqlite3)
+    set(SQLITE3_LIBRARIES "")
+    set(SQLITE3_SOURCE ${SQLITE3_INCLUDE_DIR}/sqlite3.c)
+    MESSAGE(STATUS "Using own sqlite3 from " ${SQLITE3_INCLUDE_DIR})
+else()
     include(FindPackageHandleStandardArgs)
     find_package_handle_standard_args(SQLite3 DEFAULT_MSG SQLITE3_LIBRARIES SQLITE3_INCLUDE_DIRS)
+endif()
+
+
 
 # show the SQLITE3_INCLUDE_DIRS and SQLITE3_LIBRARIES variables only in the advanced view
 mark_as_advanced(SQLITE3_INCLUDE_DIRS SQLITE3_LIBRARIES)

cmake/modules/NSIS.template.in

@@ -391,6 +391,7 @@ Section "${APPLICATION_NAME}" SEC_APPLICATION
    ; Make sure only to copy qt, not qt_help, etc
    File "${MING_SHARE}\qt5\translations\qt_??.qm"
    File "${MING_SHARE}\qt5\translations\qt_??_??.qm"
+   File "${MING_SHARE}\qt5\translations\qtbase_*.qm"
    File "${MING_SHARE}\qt5\translations\qtkeychain_*.qm"
 
    SetOutPath "$INSTDIR\platforms"

cmake/modules/QtVersionAbstraction.cmake

@@ -153,7 +153,18 @@ if(NOT Qt5Core_FOUND)
         include( ${QT_USE_FILE} )
     endmacro()
 
+    if (CMAKE_COMPILER_IS_GNUCC)
+        execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
+                OUTPUT_VARIABLE GCC_VERSION)
+        if (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)
             add_definitions("-DQ_DECL_OVERRIDE=override")
+        else()
+            add_definitions("-DQ_DECL_OVERRIDE=")
+        endif()
+    else() #clang or others
+        add_definitions("-DQ_DECL_OVERRIDE=override")
+    endif()
+
 endif()
 
 if( Qt5Core_DIR )

csync/src/CMakeLists.txt

@@ -4,13 +4,6 @@ add_subdirectory(std)
 add_subdirectory(httpbf)
 
 # Statically include sqlite
-if (CSYNC_STATIC_COMPILE_DIR)
-    set(SQLITE3_INCLUDE_DIRS "")
-    set(SQLITE3_LIBRARIES "")
-    include_directories(${CSYNC_STATIC_COMPILE_DIR})
-else (CSYNC_STATIC_COMPILE_DIR)
-    find_package(SQLite3 3.3.9 REQUIRED)
-endif()
 
 set(CSYNC_PUBLIC_INCLUDE_DIRS
   ${CMAKE_CURRENT_BINARY_DIR}
@@ -86,8 +79,8 @@ set(csync_HDRS
 )
 
 # Statically include sqlite
-if (CSYNC_STATIC_COMPILE_DIR)
+if (USE_OUR_OWN_SQLITE3)
-    list(APPEND csync_SRCS ${CSYNC_STATIC_COMPILE_DIR}/dictionary.c  ${CSYNC_STATIC_COMPILE_DIR}/sqlite3.c)
+    list(APPEND csync_SRCS ${SQLITE3_SOURCE})
 endif()
 
 include_directories(

csync/src/csync.c

@@ -228,9 +228,10 @@ int csync_update(CSYNC *ctx) {
 
   rc = csync_ftw(ctx, ctx->local.uri, csync_walker, MAX_DEPTH);
   if (rc < 0) {
-    if(ctx->status_code == CSYNC_STATUS_OK)
+    if(ctx->status_code == CSYNC_STATUS_OK) {
         ctx->status_code = csync_errno_to_status(errno, CSYNC_STATUS_UPDATE_ERROR);
-    return -1;
+    }
+    goto out;
   }
 
   csync_gettime(&finish);
@@ -247,9 +248,10 @@ int csync_update(CSYNC *ctx) {
 
   rc = csync_ftw(ctx, ctx->remote.uri, csync_walker, MAX_DEPTH);
   if (rc < 0) {
-      if(ctx->status_code == CSYNC_STATUS_OK)
+      if(ctx->status_code == CSYNC_STATUS_OK) {
           ctx->status_code = csync_errno_to_status(errno, CSYNC_STATUS_UPDATE_ERROR);
-      return -1;
+      }
+      goto out;
   }
 
   csync_gettime(&finish);
@@ -262,7 +264,11 @@ int csync_update(CSYNC *ctx) {
 
   ctx->status |= CSYNC_STATUS_UPDATE;
 
-  return 0;
+  rc = 0;
+
+out:
+  csync_statedb_close(ctx);
+  return rc;
 }
 
 int csync_reconcile(CSYNC *ctx) {
@@ -278,6 +284,12 @@ int csync_reconcile(CSYNC *ctx) {
   /* Reconciliation for local replica */
   csync_gettime(&start);
 
+  if (csync_statedb_load(ctx, ctx->statedb.file, &ctx->statedb.db) < 0) {
+    ctx->status_code = CSYNC_STATUS_STATEDB_LOAD_ERROR;
+    rc = -1;
+    return rc;
+  }
+
   ctx->current = LOCAL_REPLICA;
   ctx->replica = ctx->local.type;
 
@@ -293,7 +305,7 @@ int csync_reconcile(CSYNC *ctx) {
       if (!CSYNC_STATUS_IS_OK(ctx->status_code)) {
           ctx->status_code = csync_errno_to_status( errno, CSYNC_STATUS_RECONCILE_ERROR );
       }
-      return -1;
+      goto out;
   }
 
   /* Reconciliation for remote replica */
@@ -314,11 +326,15 @@ int csync_reconcile(CSYNC *ctx) {
       if (!CSYNC_STATUS_IS_OK(ctx->status_code)) {
           ctx->status_code = csync_errno_to_status(errno,  CSYNC_STATUS_RECONCILE_ERROR );
       }
-      return -1;
+      goto out;
   }
 
   ctx->status |= CSYNC_STATUS_RECONCILE;
 
+  rc = 0;
+
+out:
+  csync_statedb_close(ctx);
   return 0;
 }
 

csync/src/csync_exclude.c

@@ -156,6 +156,40 @@ CSYNC_EXCLUDE_TYPE csync_excluded(CSYNC *ctx, const char *path, int filetype) {
     return match;
 }
 
+// See http://support.microsoft.com/kb/74496
+static const char *win_reserved_words[] = {"CON","PRN","AUX", "NUL",
+                                           "COM1", "COM2", "COM3", "COM4",
+                                           "LPT1", "LPT2", "LPT3", "CLOCK$" };
+
+
+bool csync_is_windows_reserved_word(const char* filename) {
+
+  size_t win_reserve_words_len = sizeof(win_reserved_words) / sizeof(char*);
+  size_t j;
+
+  for (j = 0; j < win_reserve_words_len; j++) {
+    int len_reserved_word = strlen(win_reserved_words[j]);
+    int len_filename = strlen(filename);
+    if (len_filename == 2 && filename[1] == ':') {
+        if (filename[0] >= 'a' && filename[0] <= 'z') {
+            return true;
+        }
+        if (filename[0] >= 'A' && filename[0] <= 'Z') {
+            return true;
+        }
+    }
+    if (c_strncasecmp(filename, win_reserved_words[j], len_reserved_word) == 0) {
+        if (len_filename == len_reserved_word) {
+            return true;
+        }
+        if ((len_filename > len_reserved_word) && (filename[len_reserved_word] == '.')) {
+            return true;
+        }
+    }
+  }
+  return false;
+}
+
 CSYNC_EXCLUDE_TYPE csync_excluded_no_ctx(c_strlist_t *excludes, const char *path, int filetype) {
   size_t i = 0;
   const char *p = NULL;
@@ -214,6 +248,13 @@ CSYNC_EXCLUDE_TYPE csync_excluded_no_ctx(c_strlist_t *excludes, const char *path
       SAFE_FREE(dname);
       goto out;
   }
+
+  if (csync_is_windows_reserved_word(bname)) {
+    match = CSYNC_FILE_EXCLUDE_INVALID_CHAR;
+    SAFE_FREE(bname);
+    SAFE_FREE(dname);
+    goto out;
+  }
 #endif
 
   rc = csync_fnmatch(".owncloudsync.log*", bname, 0);

csync/src/csync_exclude.h

@@ -80,4 +80,12 @@ CSYNC_EXCLUDE_TYPE csync_excluded(CSYNC *ctx, const char *path, int filetype);
 CSYNC_EXCLUDE_TYPE csync_excluded_no_ctx(c_strlist_t *excludes, const char *path, int filetype);
 #endif /* _CSYNC_EXCLUDE_H */
 
+/**
+ * @brief Checks if filename is considered reserved by Windows
+ * @param file_name filename
+ * @return true if file is reserved, false otherwise
+ */
+bool csync_is_windows_reserved_word(const char *file_name);
+
+
 /* vim: set ft=c.doxygen ts=8 sw=2 et cindent: */

csync/src/csync_owncloud.c

@@ -761,6 +761,7 @@ int owncloud_commit(CSYNC* ctx) {
     }
 
     ctx->owncloud_context->is_first_propfind = true;
+    ctx->owncloud_context->dav_session.no_recursive_propfind = true;
   /* DEBUG_WEBDAV( "********** vio_module_shutdown" ); */
 
   ctx->owncloud_context->dav_session.ctx = 0;

csync/src/csync_private.h

@@ -100,6 +100,8 @@ struct csync_s {
     sqlite3_stmt* by_hash_stmt;
     sqlite3_stmt* by_fileid_stmt;
     sqlite3_stmt* by_inode_stmt;
+
+    int lastReturnValue;
   } statedb;
 
   struct {
@@ -146,8 +148,8 @@ struct csync_s {
   struct csync_owncloud_ctx_s *owncloud_context;
 
   /* hooks for checking the white list */
-  void *checkBlackListData;
+  void *checkSelectiveSyncBlackListData;
-  int (*checkBlackListHook)(void*, const char*);
+  int (*checkSelectiveSyncBlackListHook)(void*, const char*);
 };
 
 

csync/src/csync_reconcile.c

@@ -138,6 +138,11 @@ static int _csync_merge_algorithm_visitor(void *obj, void *data) {
                 /* Do not remove a directory that has ignored files */
                 break;
             }
+            if (cur->child_modified) {
+                /* re-create directory that has modified contents */
+                cur->instruction = CSYNC_INSTRUCTION_NEW;
+                break;
+            }
             cur->instruction = CSYNC_INSTRUCTION_REMOVE;
             break;
         case CSYNC_INSTRUCTION_EVAL_RENAME:

csync/src/csync_statedb.c

@@ -50,6 +50,22 @@
 
 #define BUF_SIZE 16
 
+#define sqlite_open(A, B) sqlite3_open_v2(A,B, SQLITE_OPEN_READONLY+SQLITE_OPEN_NOMUTEX, NULL)
+
+#define SQLTM_TIME 150000
+#define SQLTM_COUNT 10
+
+#define SQLITE_BUSY_HANDLED(F) if(1) { \
+    int n = 0; \
+    do { rc = F ; \
+      if( (rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED) ) { \
+         n++; \
+         usleep(SQLTM_TIME); \
+      } \
+    }while( (n < SQLTM_COUNT) && ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED))); \
+  }
+
+
 void csync_set_statedb_exists(CSYNC *ctx, int val) {
   ctx->statedb.exists = val;
 }
@@ -73,85 +89,12 @@ static int _csync_check_db_integrity(sqlite3 *db) {
         c_strlist_destroy(result);
     }
 
+    if( sqlite3_threadsafe() == 0 ) {
+        CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "* WARNING: SQLite module is not threadsafe!");
+        rc = -1;
+    }
+
     return rc;
-
-}
-
-static int _csync_statedb_check(const char *statedb) {
-  int fd = -1, rc;
-  ssize_t r;
-  char buf[BUF_SIZE] = {0};
-  sqlite3 *db = NULL;
-  csync_stat_t sb;
-
-  mbchar_t *wstatedb = c_utf8_to_locale(statedb);
-
-  if (wstatedb == NULL) {
-    return -1;
-  }
-
-  /* check db version */
-#ifdef _WIN32
-    _fmode = _O_BINARY;
-#endif
-
-    fd = _topen(wstatedb, O_RDONLY);
-
-    if (fd >= 0) {
-        /* Check size. Size of zero is a valid database actually. */
-        rc = _tfstat(fd, &sb);
-
-        if (rc == 0) {
-            if (sb.st_size == 0) {
-                CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Database size is zero byte!");
-                close(fd);
-            } else {
-                r = read(fd, (void *) buf, sizeof(buf) - 1);
-                close(fd);
-                if (r >= 0) {
-                    buf[BUF_SIZE - 1] = '\0';
-                    if (c_streq(buf, "SQLite format 3")) {
-                        if (sqlite3_open(statedb, &db ) == SQLITE_OK) {
-                            rc = _csync_check_db_integrity(db);
-                            if( sqlite3_close(db) != 0 ) {
-                                CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "WARN: sqlite3_close error!");
-                            }
-
-                            if( rc >= 0 ) {
-                                /* everything is fine */
-                                c_free_locale_string(wstatedb);
-                                return 0;
-                            }
-                            CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Integrity check failed!");
-                        } else {
-                            /* resources need to be freed even when open failed */
-                            sqlite3_close(db);
-                            CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "database corrupted, removing!");
-                        }
-                    } else {
-                        CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "sqlite version mismatch");
-                    }
-                }
-            }
-        } else {
-            close(fd);
-        }
-        /* if it comes here, the database is broken and should be recreated. */
-        _tunlink(wstatedb);
-    }
-
-  c_free_locale_string(wstatedb);
-
-  /* create database */
-  rc = sqlite3_open(statedb, &db);
-  if (rc == SQLITE_OK) {
-    sqlite3_close(db);
-    csync_win32_set_file_hidden(statedb, true);
-    return 1;
-  }
-  sqlite3_close(db);
-   CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "sqlite3_open failed: %s %s", sqlite3_errmsg(db), statedb);
-   return -1;
 }
 
 static int _csync_statedb_is_empty(sqlite3 *db) {
@@ -179,7 +122,6 @@ static void sqlite_profile( void *x, const char* sql, sqlite3_uint64 time)
 
 int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
   int rc = -1;
-  int check_rc = -1;
   c_strlist_t *result = NULL;
   sqlite3 *db = NULL;
 
@@ -187,19 +129,15 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
       return -1;
   }
 
-  /* csync_statedb_check tries to open the statedb and creates it in case
+  if (ctx->statedb.db) {
-   * its not there.
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: DB already open");
-   */
+      return -1;
-  check_rc = _csync_statedb_check(statedb);
-  if (check_rc < 0) {
-    CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
-
-    rc = -1;
-    goto out;
   }
 
-  /* Open or create the temporary database */
+  ctx->statedb.lastReturnValue = SQLITE_OK;
-  if (sqlite3_open(statedb, &db) != SQLITE_OK) {
+
+  /* Openthe database */
+  if (sqlite_open(statedb, &db) != SQLITE_OK) {
     const char *errmsg= sqlite3_errmsg(ctx->statedb.db);
     CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to sqlite3 open statedb - bail out: %s.",
               errmsg ? errmsg : "<no sqlite3 errormsg>");
@@ -208,16 +146,31 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
     goto out;
   }
 
-  /* If check_rc == 1 the database is new and empty as a result. */
+  if (_csync_check_db_integrity(db) != 0) {
-  if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
+      const char *errmsg= sqlite3_errmsg(db);
-    CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: sqlite3 integrity check failed - bail out: %s.",
+                errmsg ? errmsg : "<no sqlite3 errormsg>");
+      rc = -1;
+      goto out;
+  }
+
+  if (_csync_statedb_is_empty(db)) {
+    CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb contents doesn't exist");
     csync_set_statedb_exists(ctx, 0);
   } else {
     csync_set_statedb_exists(ctx, 1);
   }
 
+  /* Print out the version */
+  //
+  result = csync_statedb_query(db, "SELECT sqlite_version();");
+  if (result && result->count >= 1) {
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "sqlite3 version \"%s\"", *result->vector);
+  }
+  c_strlist_destroy(result);
+
   /* optimization for speeding up SQLite */
-  result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
+  result = csync_statedb_query(db, "PRAGMA synchronous = NORMAL;");
   c_strlist_destroy(result);
   result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
   c_strlist_destroy(result);
@@ -230,6 +183,8 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
 #endif
   *pdb = db;
 
+   CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "Success");
+
   return 0;
 out:
   sqlite3_close(db);
@@ -244,22 +199,25 @@ int csync_statedb_close(CSYNC *ctx) {
   }
 
   /* deallocate query resources */
-  if( ctx->statedb.by_hash_stmt ) {
-      rc = sqlite3_finalize(ctx->statedb.by_hash_stmt);
-      ctx->statedb.by_hash_stmt = NULL;
-  }
-
   if( ctx->statedb.by_fileid_stmt ) {
-      rc = sqlite3_finalize(ctx->statedb.by_fileid_stmt);
+      sqlite3_finalize(ctx->statedb.by_fileid_stmt);
       ctx->statedb.by_fileid_stmt = NULL;
   }
-
+  if( ctx->statedb.by_hash_stmt ) {
+      sqlite3_finalize(ctx->statedb.by_hash_stmt);
+      ctx->statedb.by_hash_stmt = NULL;
+  }
   if( ctx->statedb.by_inode_stmt) {
-      rc = sqlite3_finalize(ctx->statedb.by_inode_stmt);
+      sqlite3_finalize(ctx->statedb.by_inode_stmt);
       ctx->statedb.by_inode_stmt = NULL;
   }
 
-  sqlite3_close(ctx->statedb.db);
+  ctx->statedb.lastReturnValue = SQLITE_OK;
+
+  int sr = sqlite3_close(ctx->statedb.db);
+  CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "sqlite3_close=%d", sr);
+
+  ctx->statedb.db = 0;
 
   return rc;
 }
@@ -281,7 +239,7 @@ static int _csync_file_stat_from_metadata_table( csync_file_stat_t **st, sqlite3
 
     column_count = sqlite3_column_count(stmt);
 
-    rc = sqlite3_step(stmt);
+    SQLITE_BUSY_HANDLED( sqlite3_step(stmt) );
 
     if( rc == SQLITE_ROW ) {
         if(column_count > 7) {
@@ -344,7 +302,8 @@ csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx,
   if( ctx->statedb.by_hash_stmt == NULL ) {
       const char *hash_query = "SELECT * FROM metadata WHERE phash=?1";
 
-      rc = sqlite3_prepare_v2(ctx->statedb.db, hash_query, strlen(hash_query), &ctx->statedb.by_hash_stmt, NULL);
+      SQLITE_BUSY_HANDLED(sqlite3_prepare_v2(ctx->statedb.db, hash_query, strlen(hash_query), &ctx->statedb.by_hash_stmt, NULL));
+      ctx->statedb.lastReturnValue = rc;
       if( rc != SQLITE_OK ) {
           CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Unable to create stmt for hash query.");
           return NULL;
@@ -358,6 +317,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx,
   sqlite3_bind_int64(ctx->statedb.by_hash_stmt, 1, (long long signed int)phash);
 
   rc = _csync_file_stat_from_metadata_table(&st, ctx->statedb.by_hash_stmt);
+  ctx->statedb.lastReturnValue = rc;
   if( !(rc == SQLITE_ROW || rc == SQLITE_DONE) )  {
       CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Could not get line from metadata: %d!", rc);
   }
@@ -385,7 +345,8 @@ csync_file_stat_t *csync_statedb_get_stat_by_file_id(CSYNC *ctx,
     if( ctx->statedb.by_fileid_stmt == NULL ) {
         const char *query = "SELECT * FROM metadata WHERE fileid=?1";
 
-        rc = sqlite3_prepare_v2(ctx->statedb.db, query, strlen(query), &ctx->statedb.by_fileid_stmt, NULL);
+        SQLITE_BUSY_HANDLED(sqlite3_prepare_v2(ctx->statedb.db, query, strlen(query), &ctx->statedb.by_fileid_stmt, NULL));
+        ctx->statedb.lastReturnValue = rc;
         if( rc != SQLITE_OK ) {
             CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Unable to create stmt for file id query.");
             return NULL;
@@ -396,6 +357,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_file_id(CSYNC *ctx,
     sqlite3_bind_text(ctx->statedb.by_fileid_stmt, 1, file_id, -1, SQLITE_STATIC);
 
     rc = _csync_file_stat_from_metadata_table(&st, ctx->statedb.by_fileid_stmt);
+    ctx->statedb.lastReturnValue = rc;
     if( !(rc == SQLITE_ROW || rc == SQLITE_DONE) ) {
         CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Could not get line from metadata: %d!", rc);
     }
@@ -423,7 +385,8 @@ csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx,
   if( ctx->statedb.by_inode_stmt == NULL ) {
       const char *inode_query = "SELECT * FROM metadata WHERE inode=?1";
 
-      rc = sqlite3_prepare_v2(ctx->statedb.db, inode_query, strlen(inode_query), &ctx->statedb.by_inode_stmt, NULL);
+      SQLITE_BUSY_HANDLED(sqlite3_prepare_v2(ctx->statedb.db, inode_query, strlen(inode_query), &ctx->statedb.by_inode_stmt, NULL));
+      ctx->statedb.lastReturnValue = rc;
       if( rc != SQLITE_OK ) {
           CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Unable to create stmt for inode query.");
           return NULL;
@@ -437,6 +400,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx,
   sqlite3_bind_int64(ctx->statedb.by_inode_stmt, 1, (long long signed int)inode);
 
   rc = _csync_file_stat_from_metadata_table(&st, ctx->statedb.by_inode_stmt);
+  ctx->statedb.lastReturnValue = rc;
   if( !(rc == SQLITE_ROW || rc == SQLITE_DONE) ) {
       CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Could not get line from metadata by inode: %d!", rc);
   }
@@ -485,7 +449,8 @@ int csync_statedb_get_below_path( CSYNC *ctx, const char *path ) {
         return -1;
     }
 
-    rc = sqlite3_prepare_v2(ctx->statedb.db, BELOW_PATH_QUERY, -1, &stmt, NULL);
+    SQLITE_BUSY_HANDLED(sqlite3_prepare_v2(ctx->statedb.db, BELOW_PATH_QUERY, -1, &stmt, NULL));
+    ctx->statedb.lastReturnValue = rc;
     if( rc != SQLITE_OK ) {
       CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "WRN: Unable to create stmt for below path query.");
       return -1;
@@ -507,6 +472,7 @@ int csync_statedb_get_below_path( CSYNC *ctx, const char *path ) {
 
     cnt = 0;
 
+    ctx->statedb.lastReturnValue = rc;
     do {
         csync_file_stat_t *st = NULL;
 
@@ -522,6 +488,7 @@ int csync_statedb_get_below_path( CSYNC *ctx, const char *path ) {
         }
     } while( rc == SQLITE_ROW );
 
+    ctx->statedb.lastReturnValue = rc;
     if( rc != SQLITE_DONE ) {
         ctx->status_code = CSYNC_STATUS_TREE_ERROR;
     } else {

csync/src/csync_statedb.h

@@ -98,27 +98,6 @@ int csync_statedb_get_below_path(CSYNC *ctx, const char *path);
  */
 c_strlist_t *csync_statedb_query(sqlite3 *db, const char *statement);
 
-/**
- * @brief Insert function for the statedb.
- *
- * @param ctx        The csync context.
- * @param statement  The SQL statement to insert into the statedb.
- *
- * @return  The rowid of the most recent INSERT on success, 0 if the query
- *          wasn't successful.
- */
-typedef struct csync_progressinfo_s {
-  struct csync_progressinfo_s *next;
-  uint64_t phash;
-  uint64_t modtime;
-  char *md5;
-  int error;
-  int chunk;
-  int transferId;
-  char *tmpfile;
-  char *error_string;
-} csync_progressinfo_t;
-
 #ifdef __cplusplus
 }
 #endif

csync/src/csync_update.c

@@ -100,6 +100,10 @@ static bool _csync_sameextension(const char *p1, const char *p2) {
 }
 #endif
 
+static bool _last_db_return_error(CSYNC* ctx) {
+    return ctx->statedb.lastReturnValue != SQLITE_OK && ctx->statedb.lastReturnValue != SQLITE_DONE && ctx->statedb.lastReturnValue != SQLITE_ROW;
+}
+
 static int _csync_detect_update(CSYNC *ctx, const char *file,
     const csync_vio_file_stat_t *fs, const int type) {
   uint64_t h = 0;
@@ -157,8 +161,8 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
     }
   }
 
-  if (ctx->current == REMOTE_REPLICA && ctx->checkBlackListHook) {
+  if (ctx->current == REMOTE_REPLICA && ctx->checkSelectiveSyncBlackListHook) {
-      if (ctx->checkBlackListHook(ctx->checkBlackListData, path)) {
+      if (ctx->checkSelectiveSyncBlackListHook(ctx->checkSelectiveSyncBlackListData, path)) {
           return 1;
       }
   }
@@ -190,8 +194,15 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
     }
 
     if (fs->mtime == 0) {
-      tmp = csync_statedb_get_stat_by_hash(ctx, h);
       CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "file: %s - mtime is zero!", path);
+
+      tmp = csync_statedb_get_stat_by_hash(ctx, h);
+      if(_last_db_return_error(ctx)) {
+          SAFE_FREE(st);
+          ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+          return -1;
+      }
+
       if (tmp == NULL) {
         CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "file: %s - not found in db, IGNORE!", path);
         st->instruction = CSYNC_INSTRUCTION_IGNORE;
@@ -228,10 +239,20 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
   if (csync_get_statedb_exists(ctx)) {
     tmp = csync_statedb_get_stat_by_hash(ctx, h);
 
+    if(_last_db_return_error(ctx)) {
+        SAFE_FREE(st);
+        ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+        return -1;
+    }
+
     if(tmp && tmp->phash == h ) { /* there is an entry in the database */
         /* we have an update! */
-        CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Database entry found, compare: %" PRId64 " <-> %" PRId64 ", etag: %s <-> %s, inode: %" PRId64 " <-> %" PRId64 ", size: %" PRId64 " <-> %" PRId64,
+        CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Database entry found, compare: %" PRId64 " <-> %" PRId64
-                  ((int64_t) fs->mtime), ((int64_t) tmp->modtime), fs->etag, tmp->etag, (uint64_t) fs->inode, (uint64_t) tmp->inode, (uint64_t) fs->size, (uint64_t) tmp->size);
+                                            ", etag: %s <-> %s, inode: %" PRId64 " <-> %" PRId64
+                                            ", size: %" PRId64 " <-> %" PRId64 ", perms: %s <-> %s",
+                  ((int64_t) fs->mtime), ((int64_t) tmp->modtime),
+                  fs->etag, tmp->etag, (uint64_t) fs->inode, (uint64_t) tmp->inode,
+                  (uint64_t) fs->size, (uint64_t) tmp->size, fs->remotePerm, tmp->remotePerm );
         if( !fs->etag) {
             st->instruction = CSYNC_INSTRUCTION_EVAL;
             goto out;
@@ -289,6 +310,12 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
 
             tmp = csync_statedb_get_stat_by_inode(ctx, fs->inode);
 
+            if(_last_db_return_error(ctx)) {
+                SAFE_FREE(st);
+                ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+                return -1;
+            }
+
             /* translate the file type between the two stat types csync has. */
             if( tmp && tmp->type == 0 ) {
                 tmp_vio_type = CSYNC_VIO_FILE_TYPE_REGULAR;
@@ -319,6 +346,12 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
         } else {
             /* Remote Replica Rename check */
             tmp = csync_statedb_get_stat_by_file_id(ctx, fs->file_id);
+
+            if(_last_db_return_error(ctx)) {
+                SAFE_FREE(st);
+                ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+                return -1;
+            }
             if(tmp ) {                           /* tmp existing at all */
                 if ((tmp->type == CSYNC_FTW_TYPE_DIR && fs->type != CSYNC_VIO_FILE_TYPE_DIRECTORY) ||
                         (tmp->type == CSYNC_FTW_TYPE_FILE && fs->type != CSYNC_VIO_FILE_TYPE_REGULAR)) {
@@ -346,8 +379,9 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
         }
     }
   } else  {
-      CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Unable to open statedb, setting inst to NEW" );
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Unable to open statedb" );
-      st->instruction = CSYNC_INSTRUCTION_NEW;
+      ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+      return -1;
   }
 
 out:
@@ -603,10 +637,13 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
     path = filename + ulen;
 
     /* skip ".csync_journal.db" and ".csync_journal.db.ctmp" */
+    /* Isn't this done via csync_exclude already? */
     if (c_streq(path, ".csync_journal.db")
             || c_streq(path, ".csync_journal.db.ctmp")
             || c_streq(path, ".csync_journal.db.ctmp-journal")
-            || c_streq(path, ".csync-progressdatabase")) {
+            || c_streq(path, ".csync-progressdatabase")
+            || c_streq(path, ".csync_journal.db-shm")
+            || c_streq(path, ".csync_journal.db-wal")) {
         csync_vio_file_stat_destroy(dirent);
         dirent = NULL;
         SAFE_FREE(filename);
@@ -652,6 +689,11 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
         uint64_t h = c_jhash64((uint8_t *) path, len, 0);
         etag = csync_statedb_get_etag( ctx, h );
 
+        if(_last_db_return_error(ctx)) {
+            ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+            goto error;
+        }
+
         if( etag ) {
             SAFE_FREE(fs->etag);
             fs->etag = etag;
@@ -671,11 +713,6 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
     rc = fn(ctx, filename, fs, flag);
     /* this function may update ctx->current and ctx->read_from_db */
 
-    if (ctx->current_fs && previous_fs && ctx->current_fs->child_modified) {
-        /* If a directory has modified files, put the flag on the parent directory as well */
-        previous_fs->child_modified = ctx->current_fs->child_modified;
-    }
-
     /* Only for the local replica we have to destroy stat(), for the remote one it is a pointer to dirent */
     if (ctx->replica == LOCAL_REPLICA) {
         csync_vio_file_stat_destroy(fs);
@@ -710,6 +747,11 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
       }
     }
 
+    if (ctx->current_fs && previous_fs && ctx->current_fs->child_modified) {
+        /* If a directory has modified files, put the flag on the parent directory as well */
+        previous_fs->child_modified = ctx->current_fs->child_modified;
+    }
+
     if (flag == CSYNC_FTW_FLAG_DIR && ctx->current_fs
         && (ctx->current_fs->instruction == CSYNC_INSTRUCTION_EVAL ||
             ctx->current_fs->instruction == CSYNC_INSTRUCTION_NEW)) {

csync/src/std/c_string.c

@@ -134,6 +134,14 @@ static char *c_iconv(const char* str, enum iconv_direction dir)
 }
 #endif /* defined(HAVE_ICONV) && defined(WITH_ICONV) */
 
+int c_strncasecmp(const char *a, const char *b, size_t n) {
+#ifdef _WIN32
+    return _strnicmp(a, b, n);
+#else
+    return strncasecmp(a, b, n);
+#endif
+}
+
 int c_streq(const char *a, const char *b) {
   register const char *s1 = a;
   register const char *s2 = b;

csync/src/std/c_string.h

@@ -59,6 +59,17 @@ struct c_strlist_s {
   size_t size;
 };
 
+/**
+ * @brief Compare to strings case insensitively.
+ *
+ * @param a  First string to compare.
+ * @param b  Second string to compare.
+ * @param n  Max comparison length.
+ *
+ * @return see strncasecmp
+ */
+int c_strncasecmp(const char *a, const char *b, size_t n);
+
 /**
  * @brief Compare to strings if they are equal.
  *

csync/tests/csync_tests/check_csync_exclude.c

@@ -174,6 +174,25 @@ static void check_csync_pathes(void **state)
     assert_int_equal(rc, CSYNC_NOT_EXCLUDED);
 }
 
+static void check_csync_is_windows_reserved_word() {
+    assert_true(csync_is_windows_reserved_word("CON"));
+    assert_true(csync_is_windows_reserved_word("con"));
+    assert_true(csync_is_windows_reserved_word("CON."));
+    assert_true(csync_is_windows_reserved_word("con."));
+    assert_true(csync_is_windows_reserved_word("CON.ference"));
+    assert_false(csync_is_windows_reserved_word("CONference"));
+    assert_false(csync_is_windows_reserved_word("conference"));
+    assert_false(csync_is_windows_reserved_word("conf.erence"));
+    assert_false(csync_is_windows_reserved_word("co"));
+    assert_true(csync_is_windows_reserved_word("A:"));
+    assert_true(csync_is_windows_reserved_word("a:"));
+    assert_true(csync_is_windows_reserved_word("z:"));
+    assert_true(csync_is_windows_reserved_word("Z:"));
+    assert_true(csync_is_windows_reserved_word("M:"));
+    assert_true(csync_is_windows_reserved_word("m:"));
+
+}
+
 int torture_run_tests(void)
 {
     const UnitTest tests[] = {
@@ -181,6 +200,7 @@ int torture_run_tests(void)
         unit_test_setup_teardown(check_csync_exclude_load, setup, teardown),
         unit_test_setup_teardown(check_csync_excluded, setup_init, teardown),
         unit_test_setup_teardown(check_csync_pathes, setup_init, teardown),
+        unit_test_setup_teardown(check_csync_is_windows_reserved_word, setup_init, teardown),
     };
 
     return run_tests(tests);

csync/tests/csync_tests/check_csync_statedb_load.c

@@ -42,6 +42,13 @@ static void setup(void **state) {
 
     csync->statedb.file = c_strdup( TESTDB );
     *state = csync;
+
+    sqlite3 *db = NULL;
+    rc = sqlite3_open_v2(TESTDB, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
+    assert_int_equal(rc, SQLITE_OK);
+
+    rc = sqlite3_close(db);
+    assert_int_equal(rc, SQLITE_OK);
 }
 
 static void teardown(void **state) {
@@ -57,37 +64,6 @@ static void teardown(void **state) {
     *state = NULL;
 }
 
-static void check_csync_statedb_check(void **state)
-{
-    int rc;
-
-    (void) state; /* unused */
-
-    rc = system("mkdir -p /tmp/check_csync1");
-
-    /* old db */
-    rc = system("echo \"SQLite format 2\" > /tmp/check_csync1/test.db");
-    assert_int_equal(rc, 0);
-    rc = _csync_statedb_check(TESTDB);
-    assert_int_equal(rc, 1);
-
-    /* db already exists */
-    rc = _csync_statedb_check(TESTDB);
-    assert_int_equal(rc, 1);
-
-    /* no db exists */
-    rc = system("rm -f /tmp/check_csync1/test.db");
-    assert_int_equal(rc, 0);
-    rc = _csync_statedb_check(TESTDB);
-    assert_int_equal(rc, 1);
-
-    rc = _csync_statedb_check("/tmp/check_csync1/");
-    assert_int_equal(rc, -1);
-
-    rc = system("rm -rf /tmp/check_csync1");
-    assert_int_equal(rc, 0);
-}
-
 static void check_csync_statedb_load(void **state)
 {
     CSYNC *csync = *state;
@@ -143,7 +119,6 @@ static void check_csync_statedb_close(void **state)
 int torture_run_tests(void)
 {
     const UnitTest tests[] = {
-        unit_test_setup_teardown(check_csync_statedb_check, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_load, setup, teardown),
         unit_test_setup_teardown(check_csync_statedb_close, setup, teardown),
     };

csync/tests/csync_tests/check_csync_statedb_query.c

@@ -47,6 +47,12 @@ static void setup(void **state)
     rc = csync_init(csync);
     assert_int_equal(rc, 0);
 
+    sqlite3 *db = NULL;
+    rc = sqlite3_open_v2(TESTDB, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
+    assert_int_equal(rc, SQLITE_OK);
+    rc = sqlite3_close(db);
+    assert_int_equal(rc, SQLITE_OK);
+
     rc = csync_statedb_load(csync, TESTDB, &csync->statedb.db);
     assert_int_equal(rc, 0);
 
@@ -55,19 +61,11 @@ static void setup(void **state)
 
 static void setup_db(void **state)
 {
-    CSYNC *csync;
+    char *errmsg;
-    char *stmt = NULL;
     int rc = 0;
-    c_strlist_t *result = NULL;
+    sqlite3 *db = NULL;
 
-    setup(state);
+    const char *sql = "CREATE TABLE IF NOT EXISTS metadata ("
-    csync = *state;
-
-    // rc = csync_statedb_create_tables(csync->statedb.db);
-    assert_int_equal(rc, 0);
-
-    result = csync_statedb_query(csync->statedb.db,
-        "CREATE TABLE IF NOT EXISTS metadata ("
         "phash INTEGER(8),"
         "pathlen INTEGER,"
         "path VARCHAR(4096),"
@@ -79,29 +77,25 @@ static void setup_db(void **state)
         "type INTEGER,"
         "md5 VARCHAR(32),"
         "PRIMARY KEY(phash)"
-        ");"
+        ");";
-        );
 
-    assert_non_null(result);
+        const char *sql2 = "INSERT INTO metadata"
-    c_strlist_destroy(result);
-
-
-    stmt = sqlite3_mprintf("INSERT INTO metadata"
                            "(phash, pathlen, path, inode, uid, gid, mode, modtime, type, md5) VALUES"
-                           "(%lu, %d, '%q', %d, %d, %d, %d, %lu, %d, %lu);",
+                           "(42, 42, 'Its funny stuff', 23, 42, 43, 55, 66, 2, 54);";
-                           42,
+
-                           42,
+
-                           "It's a rainy day",
+    setup(state);
-                           23,
+    rc = sqlite3_open( TESTDB, &db);
-                           42,
+    assert_int_equal(rc, SQLITE_OK);
-                           42,
+
-                           42,
+    rc = sqlite3_exec( db, sql, NULL, NULL, &errmsg );
-                           42,
+    assert_int_equal(rc, SQLITE_OK);
-                           2,
+
-                           43);
+    rc = sqlite3_exec( db, sql2, NULL, NULL, &errmsg );
+    assert_int_equal(rc, SQLITE_OK);
+
+    sqlite3_close(db);
 
-    // rc = csync_statedb_insert(csync->statedb.db, stmt);
-    sqlite3_free(stmt);
 }
 
 static void teardown(void **state) {
@@ -139,41 +133,6 @@ static void check_csync_statedb_query_statement(void **state)
     }
 }
 
-static void check_csync_statedb_create_error(void **state)
-{
-    CSYNC *csync = *state;
-    c_strlist_t *result;
-
-    result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
-    assert_non_null(result);
-    c_strlist_destroy(result);
-
-    result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
-    assert_null(result);
-
-    c_strlist_destroy(result);
-}
-
-static void check_csync_statedb_insert_statement(void **state)
-{
-    CSYNC *csync = *state;
-    c_strlist_t *result;
-    int rc = 0;
-
-    result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
-    assert_non_null(result);
-    c_strlist_destroy(result);
-
-    // rc = csync_statedb_insert(csync->statedb.db, "INSERT;");
-    assert_int_equal(rc, 0);
-    // rc = csync_statedb_insert(csync->statedb.db, "INSERT");
-    assert_int_equal(rc, 0);
-    // rc = csync_statedb_insert(csync->statedb.db, "");
-    assert_int_equal(rc, 0);
-}
-
-
-
 static void check_csync_statedb_drop_tables(void **state)
 {
     // CSYNC *csync = *state;
@@ -255,8 +214,6 @@ int torture_run_tests(void)
 {
     const UnitTest tests[] = {
         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_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),

csync/tests/csync_tests/check_csync_update.c

@@ -23,11 +23,64 @@
 
 #define TESTDB "/tmp/check_csync/journal.db"
 
+static int firstrun = 1;
+
+static void statedb_create_metadata_table(sqlite3 *db)
+{
+    int rc = 0;
+
+    if( db ) {
+        const char *sql = "CREATE TABLE IF NOT EXISTS metadata("
+                          "phash INTEGER(8),"
+                          "pathlen INTEGER,"
+                          "path VARCHAR(4096),"
+                          "inode INTEGER,"
+                          "uid INTEGER,"
+                          "gid INTEGER,"
+                          "mode INTEGER,"
+                          "modtime INTEGER(8),"
+                          "type INTEGER,"
+                          "md5 VARCHAR(32),"
+                          "PRIMARY KEY(phash));";
+
+        rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
+        const char *msg = sqlite3_errmsg(db);
+        assert_int_equal( rc, SQLITE_OK );
+    }
+}
+
+static void statedb_insert_metadata(sqlite3 *db)
+{
+    int rc = 0;
+
+    if( db ) {
+        char *stmt = sqlite3_mprintf("INSERT INTO metadata"
+                                     "(phash, pathlen, path, inode, uid, gid, mode, modtime,type,md5) VALUES"
+                                     "(%lld, %d, '%q', %d, %d, %d, %d, %lld, %d, '%q');",
+                                     (long long signed int)42,
+                                     42,
+                                     "I_was_wurst_before_I_became_wurstsalat",
+                                     619070,
+                                     42,
+                                     42,
+                                     42,
+                                     (long long signed int)42,
+                                     0,
+                                     "4711");
+
+        char *errmsg;
+        rc = sqlite3_exec(db, stmt, NULL, NULL, &errmsg);
+        sqlite3_free(stmt);
+        assert_int_equal( rc, SQLITE_OK );
+    }
+}
+
 static void setup(void **state)
 {
     CSYNC *csync;
     int rc;
 
+    unlink(TESTDB);
     rc = system("mkdir -p /tmp/check_csync");
     assert_int_equal(rc, 0);
     rc = system("mkdir -p /tmp/check_csync1");
@@ -38,10 +91,21 @@ static void setup(void **state)
     assert_int_equal(rc, 0);
     rc = csync_init(csync);
     assert_int_equal(rc, 0);
+
+    /* Create a new db with metadata */
+    sqlite3 *db;
+    csync->statedb.file = c_strdup(TESTDB);
+    rc = sqlite3_open(csync->statedb.file, &db);
+    statedb_create_metadata_table(db);
+    if( firstrun ) {
+        statedb_insert_metadata(db);
+        firstrun = 0;
+    }
+    sqlite3_close(db);
+
     rc = csync_statedb_load(csync, TESTDB, &csync->statedb.db);
     assert_int_equal(rc, 0);
 
-
     *state = csync;
 }
 
@@ -60,9 +124,18 @@ static void setup_ftw(void **state)
     assert_int_equal(rc, 0);
     rc = csync_init(csync);
     assert_int_equal(rc, 0);
+
+    sqlite3 *db = NULL;
+    rc = sqlite3_open_v2(TESTDB, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
+    assert_int_equal(rc, SQLITE_OK);
+    statedb_create_metadata_table(db);
+    rc = sqlite3_close(db);
+    assert_int_equal(rc, SQLITE_OK);
+
     rc = csync_statedb_load(csync, TESTDB, &csync->statedb.db);
     assert_int_equal(rc, 0);
 
+    csync->statedb.file = c_strdup( TESTDB );
     *state = csync;
 }
 
@@ -71,6 +144,7 @@ static void teardown(void **state)
     CSYNC *csync = *state;
     int rc;
 
+    unlink( csync->statedb.file);
     rc = csync_destroy(csync);
     assert_int_equal(rc, 0);
 
@@ -249,6 +323,7 @@ static void check_csync_detect_update_db_eval(void **state)
     csync_vio_file_stat_destroy(fs);
 }
 
+
 static void check_csync_detect_update_db_rename(void **state)
 {
     CSYNC *csync = *state;
@@ -256,27 +331,6 @@ static void check_csync_detect_update_db_rename(void **state)
 
     csync_vio_file_stat_t *fs;
     int rc = 0;
-    char *stmt = NULL;
-
-    // rc = csync_statedb_create_tables(csync->statedb.db);
-
-    assert_int_equal(rc, 0);
-    stmt = sqlite3_mprintf("INSERT INTO metadata"
-                           "(phash, pathlen, path, inode, uid, gid, mode, modtime,type,md5) VALUES"
-                           "(%lld, %d, '%q', %d, %d, %d, %d, %lld, %d, '%q');",
-                           (long long signed int)42,
-                           42,
-                           "I_was_wurst_before_I_became_wurstsalat",
-                           619070,
-                           42,
-                           42,
-                           42,
-                           (long long signed int)42,
-                           0,
-                           "4711");
-
-    // rc = csync_statedb_insert(csync->statedb.db, stmt);
-    sqlite3_free(stmt);
 
     fs = create_fstat("wurst.txt", 0, 1, 42);
     assert_non_null(fs);

csync/tests/ownCloud/ownCloud/Test.pm

@@ -115,6 +115,8 @@ sub initTesting(;$)
 
   $owncloud .= "/" unless( $owncloud =~ /\/$/ );
 
+  $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME} = 0;
+
   print "Connecting to ownCloud at ". $owncloud ."\n";
 
   # For SSL set the environment variable needed by the LWP module for SSL
@@ -166,7 +168,9 @@ sub testDirUrl()
 # the global var $remoteDir;
 sub initRemoteDir
 {
-  $d->open( $owncloud );
+  $d->open( $owncloud )
+       or die("Couldn't open $owncloud: " .$d->message . "\n");
+
   my $url = testDirUrl();
 
   my $re = $d->mkcol( $url );
@@ -545,7 +549,7 @@ sub putToDirLWP($$)
     my $string = <FILE>;
     close FILE;
 
-    my $ua  = LWP::UserAgent->new();
+    my $ua  = LWP::UserAgent->new( ssl_opts => { verify_hostname => 0 });
     $ua->agent( "ownCloudTest_$localDir");
     my $req = PUT $puturl, Content_Type => 'application/octet-stream',
 		  Content => $string;
@@ -579,7 +583,7 @@ sub getToFileLWP( $$ )
     my $geturl = testDirUrl() . $file;
     print "GETting $geturl to $localFile\n";
 
-    my $ua  = LWP::UserAgent->new();
+    my $ua  = LWP::UserAgent->new( ssl_opts => { verify_hostname => 0 });
     $ua->agent( "ownCloudTest_$localDir");
     $ua->credentials( server(), "foo", $user, $passwd);
     my $req = $ua->get($geturl, ":content_file" => $localFile);
@@ -718,16 +722,15 @@ sub createShare($$)
     my $re = $dd->mkcol( $url );
     if( $re == 0 ) {
 	print "Failed to create test dir $url\n";
-
     }
 
-    my $ua  = LWP::UserAgent->new();
+    my $ua  = LWP::UserAgent->new(ssl_opts => { verify_hostname => 0 } );
     $ua->agent( "ownCloudTest_sharing");
     # http://localhost/ocm/ocs/v1.php/apps/files_sharing/api/v1/shares
     my $puturl = $ocs_url . "apps/files_sharing/api/v1/shares";
 
     my $string = "path=$dir&shareType=0&shareWith=$user&publicUpload=false&permissions=$readWrite";
-    print ">>>>>>>>>> $string\n";
+    print ">>>>>>>>>> $puturl $string\n";
 
     my $req = POST $puturl, Content => $string;
     $req->authorization_basic($share_user, $share_passwd);
@@ -757,17 +760,16 @@ sub removeShare($$)
 		      -pass => $share_passwd );
     $dd->open( $owncloud);
 
-    my $ua  = LWP::UserAgent->new();
+    my $ua  = LWP::UserAgent->new(ssl_opts => { verify_hostname => 0 });
     $ua->agent( "ownCloudTest_sharing");
-    # http://localhost/ocm/ocs/v1.php/apps/files_sharing/api/v1/shares
+
-    my $url = $ocs_url . "apps/files_sharing/api/v1/shares/" . $shareId;
+    my $url = $ocs_url . "ocs/v1.php/apps/files_sharing/api/v1/shares/" . $shareId;
 
     my $req = DELETE $url;
     $req->authorization_basic($share_user, $share_passwd);
     my $response = $ua->request($req);
 
     if ($response->is_success()) {
-      # print "OK: ", $response->content;
 	print $response->decoded_content;
 	if( $response->decoded_content =~ /<status_code>(\d+)<\/status_code>/m) {
 	    my $code = $1;

csync/tests/ownCloud/t1.pl

@@ -122,8 +122,24 @@ assertLocalAndRemoteDir( '', 0);
 
 # The previous sync should have updated the etags, and this should NOT be a conflict
 printInfo( "Update the file again");
-createLocalFile( localDir() . "remoteToLocal1/kernelcrash.txt", 2136 );
+
-createLocalFile( localDir() . "remoteToLocal1/kraft_logo.gif", 2332 );
+my $f1 = localDir() . "remoteToLocal1/kernelcrash.txt";
+my $s1 = 2136;
+createLocalFile( $f1, $s1);
+
+# stat the file
+my @stat1 = stat $f1;
+print "Updating File $f1 to $s1, size is $stat1[7]\n";
+
+
+my $f2 = localDir() . "remoteToLocal1/kraft_logo.gif";
+my $s2 = 2332;
+
+createLocalFile( $f2, $s2);
+# stat the file
+my @stat2 = stat $f2;
+print "Updating File $f2 to $s2, size is $stat2[7]\n";
+
 system( "sleep 2 && touch " . localDir() . "remoteToLocal1/kernelcrash.txt" );
 csync( );
 assertLocalAndRemoteDir( '', 0);
@@ -169,6 +185,19 @@ assertLocalAndRemoteDir( '', 0);
 assert( -e localDir().'remoteToLocal1/rtlX' );
 assert( -e localDir().'remoteToLocal1/rtlX/rtl11/file.txt' );
 
+printInfo( "Remove a directory on the server with new files on the client");
+removeRemoteDir('remoteToLocal1/rtlX');
+system("echo hello > " . localDir(). "remoteToLocal1/rtlX/rtl11/hello.txt");
+csync();
+assertLocalAndRemoteDir( '', 0);
+# file.txt must be gone because the directory was removed on the server, but hello.txt must be there
+#   as it is a new file
+assert( ! -e localDir().'remoteToLocal1/rtlX/rtl11/file.txt' );
+assert( -e localDir().'remoteToLocal1/rtlX/rtl11/hello.txt' );
+
+
+
+
 # ==================================================================
 
 cleanup();

csync/tests/ownCloud/t3.pl

@@ -91,7 +91,10 @@ assertLocalAndRemoteDir( 'newdir', 0);
 assert( -e localDir().'newdir/rtl1/rtl11/newfile.dat' );
 assert( -e localDir().'newdir/rtl1/rtl11/myfile.txt' );
 assert( ! -e localDir().'newdir/rtl11/test.txt' );
-assert( ! -e localDir().'remoteToLocal1' );
+# BUG!  remoteToLocal1 is not deleted because changes were detected
+#       (even if the changed fileswere moved)
+# assert( ! -e localDir().'remoteToLocal1' );
+assert( ! -e localDir().'remoteToLocal1/rtl1' );
 
 printInfo("Move file and create another one with the same name.");
 move( localDir() . 'newdir/myfile.txt', localDir() . 'newdir/oldfile.txt' );

csync/tests/ownCloud/t6.pl

@@ -33,11 +33,13 @@ print "Hello, this is t6, a tester for csync with ownCloud.\n";
 
 initTesting();
 
-sub createPostUpdateScript()
+sub createPostUpdateScript($)
 {
-    my $srcFile = localDir()."BIG.file";
+  my ($name) = @_;
+
+    my $srcFile = localDir().'BIG1.file';
     my $cred = configValue("user") . ":" . configValue("passwd");
-    my $cmd = "curl -T $srcFile -u $cred " . testDirUrl();
+    my $cmd = "curl -T $srcFile -u $cred --insecure " . testDirUrl().$name;
     my $script = "/tmp/post_update_script.sh";
     open SC, ">$script" || die("Can not create script file");
     print SC "#!/bin/bash\n";
@@ -48,11 +50,11 @@ sub createPostUpdateScript()
     return $script;
 }
 
-sub getETagFromJournal($)
+sub getETagFromJournal($$)
 {
-    my ($num) = @_;
+    my ($name,$num) = @_;
 
-    my $sql = "sqlite3 " . localDir() . ".csync_journal.db \"SELECT md5 FROM metadata WHERE path='BIG.file';\"";
+    my $sql = "sqlite3 " . localDir() . ".csync_journal.db \"SELECT md5 FROM metadata WHERE path='$name';\"";
     open(my $fh, '-|', $sql) or die $!;
     my $etag  = <$fh>;
     close $fh;
@@ -89,26 +91,39 @@ sub chunkFileTest( $$ )
 }
 
 printInfo("Big file that needs chunking with default chunk size");
-chunkFileTest( "BIG.file", 23251233 );
+chunkFileTest( "BIG1.file", 23251233 );
 
 printInfo("Update the existing file and trigger reupload");
 # change the existing file again -> update
-chunkFileTest( "BIG.file", 21762122 );
+chunkFileTest( "BIG2.file", 21762122 );
 
 printInfo("Cause a precondition failed error");
 # Now overwrite the existing file to change it
-createLocalFile( localDir()."BIG.file", 21832199 );
+createLocalFile( localDir()."BIG3.file", 21832 );
+sleep(2);
+csync();
+createLocalFile( localDir().'BIG3.file', 34323 );
+sleep(2);
 # and create a post update script
-my $script = createPostUpdateScript();
+my $script = createPostUpdateScript('BIG3.file');
 $ENV{'OWNCLOUD_POST_UPDATE_SCRIPT'} = $script;
 
 # Save the etag before the sync
-my $firstETag = getETagFromJournal('First');
+my $firstETag = getETagFromJournal('BIG3.file', 'First');
+sleep(2);
 csync(); # Sync, which ends in a precondition failed error
 # get the etag again. It has to be unchanged because of the error.
-my $secondETag = getETagFromJournal('Second');
+my $secondETag = getETagFromJournal('BIG3.file', 'Second');
-assert( $firstETag eq $secondETag, "Different ETags, no precondition error." );
 
+# Now the result is that there is a conflict file because since 1.7
+# the sync is stopped on preconditoin failed and done again.
+my $seen = 0;
+opendir(my $dh, localDir() );
+while(readdir $dh) {
+  $seen = 1 if ( /BIG3_conflict.*\.file/ );
+}
+closedir $dh;
+assert( $seen == 1, "No conflict file created on precondition failed!" );
 unlink($script);
 
 # Set a custom chunk size in environment.

csync/tests/ownCloud/t8.pl

@@ -48,6 +48,7 @@ mkdir($tmpdir);
 createLocalFile( $tmpdir . "HELLO.dat", 100 );
 createLocalFile( $tmpdir . "Hello.dat", 150 );
 createLocalFile( $tmpdir . "Normal.dat", 110 );
+createLocalFile( $tmpdir . "test.dat", 170 );
 
 #put them in some directories
 createRemoteDir( "dir" );
@@ -73,14 +74,20 @@ assertLocalAndRemoteDir( '', 0);
 
 printInfo( "Renaming one file to the same name as another one with different casing" );
 moveRemoteFile( 'dir/Hello.dat', 'dir/NORMAL.dat');
+moveRemoteFile( 'dir/test.dat', 'dir/TEST.dat');
 
 csync();
 
-#It should not have do the move
+# Hello -> NORMAL should not have do the move since the case conflict
 assert( -e localDir() . 'dir/Hello.dat' );
 assert( !-e localDir() . 'dir/NORMAL.dat' );
 assert( -e localDir() . 'dir/Normal.dat' );
 
+#test->TEST should have been worked.
+assert( -e localDir() . 'dir/TEST.dat' );
+assert( !-e localDir() . 'dir/test.dat' );
+
+
 printInfo( "Another directory with the same name but different casing is created" );
 
 createRemoteDir( "DIR" );

shell_integration/MacOSX/CMakeLists.txt

@@ -2,10 +2,10 @@
 if(APPLE)
 add_custom_target( mac_overlayplugin ALL 
                    xcodebuild -workspace ${CMAKE_SOURCE_DIR}/shell_integration/MacOSX/OwnCloud.xcworkspace 
-                            -scheme OwnCloudFinder.osax SYMROOT=${CMAKE_CURRENT_BINARY_DIR} archive
+                            -scheme SyncStateFinder.osax SYMROOT=${CMAKE_CURRENT_BINARY_DIR} archive
                    COMMENT building Mac Overlay icons)
 
-INSTALL( DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Release/OwnCloudFinder.osax/Contents
+INSTALL( DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Release/SyncStateFinder.osax/Contents
-         DESTINATION ${CMAKE_INSTALL_PREFIX}/Library/ScriptingAdditions/OwnCloudFinder.osax/ )
+         DESTINATION ${CMAKE_INSTALL_PREFIX}/Library/ScriptingAdditions/SyncStateFinder.osax/ )
 endif(APPLE)
 

shell_integration/MacOSX/OwnCloudFinder/ContentManager.m

@@ -185,7 +185,7 @@ static ContentManager* sharedInstance = nil;
 	}
 	
 	if( [keysToDelete count] > 0 ) {
-		NSLog( @"Entries to delete: %d", [keysToDelete count]);
+		NSLog( @"Entries to delete: %lu", (unsigned long)[keysToDelete count]);
 		[_fileNamesCache removeObjectsForKeys:keysToDelete];
 	}
 }
@@ -233,7 +233,7 @@ static ContentManager* sharedInstance = nil;
 - (void)repaintAllWindowsIfNeeded
 {
 	if (!_hasChangedContent) {
-		NSLog(@"%@ Repaint scheduled but not needed", NSStringFromSelector(_cmd));
+		//NSLog(@"%@ Repaint scheduled but not needed", NSStringFromSelector(_cmd));
 		return;
 	}
 

shell_integration/MacOSX/OwnCloudFinder/FinishedIconCache.h

@@ -0,0 +1,24 @@
+//
+//  FinishedIconCache.h
+//  OwnCloudFinder
+//
+//  Created by Markus Goetz on 01/10/14.
+//
+//
+
+#import <Foundation/Foundation.h>
+#import <Cocoa/Cocoa.h>
+
+@interface FinishedIconCache : NSObject {
+	NSCache *_cache;
+	long long _hits;
+	long long _misses;
+}
+
++ (FinishedIconCache*)sharedInstance;
+
+- (NSImage*)getIcon:(NSString*)fileName overlayIconIndex:(int)idx width:(float)w height:(float)h;
+- (void)registerIcon:(NSImage*)icon withFileName:(NSString*)fileName overlayIconIndex:(int)idx width:(float)w height:(float)h;
+
+
+@end

shell_integration/MacOSX/OwnCloudFinder/FinishedIconCache.m

@@ -0,0 +1,91 @@
+//
+//  FinishedIconCache.m
+//  OwnCloudFinder
+//
+//  Created by Markus Goetz on 01/10/14.
+//
+//
+
+#import "FinishedIconCache.h"
+
+
+@interface FinishedIconCacheItem : NSObject
+@property (nonatomic, strong) NSImage *icon;
+@property (nonatomic) NSTimeInterval maxAge;
+@end
+
+@implementation FinishedIconCacheItem
+@synthesize icon;
+@synthesize maxAge;
+- (void)dealloc {
+	//NSLog(@"RELEASE %@ %@", self, self.icon);
+	if (self.icon) {
+		[self->icon release];
+	}
+	[super dealloc];
+}
+@end
+
+@implementation FinishedIconCache
+
+static FinishedIconCache* sharedInstance = nil;
+
+- init
+{
+	self = [super init];
+	if (self)
+	{
+		_cache = [[NSCache alloc] init];
+		_cache.totalCostLimit = (2880 * 1800); // mbp15 screen size
+		_hits = 0;
+		_misses = 0;
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	[_cache dealloc];
+	[super dealloc];
+}
+
++ (FinishedIconCache*)sharedInstance
+{
+	@synchronized(self)
+	{
+		if (sharedInstance == nil)
+		{
+			sharedInstance = [[self alloc] init];
+		}
+	}
+	return sharedInstance;
+}
+
+
+- (NSImage*)getIcon:(NSString*)fileName overlayIconIndex:(int)idx width:(float)w height:(float)h
+{
+	NSString *cacheKey = [NSString stringWithFormat:@"%@--%d--%f%f", fileName, idx, w,h];
+	FinishedIconCacheItem *item = [_cache objectForKey:cacheKey];
+	if (item) {
+		if (item.maxAge > [[NSDate date] timeIntervalSinceReferenceDate]) {
+			_hits++;
+			return item.icon;
+		}
+	}
+	_misses++;
+	return NULL;
+}
+
+- (void)registerIcon:(NSImage*)icon withFileName:(NSString*)fileName overlayIconIndex:(int)idx width:(float)w height:(float)h
+{
+	NSString *cacheKey = [NSString stringWithFormat:@"%@--%d--%f%f", fileName, idx, w, h];
+	FinishedIconCacheItem *item = [[FinishedIconCacheItem alloc] init];
+	item.icon = icon;
+	// max age between 1 sec and 5 sec
+	item.maxAge = [[NSDate date] timeIntervalSinceReferenceDate] + 1.0 + 4.0*((double)arc4random() / 0x100000000);
+	[_cache setObject:item forKey:cacheKey cost:w*h];
+	[item release];
+	//NSLog(@"CACHE hit/miss ratio: %f", (float)_hits/(float)_misses);
+}
+
+@end

shell_integration/MacOSX/OwnCloudFinder/IconOverlayHandlers.m

@@ -15,6 +15,7 @@
 #import <objc/runtime.h>
 #import "ContentManager.h"
 #import "IconCache.h"
+#import "FinishedIconCache.h"
 #import "IconOverlayHandlers.h"
 #import "Finder/Finder.h"
 
@@ -69,7 +70,6 @@
 
 	NSURL* url = [node previewItemURL];
 
-	NSError *error;
 	BOOL isDir;
 	if ([[NSFileManager defaultManager] fileExistsAtPath:[url path] isDirectory:&isDir] == NO) {
 		NSLog(@"ERROR: Could not determine file type of %@", [url path]);
@@ -83,15 +83,26 @@
 	{
 		NSImage* icon = [arg1 _nsImage];
 
-		[icon lockFocus];
+		// Use the short term icon cache that possibly has the finished icon
-
+		FinishedIconCache *finishedIconCache = [FinishedIconCache sharedInstance];
-		CGContextRef myContext = [[NSGraphicsContext currentContext] graphicsPort];
+		NSImage *finishedImage = [finishedIconCache getIcon:[url path] overlayIconIndex:imageIndex width:[icon size].width height:[icon size].height];
+		if (finishedImage) {
+			//NSLog(@"X Got finished image from cache %@ %@", finishedImage, [url path]);
+			return [[[IKImageWrapper alloc] initWithNSImage:finishedImage] autorelease];;
+		} else {
+			//NSLog(@"X Need to redraw %@", [url path]);
+		}
 
 		NSImage* iconimage = [[IconCache sharedInstance] getIcon:[NSNumber numberWithInt:[imageIndex intValue]]];
 
 		if (iconimage != nil)
 		{
+			[icon lockFocus];
+
+			CGContextRef myContext = [[NSGraphicsContext currentContext] graphicsPort];
+
 			CGRect destRect = CGRectMake(0, 0, [icon size].width, [icon size].height);
+
 			CGImageRef cgImage = [iconimage CGImageForProposedRect:&destRect
 														   context:[NSGraphicsContext currentContext]
 															 hints:nil];
@@ -103,9 +114,11 @@
 				NSLog(@"No image given!!!!!11 %@", [url path]);
 			}
 
+			[icon unlockFocus];
 		}
 
-		[icon unlockFocus];
+		// Insert into cache
+		[finishedIconCache registerIcon:icon withFileName:[url path] overlayIconIndex:imageIndex width:[icon size].width height:[icon size].height];
 
 		return [[[IKImageWrapper alloc] initWithNSImage:icon] autorelease];
 	}

shell_integration/MacOSX/OwnCloudFinder/JSONKit.h

@@ -1,251 +0,0 @@
-//
-//  JSONKit.h
-//  http://github.com/johnezang/JSONKit
-//  Dual licensed under either the terms of the BSD License, or alternatively
-//  under the terms of the Apache License, Version 2.0, as specified below.
-//
-
-/*
- Copyright (c) 2011, John Engelhart
- 
- All rights reserved.
- 
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
- 
- * Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 
- * Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
- 
- * Neither the name of the Zang Industries nor the names of its
- contributors may be used to endorse or promote products derived from
- this software without specific prior written permission.
- 
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/*
- Copyright 2011 John Engelhart
- 
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- 
- http://www.apache.org/licenses/LICENSE-2.0
- 
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-
-#include <stddef.h>
-#include <stdint.h>
-#include <limits.h>
-#include <TargetConditionals.h>
-#include <AvailabilityMacros.h>
-
-#ifdef    __OBJC__
-#import <Foundation/NSArray.h>
-#import <Foundation/NSData.h>
-#import <Foundation/NSDictionary.h>
-#import <Foundation/NSError.h>
-#import <Foundation/NSObjCRuntime.h>
-#import <Foundation/NSString.h>
-#endif // __OBJC__
- 
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-
-// For Mac OS X < 10.5.
-#ifndef   NSINTEGER_DEFINED
-#define   NSINTEGER_DEFINED
-#if       defined(__LP64__) || defined(NS_BUILD_32_LIKE_64)
-typedef long           NSInteger;
-typedef unsigned long  NSUInteger;
-#define NSIntegerMin   LONG_MIN
-#define NSIntegerMax   LONG_MAX
-#define NSUIntegerMax  ULONG_MAX
-#else  // defined(__LP64__) || defined(NS_BUILD_32_LIKE_64)
-typedef int            NSInteger;
-typedef unsigned int   NSUInteger;
-#define NSIntegerMin   INT_MIN
-#define NSIntegerMax   INT_MAX
-#define NSUIntegerMax  UINT_MAX
-#endif // defined(__LP64__) || defined(NS_BUILD_32_LIKE_64)
-#endif // NSINTEGER_DEFINED
-
-
-#ifndef _JSONKIT_H_
-#define _JSONKIT_H_
-
-#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__APPLE_CC__) && (__APPLE_CC__ >= 5465)
-#define JK_DEPRECATED_ATTRIBUTE __attribute__((deprecated))
-#else
-#define JK_DEPRECATED_ATTRIBUTE
-#endif
-  
-#define JSONKIT_VERSION_MAJOR 1
-#define JSONKIT_VERSION_MINOR 4
-
-typedef NSUInteger JKFlags;
-
-/*
-  JKParseOptionComments        : Allow C style // and /_* ... *_/ (without a _, obviously) comments in JSON.
-  JKParseOptionUnicodeNewlines : Allow Unicode recommended (?:\r\n|[\n\v\f\r\x85\p{Zl}\p{Zp}]) newlines.
-  JKParseOptionLooseUnicode    : Normally the decoder will stop with an error at any malformed Unicode.
-                                 This option allows JSON with malformed Unicode to be parsed without reporting an error.
-                                 Any malformed Unicode is replaced with \uFFFD, or "REPLACEMENT CHARACTER".
- */
-
-enum {
-  JKParseOptionNone                     = 0,
-  JKParseOptionStrict                   = 0,
-  JKParseOptionComments                 = (1 << 0),
-  JKParseOptionUnicodeNewlines          = (1 << 1),
-  JKParseOptionLooseUnicode             = (1 << 2),
-  JKParseOptionPermitTextAfterValidJSON = (1 << 3),
-  JKParseOptionValidFlags               = (JKParseOptionComments | JKParseOptionUnicodeNewlines | JKParseOptionLooseUnicode | JKParseOptionPermitTextAfterValidJSON),
-};
-typedef JKFlags JKParseOptionFlags;
-
-enum {
-  JKSerializeOptionNone                 = 0,
-  JKSerializeOptionPretty               = (1 << 0),
-  JKSerializeOptionEscapeUnicode        = (1 << 1),
-  JKSerializeOptionEscapeForwardSlashes = (1 << 4),
-  JKSerializeOptionValidFlags           = (JKSerializeOptionPretty | JKSerializeOptionEscapeUnicode | JKSerializeOptionEscapeForwardSlashes),
-};
-typedef JKFlags JKSerializeOptionFlags;
-
-#ifdef    __OBJC__
-
-typedef struct JKParseState JKParseState; // Opaque internal, private type.
-
-// As a general rule of thumb, if you use a method that doesn't accept a JKParseOptionFlags argument, it defaults to JKParseOptionStrict
-
-@interface JSONDecoder : NSObject {
-  JKParseState *parseState;
-}
-+ (id)decoder;
-+ (id)decoderWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (id)initWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (void)clearCache;
-
-// The parse... methods were deprecated in v1.4 in favor of the v1.4 objectWith... methods.
-- (id)parseUTF8String:(const unsigned char *)string length:(size_t)length                         JK_DEPRECATED_ATTRIBUTE; // Deprecated in JSONKit v1.4.  Use objectWithUTF8String:length:        instead.
-- (id)parseUTF8String:(const unsigned char *)string length:(size_t)length error:(NSError **)error JK_DEPRECATED_ATTRIBUTE; // Deprecated in JSONKit v1.4.  Use objectWithUTF8String:length:error:  instead.
-// The NSData MUST be UTF8 encoded JSON.
-- (id)parseJSONData:(NSData *)jsonData                                                            JK_DEPRECATED_ATTRIBUTE; // Deprecated in JSONKit v1.4.  Use objectWithData:                     instead.
-- (id)parseJSONData:(NSData *)jsonData error:(NSError **)error                                    JK_DEPRECATED_ATTRIBUTE; // Deprecated in JSONKit v1.4.  Use objectWithData:error:               instead.
-
-// Methods that return immutable collection objects.
-- (id)objectWithUTF8String:(const unsigned char *)string length:(NSUInteger)length;
-- (id)objectWithUTF8String:(const unsigned char *)string length:(NSUInteger)length error:(NSError **)error;
-// The NSData MUST be UTF8 encoded JSON.
-- (id)objectWithData:(NSData *)jsonData;
-- (id)objectWithData:(NSData *)jsonData error:(NSError **)error;
-
-// Methods that return mutable collection objects.
-- (id)mutableObjectWithUTF8String:(const unsigned char *)string length:(NSUInteger)length;
-- (id)mutableObjectWithUTF8String:(const unsigned char *)string length:(NSUInteger)length error:(NSError **)error;
-// The NSData MUST be UTF8 encoded JSON.
-- (id)mutableObjectWithData:(NSData *)jsonData;
-- (id)mutableObjectWithData:(NSData *)jsonData error:(NSError **)error;
-
-@end
-
-////////////
-#pragma mark Deserializing methods
-////////////
-
-@interface NSString (JSONKitDeserializing)
-- (id)objectFromJSONString;
-- (id)objectFromJSONStringWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (id)objectFromJSONStringWithParseOptions:(JKParseOptionFlags)parseOptionFlags error:(NSError **)error;
-- (id)mutableObjectFromJSONString;
-- (id)mutableObjectFromJSONStringWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (id)mutableObjectFromJSONStringWithParseOptions:(JKParseOptionFlags)parseOptionFlags error:(NSError **)error;
-@end
-
-@interface NSData (JSONKitDeserializing)
-// The NSData MUST be UTF8 encoded JSON.
-- (id)objectFromJSONData;
-- (id)objectFromJSONDataWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (id)objectFromJSONDataWithParseOptions:(JKParseOptionFlags)parseOptionFlags error:(NSError **)error;
-- (id)mutableObjectFromJSONData;
-- (id)mutableObjectFromJSONDataWithParseOptions:(JKParseOptionFlags)parseOptionFlags;
-- (id)mutableObjectFromJSONDataWithParseOptions:(JKParseOptionFlags)parseOptionFlags error:(NSError **)error;
-@end
-
-////////////
-#pragma mark Serializing methods
-////////////
-  
-@interface NSString (JSONKitSerializing)
-// Convenience methods for those that need to serialize the receiving NSString (i.e., instead of having to serialize a NSArray with a single NSString, you can "serialize to JSON" just the NSString).
-// Normally, a string that is serialized to JSON has quotation marks surrounding it, which you may or may not want when serializing a single string, and can be controlled with includeQuotes:
-// includeQuotes:YES `a "test"...` -> `"a \"test\"..."`
-// includeQuotes:NO  `a "test"...` -> `a \"test\"...`
-- (NSData *)JSONData;     // Invokes JSONDataWithOptions:JKSerializeOptionNone   includeQuotes:YES
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions includeQuotes:(BOOL)includeQuotes error:(NSError **)error;
-- (NSString *)JSONString; // Invokes JSONStringWithOptions:JKSerializeOptionNone includeQuotes:YES
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions includeQuotes:(BOOL)includeQuotes error:(NSError **)error;
-@end
-
-@interface NSArray (JSONKitSerializing)
-- (NSData *)JSONData;
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions error:(NSError **)error;
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingDelegate:(id)delegate selector:(SEL)selector error:(NSError **)error;
-- (NSString *)JSONString;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions error:(NSError **)error;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingDelegate:(id)delegate selector:(SEL)selector error:(NSError **)error;
-@end
-
-@interface NSDictionary (JSONKitSerializing)
-- (NSData *)JSONData;
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions error:(NSError **)error;
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingDelegate:(id)delegate selector:(SEL)selector error:(NSError **)error;
-- (NSString *)JSONString;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions error:(NSError **)error;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingDelegate:(id)delegate selector:(SEL)selector error:(NSError **)error;
-@end
-
-#ifdef __BLOCKS__
-
-@interface NSArray (JSONKitSerializingBlockAdditions)
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingBlock:(id(^)(id object))block error:(NSError **)error;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingBlock:(id(^)(id object))block error:(NSError **)error;
-@end
-
-@interface NSDictionary (JSONKitSerializingBlockAdditions)
-- (NSData *)JSONDataWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingBlock:(id(^)(id object))block error:(NSError **)error;
-- (NSString *)JSONStringWithOptions:(JKSerializeOptionFlags)serializeOptions serializeUnsupportedClassesUsingBlock:(id(^)(id object))block error:(NSError **)error;
-@end
-  
-#endif
-
-
-#endif // __OBJC__
-
-#endif // _JSONKIT_H_
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif

shell_integration/MacOSX/OwnCloudFinder/OwnCloudFinder.xcodeproj/project.pbxproj

@@ -7,9 +7,9 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		0B13ECAE173C687400548DA1 /* GCDAsyncSocket.m in Sources */ = {isa = PBXBuildFile; fileRef = 0B13ECAD173C686A00548DA1 /* GCDAsyncSocket.m */; };
+		0B13ECAE173C687400548DA1 /* GCDAsyncSocket.m in Sources */ = {isa = PBXBuildFile; fileRef = 0B13ECAD173C686A00548DA1 /* GCDAsyncSocket.m */; settings = {COMPILER_FLAGS = "-fobjc-arc"; }; };
 		0B13ECAF173C687900548DA1 /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0BFC9ACB173C57E400CDD329 /* Security.framework */; };
-		0BFAF21C16F8E6C10017EA7E /* JSONKit.m in Sources */ = {isa = PBXBuildFile; fileRef = 0BFAF21B16F8E6C10017EA7E /* JSONKit.m */; };
+		5BB74A8719DBF9BB001BAAAC /* FinishedIconCache.m in Sources */ = {isa = PBXBuildFile; fileRef = 5BB74A8619DBF9BB001BAAAC /* FinishedIconCache.m */; };
 		692C18A516660C4700BF6A53 /* ContextMenuHandlers.m in Sources */ = {isa = PBXBuildFile; fileRef = 692C18A416660C4600BF6A53 /* ContextMenuHandlers.m */; };
 		692C18A9166617F500BF6A53 /* IconOverlayHandlers.m in Sources */ = {isa = PBXBuildFile; fileRef = 692C18A8166617F500BF6A53 /* IconOverlayHandlers.m */; };
 		692C18AC1666392700BF6A53 /* MenuManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 692C18AB1666392700BF6A53 /* MenuManager.m */; };
@@ -29,9 +29,9 @@
 		0B13ECAC173C686900548DA1 /* GCDAsyncSocket.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GCDAsyncSocket.h; sourceTree = "<group>"; };
 		0B13ECAD173C686A00548DA1 /* GCDAsyncSocket.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = GCDAsyncSocket.m; sourceTree = "<group>"; };
 		0B2BF60B176A43DB001246CD /* Finder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Finder.h; sourceTree = "<group>"; };
-		0BFAF21A16F8E6C10017EA7E /* JSONKit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSONKit.h; sourceTree = "<group>"; };
-		0BFAF21B16F8E6C10017EA7E /* JSONKit.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = JSONKit.m; sourceTree = "<group>"; };
 		0BFC9ACB173C57E400CDD329 /* Security.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Security.framework; path = System/Library/Frameworks/Security.framework; sourceTree = SDKROOT; };
+		5BB74A8519DBF9BB001BAAAC /* FinishedIconCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FinishedIconCache.h; sourceTree = "<group>"; };
+		5BB74A8619DBF9BB001BAAAC /* FinishedIconCache.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FinishedIconCache.m; sourceTree = "<group>"; };
 		692C18A316660C4600BF6A53 /* ContextMenuHandlers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ContextMenuHandlers.h; sourceTree = "<group>"; };
 		692C18A416660C4600BF6A53 /* ContextMenuHandlers.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ContextMenuHandlers.m; sourceTree = "<group>"; };
 		692C18A7166617F500BF6A53 /* IconOverlayHandlers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IconOverlayHandlers.h; sourceTree = "<group>"; };
@@ -48,7 +48,7 @@
 		8C37DDB9161594B400016A95 /* Quartz.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Quartz.framework; path = System/Library/Frameworks/Quartz.framework; sourceTree = SDKROOT; };
 		8C99F6921622D145002D2135 /* IconCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IconCache.h; sourceTree = "<group>"; };
 		8C99F6931622D145002D2135 /* IconCache.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = IconCache.m; sourceTree = "<group>"; };
-		8D576316048677EA00EA77CD /* OwnCloudFinder.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = OwnCloudFinder.bundle; sourceTree = BUILT_PRODUCTS_DIR; };
+		8D576316048677EA00EA77CD /* SyncStateFinder.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SyncStateFinder.bundle; sourceTree = BUILT_PRODUCTS_DIR; };
 		8D576317048677EA00EA77CD /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
@@ -67,7 +67,7 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
-		089C166AFE841209C02AAC07 /* OwnCloudFinder */ = {
+		089C166AFE841209C02AAC07 /* SyncStateFinder */ = {
 			isa = PBXGroup;
 			children = (
 				08FB77AFFE84173DC02AAC07 /* Source */,
@@ -75,7 +75,7 @@
 				089C1671FE841209C02AAC07 /* External Frameworks and Libraries */,
 				19C28FB6FE9D52B211CA2CBB /* Products */,
 			);
-			name = OwnCloudFinder;
+			name = SyncStateFinder;
 			sourceTree = "<group>";
 			usesTabs = 1;
 		};
@@ -104,7 +104,6 @@
 			children = (
 				0B2BF60A176A43DB001246CD /* Finder */,
 				0B08BAC21759627700C8351E /* GCDAsyncSocket */,
-				0BFAF21916F8E6910017EA7E /* JSONKit */,
 				8C37DD99161593BD00016A95 /* FinderHook.h */,
 				8C37DD9A161593BD00016A95 /* FinderHook.m */,
 				692C18A316660C4600BF6A53 /* ContextMenuHandlers.h */,
@@ -117,6 +116,8 @@
 				69948B351636D50E0093B6CE /* ContentManager.m */,
 				8C99F6921622D145002D2135 /* IconCache.h */,
 				8C99F6931622D145002D2135 /* IconCache.m */,
+				5BB74A8519DBF9BB001BAAAC /* FinishedIconCache.h */,
+				5BB74A8619DBF9BB001BAAAC /* FinishedIconCache.m */,
 				692C18AA1666392700BF6A53 /* MenuManager.h */,
 				692C18AB1666392700BF6A53 /* MenuManager.m */,
 			);
@@ -140,19 +141,10 @@
 			path = Finder;
 			sourceTree = "<group>";
 		};
-		0BFAF21916F8E6910017EA7E /* JSONKit */ = {
-			isa = PBXGroup;
-			children = (
-				0BFAF21A16F8E6C10017EA7E /* JSONKit.h */,
-				0BFAF21B16F8E6C10017EA7E /* JSONKit.m */,
-			);
-			name = JSONKit;
-			sourceTree = "<group>";
-		};
 		19C28FB6FE9D52B211CA2CBB /* Products */ = {
 			isa = PBXGroup;
 			children = (
-				8D576316048677EA00EA77CD /* OwnCloudFinder.bundle */,
+				8D576316048677EA00EA77CD /* SyncStateFinder.bundle */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -160,9 +152,9 @@
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
-		8D57630D048677EA00EA77CD /* OwnCloudFinder */ = {
+		8D57630D048677EA00EA77CD /* SyncStateFinder */ = {
 			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "OwnCloudFinder" */;
+			buildConfigurationList = 1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "SyncStateFinder" */;
 			buildPhases = (
 				8D57630F048677EA00EA77CD /* Resources */,
 				8D576311048677EA00EA77CD /* Sources */,
@@ -172,10 +164,10 @@
 			);
 			dependencies = (
 			);
-			name = OwnCloudFinder;
+			name = SyncStateFinder;
 			productInstallPath = "$(HOME)/Library/Bundles";
-			productName = OwnCloudFinder;
+			productName = SyncStateFinder;
-			productReference = 8D576316048677EA00EA77CD /* OwnCloudFinder.bundle */;
+			productReference = 8D576316048677EA00EA77CD /* SyncStateFinder.bundle */;
 			productType = "com.apple.product-type.bundle";
 		};
 /* End PBXNativeTarget section */
@@ -186,7 +178,7 @@
 			attributes = {
 				LastUpgradeCheck = 0460;
 			};
-			buildConfigurationList = 1DEB911E08733D790010E9CD /* Build configuration list for PBXProject "OwnCloudFinder" */;
+			buildConfigurationList = 1DEB911E08733D790010E9CD /* Build configuration list for PBXProject "SyncStateFinder" */;
 			compatibilityVersion = "Xcode 3.2";
 			developmentRegion = English;
 			hasScannedForEncodings = 1;
@@ -196,11 +188,11 @@
 				French,
 				German,
 			);
-			mainGroup = 089C166AFE841209C02AAC07 /* OwnCloudFinder */;
+			mainGroup = 089C166AFE841209C02AAC07 /* SyncStateFinder` */;
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
-				8D57630D048677EA00EA77CD /* OwnCloudFinder */,
+				8D57630D048677EA00EA77CD /* SyncStateFinder */,
 			);
 		};
 /* End PBXProject section */
@@ -226,10 +218,10 @@
 				8C99F6941622D145002D2135 /* IconCache.m in Sources */,
 				69948B361636D50E0093B6CE /* ContentManager.m in Sources */,
 				6993878616494C000044E4DF /* RequestManager.m in Sources */,
+				5BB74A8719DBF9BB001BAAAC /* FinishedIconCache.m in Sources */,
 				692C18A516660C4700BF6A53 /* ContextMenuHandlers.m in Sources */,
 				692C18A9166617F500BF6A53 /* IconOverlayHandlers.m in Sources */,
 				692C18AC1666392700BF6A53 /* MenuManager.m in Sources */,
-				0BFAF21C16F8E6C10017EA7E /* JSONKit.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -260,7 +252,7 @@
 				GCC_OPTIMIZATION_LEVEL = 0;
 				INFOPLIST_FILE = Info.plist;
 				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				PRODUCT_NAME = OwnCloudFinder;
+				PRODUCT_NAME = SyncStateFinder;
 				WRAPPER_EXTENSION = bundle;
 			};
 			name = Debug;
@@ -277,7 +269,7 @@
 				GCC_MODEL_TUNING = G5;
 				INFOPLIST_FILE = Info.plist;
 				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				PRODUCT_NAME = OwnCloudFinder;
+				PRODUCT_NAME = SyncStateFinder;
 				WRAPPER_EXTENSION = bundle;
 			};
 			name = Release;
@@ -302,8 +294,9 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ARCHS = "$(ARCHS_STANDARD_32_64_BIT)";
-				COPY_PHASE_STRIP = YES;
+				COPY_PHASE_STRIP = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_OPTIMIZATION_LEVEL = 0;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				MACOSX_DEPLOYMENT_TARGET = 10.7;
@@ -315,7 +308,7 @@
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
-		1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "OwnCloudFinder" */ = {
+		1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "SyncStateFinder" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				1DEB911B08733D790010E9CD /* Debug */,
@@ -324,7 +317,7 @@
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
-		1DEB911E08733D790010E9CD /* Build configuration list for PBXProject "OwnCloudFinder" */ = {
+		1DEB911E08733D790010E9CD /* Build configuration list for PBXProject "SyncStateFinder" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				1DEB911F08733D790010E9CD /* Debug */,

shell_integration/MacOSX/OwnCloudFinder/RequestManager.m

@@ -83,7 +83,7 @@ static RequestManager* sharedInstance = nil;
 	NSArray *regPathes = [_registeredPathes allKeys];
 	BOOL registered = NO;
 
-	NSString* checkPath = [[NSString alloc] initWithString:path];
+	NSString* checkPath = [NSString stringWithString:path];
 	if (isDir) {
 		// append a slash
 		checkPath = [path stringByAppendingString:@"/"];
@@ -127,17 +127,17 @@ static RequestManager* sharedInstance = nil;
 
 - (void)socket:(GCDAsyncSocket*)socket didReadData:(NSData*)data withTag:(long)tag
 {
-	NSArray *chunks;
 	NSString *answer = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+	NSArray *chunks = nil;
 	if (answer != nil && [answer length] > 0) {
 		// cut a trailing newline
 		answer = [answer substringToIndex:[answer length] - 1];
 		chunks = [answer componentsSeparatedByString: @":"];
 	}
-	NSLog(@"READ from socket (%ld): <%@>", tag, answer);
 	ContentManager *contentman = [ContentManager sharedInstance];
 
-	if( [chunks count] > 0 && tag == READ_TAG ) {
+	if( chunks && [chunks count] > 0 && tag == READ_TAG ) {
+		NSLog(@"READ from socket (%ld): <%@>", tag, answer);
 		if( [[chunks objectAtIndex:0] isEqualToString:@"STATUS"] ) {
 			NSString *path = [chunks objectAtIndex:2];
 			if( [chunks count] > 3 ) {
@@ -168,8 +168,8 @@ static RequestManager* sharedInstance = nil;
 		} else {
 			NSLog(@"Unknown command %@", [chunks objectAtIndex:0]);
 		}
-	} else {
+	} else if (tag != READ_TAG) {
-		NSLog(@"Received unknown tag %ld", tag);
+		NSLog(@"Received unknown tag %ld <%@>", tag, answer);
 	}
 	// Read on and on
 	NSData* stop = [@"\n" dataUsingEncoding:NSUTF8StringEncoding];
@@ -202,7 +202,7 @@ static RequestManager* sharedInstance = nil;
 	if( [_requestQueue count] > 0 ) {
 		NSLog( @"We have to empty the queue");
 		for( NSString *path in _requestQueue ) {
-			[self askOnSocket:path];
+			[self askOnSocket:path query:@"RETRIEVE_FILE_STATUS"];
 		}
 	}
 
@@ -253,7 +253,7 @@ static RequestManager* sharedInstance = nil;
 				NSLog(@"I goofed: %@", err);
 			}
 		} else if (!useTcp) {
-			NSURL *url;
+			NSURL *url = nil;
 			NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
 			if ([paths count])
 			{

shell_integration/MacOSX/OwnCloudInjector/OwnCloudInjector.m

@@ -27,7 +27,7 @@ static NSString* globalLock = @"I'm the global lock to prevent concruent handler
 @end
 
 static bool liferayNativityLoaded = false;
-static NSString* liferayNativityBundleName = @"OwnCloudFinder";
+static NSString* liferayNativityBundleName = @"SyncStateFinder";
 
 typedef struct {
   NSString* location;
@@ -85,7 +85,7 @@ static OSErr loadBundle(LNBundleType type, AppleEvent* reply, long refcon) {
   }
 
   if (isLoaded) {
-    NSLog(@"LiferayNativityInjector: %@ already loaded.", bundleName);
+    NSLog(@"OwnCloudInjector: %@ already loaded.", bundleName);
     return noErr;
   }
 

shell_integration/MacOSX/OwnCloudInjector/OwnCloudInjector.xcodeproj/project.pbxproj

@@ -7,7 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		0B36CB92182461A10039B237 /* OwnCloudFinder.bundle in Resources */ = {isa = PBXBuildFile; fileRef = 0B36CB91182461A10039B237 /* OwnCloudFinder.bundle */; };
+		0B36CB92182461A10039B237 /* SyncStateFinder.bundle in Resources */ = {isa = PBXBuildFile; fileRef = 0B36CB91182461A10039B237 /* SyncStateFinder.bundle */; };
 		0BD9C38E1778EF450094CF5D /* license.txt in Resources */ = {isa = PBXBuildFile; fileRef = 0BD9C38D1778EF450094CF5D /* license.txt */; };
 		8D576314048677EA00EA77CD /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0AA1909FFE8422F4C02AAC07 /* CoreFoundation.framework */; };
 		8D5B49A804867FD3000E48DA /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 8D5B49A704867FD3000E48DA /* InfoPlist.strings */; };
@@ -19,10 +19,10 @@
 /* Begin PBXFileReference section */
 		089C167EFE841241C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
 		0AA1909FFE8422F4C02AAC07 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = /System/Library/Frameworks/CoreFoundation.framework; sourceTree = "<absolute>"; };
-		0B36CB91182461A10039B237 /* OwnCloudFinder.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; path = OwnCloudFinder.bundle; sourceTree = BUILT_PRODUCTS_DIR; };
+		0B36CB91182461A10039B237 /* SyncStateFinder.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; path = SyncStateFinder.bundle; sourceTree = BUILT_PRODUCTS_DIR; };
 		0BD9C38D1778EF450094CF5D /* license.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = license.txt; sourceTree = "<group>"; };
 		8D576317048677EA00EA77CD /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		D60A992314CE37030061AD6D /* OwnCloudFinder.osax */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = OwnCloudFinder.osax; sourceTree = BUILT_PRODUCTS_DIR; };
+		D60A992314CE37030061AD6D /* SyncStateFinder.osax */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SyncStateFinder.osax; sourceTree = BUILT_PRODUCTS_DIR; };
 		D6ACBE9E117B7D5600F6691C /* OwnCloudInjector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = OwnCloudInjector.m; sourceTree = "<group>"; };
 		D6ACBE9F117B7D5600F6691C /* LNVersionComparisonProtocol.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LNVersionComparisonProtocol.h; sourceTree = "<group>"; };
 		D6ACBEA0117B7D5600F6691C /* LNStandardVersionComparator.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LNStandardVersionComparator.m; sourceTree = "<group>"; };
@@ -51,7 +51,7 @@
 				D60A992414CE37030061AD6D /* Products */,
 			);
 			indentWidth = 2;
-			name = "TotalFinder-osax";
+			name = "SyncStateFinder-osax";
 			sourceTree = "<group>";
 			tabWidth = 2;
 			usesTabs = 0;
@@ -67,7 +67,7 @@
 		089C167CFE841241C02AAC07 /* Resources */ = {
 			isa = PBXGroup;
 			children = (
-				0B36CB91182461A10039B237 /* OwnCloudFinder.bundle */,
+				0B36CB91182461A10039B237 /* SyncStateFinder.bundle */,
 				D6ACBEA4117B7D6100F6691C /* OwnCloudInjector.sdef */,
 				8D576317048677EA00EA77CD /* Info.plist */,
 				8D5B49A704867FD3000E48DA /* InfoPlist.strings */,
@@ -90,7 +90,7 @@
 		D60A992414CE37030061AD6D /* Products */ = {
 			isa = PBXGroup;
 			children = (
-				D60A992314CE37030061AD6D /* OwnCloudFinder.osax */,
+				D60A992314CE37030061AD6D /* SyncStateFinder.osax */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -98,9 +98,9 @@
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
-		8D57630D048677EA00EA77CD /* OwnCloudFinder.osax */ = {
+		8D57630D048677EA00EA77CD /* SyncStateFinder.osax */ = {
 			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "OwnCloudFinder.osax" */;
+			buildConfigurationList = 1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "SyncStateFinder.osax" */;
 			buildPhases = (
 				8D57630F048677EA00EA77CD /* Resources */,
 				8D576311048677EA00EA77CD /* Sources */,
@@ -110,10 +110,10 @@
 			);
 			dependencies = (
 			);
-			name = OwnCloudFinder.osax;
+			name = SyncStateFinder.osax;
 			productInstallPath = "$(HOME)/Library/Bundles";
-			productName = "TotalFinder-osax";
+			productName = "SyncStateFinder-osax";
-			productReference = D60A992314CE37030061AD6D /* OwnCloudFinder.osax */;
+			productReference = D60A992314CE37030061AD6D /* SyncStateFinder.osax */;
 			productType = "com.apple.product-type.bundle";
 		};
 /* End PBXNativeTarget section */
@@ -139,7 +139,7 @@
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
-				8D57630D048677EA00EA77CD /* OwnCloudFinder.osax */,
+				8D57630D048677EA00EA77CD /* SyncStateFinder.osax */,
 			);
 		};
 /* End PBXProject section */
@@ -149,7 +149,7 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				0B36CB92182461A10039B237 /* OwnCloudFinder.bundle in Resources */,
+				0B36CB92182461A10039B237 /* SyncStateFinder.bundle in Resources */,
 				8D5B49A804867FD3000E48DA /* InfoPlist.strings in Resources */,
 				D6ACBEA5117B7D6100F6691C /* OwnCloudInjector.sdef in Resources */,
 				0BD9C38E1778EF450094CF5D /* license.txt in Resources */,
@@ -195,7 +195,7 @@
 					"-framework",
 					AppKit,
 				);
-				PRODUCT_NAME = OwnCloudFinder;
+				PRODUCT_NAME = SyncStateFinder;
 				SKIP_INSTALL = YES;
 				WRAPPER_EXTENSION = osax;
 			};
@@ -214,7 +214,7 @@
 					"-framework",
 					AppKit,
 				);
-				PRODUCT_NAME = OwnCloudFinder;
+				PRODUCT_NAME = SyncStateFinder;
 				WRAPPER_EXTENSION = osax;
 			};
 			name = Release;
@@ -245,7 +245,7 @@
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
-		1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "OwnCloudFinder.osax" */ = {
+		1DEB911A08733D790010E9CD /* Build configuration list for PBXNativeTarget "SyncStateFinder.osax" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				1DEB911B08733D790010E9CD /* Debug */,

shell_integration/MacOSX/OwnCloudInjector/OwnCloudInjector.xcodeproj/xcshareddata/xcschemes/SyncStateFinder.osax.xcscheme

@@ -15,8 +15,8 @@
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "8D57630D048677EA00EA77CD"
-               BuildableName = "OwnCloudFinder.bundle"
+               BuildableName = "SyncStateFinder.bundle"
-               BlueprintName = "OwnCloudFinder"
+               BlueprintName = "SyncStateFinder"
                ReferencedContainer = "container:../OwnCloudFinder/OwnCloudFinder.xcodeproj">
             </BuildableReference>
          </BuildActionEntry>
@@ -29,8 +29,8 @@
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "8D57630D048677EA00EA77CD"
-               BuildableName = "OwnCloudFinder.osax"
+               BuildableName = "SyncStateFinder.osax"
-               BlueprintName = "OwnCloudFinder.osax"
+               BlueprintName = "SyncStateFinder.osax"
                ReferencedContainer = "container:OwnCloudInjector.xcodeproj">
             </BuildableReference>
          </BuildActionEntry>

shell_integration/MacOSX/deploy.sh

@@ -1,10 +1,10 @@
 #!/bin/sh
 # osascript $HOME/owncloud.com/mirall/shell_integration/MacOSX/unload.scpt
 
-sudo rm -rf /Library/ScriptingAdditions/OwnCloudFinder.osax
+sudo rm -rf /Library/ScriptingAdditions/SyncStateFinder.osax
 # Klaas' machine
-OSAXDIR=$HOME/Library/Developer/Xcode/DerivedData/OwnCloud-*/Build/Products/Debug/OwnCloudFinder.osax
+OSAXDIR=$HOME/Library/Developer/Xcode/DerivedData/OwnCloud-*/Build/Products/Debug/SyncStateFinder.osax
-[ -d $OSAXDIR ] ||OSAXDIR=$HOME/Library/Developer/Xcode/DerivedData/OwnCloud-*/Build/Intermediates/ArchiveIntermediates/OwnCloudFinder.osax/IntermediateBuildFilesPath/UninstalledProducts/OwnCloudFinder.osax
+[ -d $OSAXDIR ] ||OSAXDIR=$HOME/Library/Developer/Xcode/DerivedData/OwnCloud-*/Build/Intermediates/ArchiveIntermediates/SyncStateFinder.osax/IntermediateBuildFilesPath/UninstalledProducts/SyncStateFinder.osax
 
 # Markus' machine
 [ -d $OSAXDIR ] || echo "OSAX does not exist"

shell_integration/nautilus/syncstate.py

@@ -34,6 +34,7 @@ class syncStateExtension(GObject.GObject, Nautilus.ColumnProvider, Nautilus.Info
             GObject.timeout_add(5000, self.connectToSocketServer)
 
     def connectToSocketServer(self):
+        do_reconnect = True
         try:
             self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             postfix = "/"+self.appname+"/socket"
@@ -44,15 +45,18 @@ class syncStateExtension(GObject.GObject, Nautilus.ColumnProvider, Nautilus.Info
 		    print("Socket File: "+sock_file)
 		    self.sock.connect(sock_file)
 		    self.connected = True
+		    print("Setting connected to %r" % self.connected )
 		    self.watch_id = GObject.io_add_watch(self.sock, GObject.IO_IN, self.handle_notify)
-		except:
+		    do_reconnect = False
-		    print("Could not connect to unix socket.")
+		except Exception, e:
+		    print("Could not connect to unix socket." + str(e))
 	    else:
 		 print("Sock-File not valid: "+sock_file)
-        except:
+        except Exception, e:
-            print("Connect could not be established, try again later!")
+            print("Connect could not be established, try again later " + str(e))
             self.sock.close()
-        return not self.connected
+        # print("Returning %r" % do_reconnect)
+        return do_reconnect
 
     def sendCommand(self, cmd):
         if self.connected:
@@ -122,7 +126,7 @@ class syncStateExtension(GObject.GObject, Nautilus.ColumnProvider, Nautilus.Info
 			if( not itemStore['state'] or newState != itemStore['state'] ):
 			    item = itemStore['item']
 			    item.add_emblem(emblem)
-			    # print "Setting emblem on " + parts[2]
+			    # print "Setting emblem on " + parts[2]+ "<>"+emblem+"<>"
 			    self.nautilusVFSFile_table[parts[2]] = {'item': item, 'state':newState}
 
             elif action == 'UPDATE_VIEW':

shell_integration/windows/OCShellExtensions/OCOverlays/OCOverlay.cpp

@@ -36,17 +36,13 @@ extern HINSTANCE instanceHandle;
 #define IDM_DISPLAY 0  
 #define IDB_OK 101
 
-namespace {
-	static std::vector<std::wstring> s_watchedDirectories;
-}
-
 OCOverlay::OCOverlay(int state) 
-	: _communicationSocket(0)
+	: _referenceCount(1)
-	, _referenceCount(1)
-	, _checker(new RemotePathChecker(PORT))
 	, _state(state)
 
 {
+    static RemotePathChecker s_remotePathChecker;
+    _checker = &s_remotePathChecker;
 }
 
 OCOverlay::~OCOverlay(void)
@@ -121,23 +117,13 @@ IFACEMETHODIMP OCOverlay::GetPriority(int *pPriority)
 
  IFACEMETHODIMP OCOverlay::IsMemberOf(PCWSTR pwszPath, DWORD dwAttrib)
 {
-	
+    auto watchedDirectories = _checker->WatchedDirectories();
-	//if(!_IsOverlaysEnabled())
-	//{
-	//	return MAKE_HRESULT(S_FALSE, 0, 0);
-	//}
-
-	// FIXME: Use Registry instead, this will only trigger once
-	// and now follow any user changes in the client
-	if (s_watchedDirectories.empty()) {
-		s_watchedDirectories = _checker->WatchedDirectories();
-	}
 
 	wstring wpath(pwszPath);
-	wpath.append(L"\\");
+	//wpath.append(L"\\");
 	vector<wstring>::iterator it;
 	bool watched = false;
-	for (it = s_watchedDirectories.begin(); it != s_watchedDirectories.end(); ++it) {
+	for (it = watchedDirectories.begin(); it != watchedDirectories.end(); ++it) {
 		if (StringUtil::begins_with(wpath, *it)) {
 			watched = true;
 		}

shell_integration/windows/OCShellExtensions/OCOverlays/OCOverlay.h

@@ -35,14 +35,13 @@ public:
     IFACEMETHODIMP_(ULONG) Release();
 
 protected:
-    ~OCOverlay(void);
+    ~OCOverlay();
 
 private:
 	//bool _GenerateMessage(const wchar_t*, std::wstring*);
 
 	bool _IsOverlaysEnabled();
     long _referenceCount;
-	CommunicationSocket* _communicationSocket;
 	RemotePathChecker* _checker;
 	int _state;
 };

shell_integration/windows/OCShellExtensions/OCOverlays/OCOverlayRegistrationHandler.cpp

@@ -62,7 +62,7 @@ HRESULT OCOverlayRegistrationHandler::RemoveRegistryEntries(PCWSTR friendlyName)
 	}
 
 	HKEY syncExOverlayKey = NULL;
-	hResult = HRESULT_FROM_WIN32(RegDeleteKeyEx(shellOverlayKey, friendlyName, DELETE, 0));
+	hResult = HRESULT_FROM_WIN32(RegDeleteKey(shellOverlayKey, friendlyName));
 	if (!SUCCEEDED(hResult)) {
 		return hResult;
 	}
@@ -137,12 +137,12 @@ HRESULT OCOverlayRegistrationHandler::UnregisterCOMObject(const CLSID& clsid)
 		return hResult;
 	}
 
-	hResult = HRESULT_FROM_WIN32(RegDeleteKeyEx(clsidKey, REGISTRY_IN_PROCESS, DELETE, 0));
+	hResult = HRESULT_FROM_WIN32(RegDeleteKey(clsidKey, REGISTRY_IN_PROCESS));
 	if(!SUCCEEDED(hResult)) {
 		return hResult;
 	}
 
-	hResult = HRESULT_FROM_WIN32(RegDeleteKeyEx(hKey, stringCLSID, DELETE, 0));
+	hResult = HRESULT_FROM_WIN32(RegDeleteKey(hKey, stringCLSID));
 	if(!SUCCEEDED(hResult)) {
 		return hResult;
 	}

shell_integration/windows/OCShellExtensions/OCUtil/CommunicationSocket.cpp

@@ -21,6 +21,7 @@
 #include <windows.h>
 #include <iostream>
 #include <vector>
+#include <array>
 
 #include <fstream> 
 
@@ -30,8 +31,8 @@ using namespace std;
 
 #define DEFAULT_BUFLEN 4096
 
-CommunicationSocket::CommunicationSocket(int port)
+CommunicationSocket::CommunicationSocket()
-	: _port(port), _clientSocket(INVALID_SOCKET)
+    : _pipe(INVALID_HANDLE_VALUE)
 {
 }
 
@@ -43,45 +44,20 @@ CommunicationSocket::~CommunicationSocket()
 bool CommunicationSocket::Close()
 {
 	WSACleanup();
-	bool closed = (closesocket(_clientSocket) == 0);
+	if (_pipe == INVALID_HANDLE_VALUE) {
-	shutdown(_clientSocket, SD_BOTH);
-	_clientSocket = INVALID_SOCKET;
-	return closed;
-}
-
-
-bool CommunicationSocket::Connect()
-{
-	WSADATA wsaData;
-
-	HRESULT iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
-
-	if (iResult != NO_ERROR) {
-		int error = WSAGetLastError();
-	}
-
-
-	_clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-
-	if (_clientSocket == INVALID_SOCKET) {
-		//int error = WSAGetLastError();
-		Close();
 		return false;
 	}
+	CloseHandle(_pipe);
+	_pipe = INVALID_HANDLE_VALUE;
+	return true;
+}
 
-	struct sockaddr_in clientService;
 
-	clientService.sin_family = AF_INET;
+bool CommunicationSocket::Connect(const std::wstring &pipename)
-	clientService.sin_addr.s_addr = inet_addr(PLUG_IN_SOCKET_ADDRESS);
+{
-	clientService.sin_port = htons(_port);
+	_pipe = CreateFile(pipename.data(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 
-	iResult = connect(_clientSocket, (SOCKADDR*)&clientService, sizeof(clientService));
+    if (_pipe == INVALID_HANDLE_VALUE) {
-	DWORD timeout = 500; // ms
-	setsockopt(_clientSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*) &timeout, sizeof(DWORD));
-
-	if (iResult == SOCKET_ERROR) {
-		//int error = WSAGetLastError();
-		Close();
         return false;
     }
     return true;
@@ -89,18 +65,18 @@ bool CommunicationSocket::Connect()
 
 bool CommunicationSocket::SendMsg(const wchar_t* message)
 {
-	const char* utf8_msg = StringUtil::toUtf8(message);
+	auto utf8_msg = StringUtil::toUtf8(message);
-	size_t result = send(_clientSocket, utf8_msg, (int)strlen(utf8_msg), 0);
+
-	delete[] utf8_msg;
+    DWORD numBytesWritten = 0;
+    auto result = WriteFile( _pipe, utf8_msg.c_str(), DWORD(utf8_msg.size()), &numBytesWritten, NULL);
+
+    if (result) {
+        return true;
+    } else {
+        Close();
 
-	if (result == SOCKET_ERROR) {
-		//int error = WSAGetLastError();
-		closesocket(_clientSocket);
         return false;
     }
-
-	return true;
-
 }
 
 bool CommunicationSocket::ReadLine(wstring* response)
@@ -109,21 +85,43 @@ bool CommunicationSocket::ReadLine(wstring* response)
 		return false;
 	}
 
-	vector<char> resp_utf8;
+    response->clear();
-	char buffer;
+
-	while (true) {
+    if (_pipe == INVALID_HANDLE_VALUE) {
-		int bytesRead = recv(_clientSocket, &buffer, 1, 0);
-		if (bytesRead <= 0) {
-			response = 0;
         return false;
     }
 
-		if (buffer == '\n')	{
+
-			resp_utf8.push_back(0);
+	while (true) {
-			*response = StringUtil::toUtf16(&resp_utf8[0], resp_utf8.size());
+        int lbPos = 0;
+        auto it = std::find(_buffer.begin() + lbPos, _buffer.end(), '\n');
+        if (it != _buffer.end()) {
+            *response = StringUtil::toUtf16(_buffer.data(), DWORD(it - _buffer.begin()));
+            _buffer.erase(_buffer.begin(), it + 1);
             return true;
-		} else {
+        }
-			resp_utf8.push_back(buffer);
+
-		}
+        std::array<char, 128> resp_utf8;
+        DWORD numBytesRead = 0;
+		DWORD totalBytesAvailable = 0;
+		auto result = PeekNamedPipe(_pipe, NULL, 0, 0, &totalBytesAvailable, 0);
+		if (!result) {
+			Close();
+			return false;
+		}
+		if (totalBytesAvailable == 0) {
+			return false;
+		}
+
+        result = ReadFile(_pipe, resp_utf8.data(), DWORD(resp_utf8.size()), &numBytesRead, NULL);
+        if (!result) {
+            Close();
+            return false;
+        }
+        if (numBytesRead <= 0) {
+            return false;
+        }
+		_buffer.insert(_buffer.end(), resp_utf8.begin(), resp_utf8.begin()+numBytesRead);
+        continue;
 	}
 }

shell_integration/windows/OCShellExtensions/OCUtil/CommunicationSocket.h

@@ -20,23 +20,27 @@
 #pragma warning (disable : 4251)
 
 #include <string>
+#include <vector>
 #include <WinSock2.h>
 
 class __declspec(dllexport) CommunicationSocket
 {
 public:
-	CommunicationSocket(int port);
+	CommunicationSocket();
 	~CommunicationSocket();
 
-	bool Connect();
+	bool Connect(const std::wstring& pipename);
 	bool Close();
 
 	bool SendMsg(const wchar_t*);
 	bool ReadLine(std::wstring*);
 
+    HANDLE Event() { return _pipe; }
+
 private:	
-	int _port;
+	HANDLE _pipe;
-	SOCKET _clientSocket;
+	std::vector<char> _buffer;
+    bool _connected;
 };
 
 #endif

shell_integration/windows/OCShellExtensions/OCUtil/RemotePathChecker.cpp

@@ -20,88 +20,173 @@
 #include <iostream>
 #include <sstream>
 #include <iterator>
+#include <unordered_set>
+#include <cassert>
+
+#include <shlobj.h>
 
 using namespace std;
 
-RemotePathChecker::RemotePathChecker(int port)
+
-	: _port(port)
+// This code is run in a thread
+void RemotePathChecker::workerThreadLoop()
 {
+    auto pipename = std::wstring(L"\\\\.\\pipe\\");
+    pipename += L"ownCloud";
+
+    bool connected = false;
+    CommunicationSocket socket;
+    std::unordered_set<std::wstring> asked;
+
+    while(!_stop) {
+		Sleep(50);
+
+        if (!connected) {
+            asked.clear();
+            if (!WaitNamedPipe(pipename.data(), 5 * 1000)) {
+                continue;
+            }
+            if (!socket.Connect(pipename)) {
+                continue;
+            }
+            connected = true;
+            std::unique_lock<std::mutex> lock(_mutex);
+            _connected = true;
+        }
+
+        {
+            std::unique_lock<std::mutex> lock(_mutex);
+            while (!_pending.empty() && !_stop) {
+                auto filePath = _pending.front();
+                _pending.pop();
+
+                lock.unlock();
+                if (!asked.count(filePath)) {
+                    asked.insert(filePath);
+                    socket.SendMsg(wstring(L"RETRIEVE_FILE_STATUS:" + filePath + L'\n').data());
+                }
+                lock.lock();
+            }
+        }
+
+        std::wstring response;
+        while (!_stop && socket.ReadLine(&response)) {
+			if (StringUtil::begins_with(response, wstring(L"REGISTER_PATH:"))) {
+				wstring responsePath = response.substr(14); // length of REGISTER_PATH:
+
+				{   std::unique_lock<std::mutex> lock(_mutex);
+					_watchedDirectories.push_back(responsePath);
+				}
+				SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, responsePath.data(), NULL);
+			} else if (StringUtil::begins_with(response, wstring(L"UNREGISTER_PATH:"))) {
+                wstring responsePath = response.substr(16); // length of UNREGISTER_PATH:
+
+                {   std::unique_lock<std::mutex> lock(_mutex);
+                    _watchedDirectories.erase(
+                        std::remove(_watchedDirectories.begin(), _watchedDirectories.end(), responsePath),
+                        _watchedDirectories.end());
+
+                    // Remove any item from the cache
+                    for (auto it = _cache.begin(); it != _cache.end() ; ) {
+                        if (StringUtil::begins_with(it->first, responsePath)) {
+                            it = _cache.erase(it);
+                        } else {
+                            ++it;
+                        }
+                    }
+                }
+                SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, responsePath.data(), NULL);
+            } else if (StringUtil::begins_with(response, wstring(L"STATUS:")) ||
+                    StringUtil::begins_with(response, wstring(L"BROADCAST:"))) {
+
+                auto statusBegin = response.find(L':', 0);
+                assert(statusBegin != std::wstring::npos);
+
+                auto statusEnd = response.find(L':', statusBegin + 1);
+                if (statusEnd == std::wstring::npos) {
+                    // the command do not contains two colon?
+                    continue;
+                }
+
+                auto responseStatus = response.substr(statusBegin+1, statusEnd - statusBegin-1);
+                auto responsePath = response.substr(statusEnd+1);
+                auto state = _StrToFileState(responseStatus);
+                auto erased = asked.erase(responsePath);
+
+                bool changed = false;
+                {   std::unique_lock<std::mutex> lock(_mutex);
+                    auto &it = _cache[responsePath];
+                    changed = it == state;
+                    it = state;
+                }
+                if (changed) {
+                    SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, responsePath.data(), NULL);
+                }
+            }
+        }
+
+		if (socket.Event() == INVALID_HANDLE_VALUE) {
+			std::unique_lock<std::mutex> lock(_mutex);
+			_cache.clear();
+			_watchedDirectories.clear();
+			_connected = connected = false;
+		}
+
+		if (_stop) return;
+
+		HANDLE handles[2] = { _newQueries, socket.Event() };
+		WaitForMultipleObjects(2, handles, false, 0);
+    }
+}
+
+
+
+RemotePathChecker::RemotePathChecker()
+    : _connected(false)
+    , _newQueries(CreateEvent(NULL, true, true, NULL))
+	, _thread([this]{ this->workerThreadLoop(); })
+{
+}
+
+RemotePathChecker::~RemotePathChecker()
+{
+    _stop = true;
+    //_newQueries.notify_all();
+    SetEvent(_newQueries);
+    _thread.join();
+    CloseHandle(_newQueries);
 }
 
 vector<wstring> RemotePathChecker::WatchedDirectories()
 {
-	vector<wstring> watchedDirectories;
+    std::unique_lock<std::mutex> lock(_mutex);
-	wstring response;
+    return _watchedDirectories;
-	bool needed = false;
-
-	CommunicationSocket socket(_port);
-	socket.Connect();
-
-	while (socket.ReadLine(&response)) {
-		if (StringUtil::begins_with(response, wstring(L"REGISTER_PATH:"))) {
-			size_t pathBegin = response.find(L':', 0);
-			if (pathBegin == -1) {
-				continue;
-			}
-
-			// chop trailing '\n'
-			wstring responsePath = response.substr(pathBegin + 1, response.length()-1);
-			watchedDirectories.push_back(responsePath);
-		}
-	}
-
-	return watchedDirectories;
 }
 
 bool RemotePathChecker::IsMonitoredPath(const wchar_t* filePath, int* state)
 {
-	wstring request;
+    assert(state); assert(filePath);
-	wstring response;
-	bool needed = false;
 
-	CommunicationSocket socket(_port);
+    std::unique_lock<std::mutex> lock(_mutex);
-	socket.Connect();
+    if (!_connected) {
-	request = L"RETRIEVE_FILE_STATUS:";
-	request += filePath;
-	request += L'\n';
-
-	if (!socket.SendMsg(request.c_str())) {
         return false;
     }
 
-	while (socket.ReadLine(&response)) {
+    auto path = std::wstring(filePath);
-		// discard broadcast messages
+
-		if (StringUtil::begins_with(response, wstring(L"STATUS:"))) {
+    auto it = _cache.find(path);
-			break;
+    if (it != _cache.end()) {
-		}
+        *state = it->second;
+        return true;
     }
 
-	size_t statusBegin = response.find(L':', 0);
+    _pending.push(filePath);
-	if (statusBegin == -1)
+    SetEvent(_newQueries);
     return false;
 
-	size_t statusEnd = response.find(L':', statusBegin + 1);
-	if (statusEnd == -1)
-		return false;
-
-
-	wstring responseStatus = response.substr(statusBegin+1, statusEnd - statusBegin-1);
-	wstring responsePath = response.substr(statusEnd+1);
-	if (responsePath == filePath) {
-		if (!state) {
-			return false;
-		}
-		*state = _StrToFileState(responseStatus);
-		if (*state == StateNone) {
-			return false;
-		}
-		needed = true;
 }
 
-	return needed;
+RemotePathChecker::FileState RemotePathChecker::_StrToFileState(const std::wstring &str)
-}
-
-int RemotePathChecker::_StrToFileState(const std::wstring &str)
 {
 	if (str == L"NOP" || str == L"NONE") {
 		return StateNone;

shell_integration/windows/OCShellExtensions/OCUtil/RemotePathChecker.h

@@ -16,6 +16,12 @@
 
 #include <string>
 #include <vector>
+#include <unordered_map>
+#include <queue>
+#include <thread>
+#include <mutex>
+#include <atomic>
+#include <condition_variable>
 
 #pragma once    
 
@@ -29,14 +35,33 @@ public:
 		StateWarning, StateWarningSWM,
 		StateNone
 	};
-	RemotePathChecker(int port);
+	RemotePathChecker();
+    ~RemotePathChecker();
 	std::vector<std::wstring> WatchedDirectories();
 	bool IsMonitoredPath(const wchar_t* filePath, int* state);
 
 private:
-	int _StrToFileState(const std::wstring &str);
+	FileState _StrToFileState(const std::wstring &str);
-	int _port;
+    std::mutex _mutex;
+    std::atomic<bool> _stop;
 
+    // Everything here is protected by the _mutex
+
+    /** The list of paths we need to query. The main thread fill this, and the worker thread
+     * send that to the socket. */
+    std::queue<std::wstring> _pending;
+
+    std::unordered_map<std::wstring, FileState> _cache;
+    std::vector<std::wstring> _watchedDirectories;
+    bool _connected;
+
+
+    // The main thread notifies when there are new items in _pending
+    //std::condition_variable _newQueries;
+    HANDLE _newQueries;
+
+	std::thread _thread;
+    void workerThreadLoop();
 };
 
 #endif

shell_integration/windows/OCShellExtensions/OCUtil/StringUtil.cpp

@@ -11,22 +11,26 @@
 * details.
 */
 
-#include <Windows.h>
+#include <locale>
+#include <string>
+#include <codecvt>
 
 #include "StringUtil.h"
 
-char* StringUtil::toUtf8(const wchar_t *utf16, int len)
+std::string StringUtil::toUtf8(const wchar_t *utf16, int len)
 {
-	int newlen = WideCharToMultiByte(CP_UTF8, 0, utf16, len, NULL, 0, NULL, NULL);
+	if (len < 0) {
-	char* str = new char[newlen];
+		len = wcslen(utf16);
-	WideCharToMultiByte(CP_UTF8, 0, utf16, -1, str, newlen, NULL, NULL);
+	}
-	return str;
+    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> > converter;
+    return converter.to_bytes(utf16, utf16+len);
 }
 
-wchar_t* StringUtil::toUtf16(const char *utf8, int len)
+std::wstring StringUtil::toUtf16(const char *utf8, int len)
 {
-	int newlen = MultiByteToWideChar(CP_UTF8, 0, utf8, len, NULL, 0);
+	if (len < 0) {
-	wchar_t* wstr = new wchar_t[newlen];
+		len = strlen(utf8);
-	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, newlen);
+	}
-	return wstr;
+	std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> > converter;
+    return converter.from_bytes(utf8, utf8+len);
 }

shell_integration/windows/OCShellExtensions/OCUtil/StringUtil.h

@@ -20,15 +20,14 @@
 
 class __declspec(dllexport) StringUtil {
 public:
-	static char*    toUtf8(const wchar_t* utf16, int len = -1);
+	static std::string  toUtf8(const wchar_t* utf16, int len = -1);
-	static wchar_t* toUtf16(const char* utf8, int len = -1);
+	static std::wstring toUtf16(const char* utf8, int len = -1);
-
 
 	template<class T>
 	static bool begins_with(const T& input, const T& match)
 	{
 		return input.size() >= match.size()
-			&& equal(match.begin(), match.end(), input.begin());
+			&& std::equal(match.begin(), match.end(), input.begin());
 	}
 };
 

src/CMakeLists.txt

@@ -75,6 +75,7 @@ set(libsync_SRCS
     mirall/propagator_legacy.cpp
     mirall/syncjournalfilerecord.cpp
     mirall/syncjournaldb.cpp
+    mirall/ownsql.cpp
     mirall/theme.cpp
     mirall/owncloudtheme.cpp
     mirall/logger.cpp
@@ -337,7 +338,6 @@ set(ownCloud ${ownCloud_old})
 if (WITH_DBUS)
     set(ADDITIONAL_APP_MODULES DBus)
 endif(WITH_DBUS)
-
 if(NOT BUILD_OWNCLOUD_OSX_BUNDLE AND NOT BUILD_LIBRARIES_ONLY)
     set(BIN_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 
@@ -368,8 +368,15 @@ elseif(NOT BUILD_LIBRARIES_ONLY)
 
     set (QM_DIR ${OWNCLOUD_OSX_BUNDLE}/Contents/Resources/Translations)
     install(FILES ${mirall_I18N} DESTINATION ${QM_DIR})
+    get_target_property(_qmake Qt5::qmake LOCATION)
+    execute_process(COMMAND ${_qmake} -query QT_INSTALL_TRANSLATIONS
+        OUTPUT_VARIABLE QT_TRANSLATIONS_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
     file(GLOB qt_I18N ${QT_TRANSLATIONS_DIR}/qt_??.qm ${QT_TRANSLATIONS_DIR}/qt_??_??.qm)
     install(FILES ${qt_I18N} DESTINATION ${QM_DIR})
+    file(GLOB qtbase_I18N ${QT_TRANSLATIONS_DIR}/qtbase_??.qm ${QT_TRANSLATIONS_DIR}/qt_??_??.qm)
+    install(FILES ${qtbase_I18N} DESTINATION ${QM_DIR})
     file(GLOB qtkeychain_I18N ${QT_TRANSLATIONS_DIR}/qtkeychain*.qm)
     install(FILES ${qtkeychain_I18N} DESTINATION ${QM_DIR})
 endif()
@@ -382,9 +389,11 @@ if(NOT BUILD_LIBRARIES_ONLY)
   set_target_properties( ${APPLICATION_EXECUTABLE} PROPERTIES
           RUNTIME_OUTPUT_DIRECTORY  ${BIN_OUTPUT_DIRECTORY}
   )
+  # Only relevant for Linux? On OS X it by default properly checks in the bundle directory next to the exe
   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 )
@@ -442,8 +451,9 @@ endif()
 # currently it needs to be done because the code right above needs to be executed no matter
 # if building a bundle or not and the install_qt4_executable needs to be called afterwards
 if(BUILD_OWNCLOUD_OSX_BUNDLE AND NOT BUILD_LIBRARIES_ONLY)
+   get_target_property (QT_QMAKE_EXECUTABLE Qt5::qmake IMPORTED_LOCATION)
    install(CODE "
     message(STATUS \"Deploying (Qt) dependencies and fixing library pathes...\")
-    execute_process(COMMAND \"${CMAKE_SOURCE_DIR}/admin/osx/macdeployqt.py\" ${CMAKE_INSTALL_PREFIX}/${OWNCLOUD_OSX_BUNDLE})
+    execute_process(COMMAND \"${CMAKE_SOURCE_DIR}/admin/osx/macdeployqt.py\" ${CMAKE_INSTALL_PREFIX}/${OWNCLOUD_OSX_BUNDLE} ${QT_QMAKE_EXECUTABLE})
     " COMPONENT RUNTIME)
 endif()

src/creds/httpcredentials.cpp

@@ -65,9 +65,13 @@ int getauth(const char *prompt,
     } else if( qPrompt == QLatin1String("Enter your password:") ) {
         // qDebug() << "OOO Password requested!";
         qstrncpy( buf, pwd.toUtf8().constData(), len );
+    } else {
+        if( http_credentials->sslIsTrusted() ) {
+            qstrcpy( buf, "yes" ); // Certificate is fine!
         } else {
             re = handleNeonSSLProblems(prompt, buf, len, echo, verify, userdata);
         }
+    }
     return re;
 }
 

src/creds/httpcredentials.h

@@ -52,6 +52,7 @@ public:
     virtual QString queryPassword(bool *ok) = 0;
     void invalidateToken(Account *account) Q_DECL_OVERRIDE;
     QString fetchUser(Account *account);
+    virtual bool sslIsTrusted() { return false; }
 
 private Q_SLOTS:
     void slotAuthentication(QNetworkReply*, QAuthenticator*);

src/main.cpp

@@ -82,6 +82,7 @@ int main(int argc, char **argv)
 
     // if the application is already running, notify it.
     if( app.isRunning() ) {
+        qDebug() << Q_FUNC_INFO << "Already running, exiting...";
         QStringList args = app.arguments();
         if ( args.size() > 1 && ! app.giveHelp() ) {
             QString msg = args.join( QLatin1String("|") );

src/mirall/accountsettings.cpp

@@ -605,7 +605,7 @@ void AccountSettings::slotSetProgress(const QString& folder, const Progress::Inf
     item->setData( QVariant(true), FolderStatusDelegate::AddProgressSpace );
 
     if (!progress._currentDiscoveredFolder.isEmpty()) {
-        item->setData( tr("Discovering %1").arg(progress._currentDiscoveredFolder) , FolderStatusDelegate::SyncProgressItemString );
+        item->setData( tr("Discovering '%1'").arg(progress._currentDiscoveredFolder) , FolderStatusDelegate::SyncProgressItemString );
         return;
     }
 

src/mirall/application.cpp

@@ -534,12 +534,15 @@ void Application::setupTranslations()
             setProperty("ui_lang", lang);
             const QString qtTrPath = QLibraryInfo::location(QLibraryInfo::TranslationsPath);
             const QString qtTrFile = QLatin1String("qt_") + lang;
-            if (qtTranslator->load(qtTrFile, qtTrPath)) {
+            const QString qtBaseTrFile = QLatin1String("qtbase_") + lang;
-                qtTranslator->load(qtTrFile, trPath);
+            if (!qtTranslator->load(qtTrFile, qtTrPath)) {
+                if (!qtTranslator->load(qtTrFile, trPath)) {
+                    qtTranslator->load(qtBaseTrFile, trPath);
                 }
-            const QString qtkeychainFile = QLatin1String("qt_") + lang;
+            }
-            if (!qtkeychainTranslator->load(qtkeychainFile, qtTrPath)) {
+            const QString qtkeychainTrFile = QLatin1String("qtkeychain_") + lang;
-               qtkeychainTranslator->load(qtkeychainFile, trPath);
+            if (!qtkeychainTranslator->load(qtkeychainTrFile, qtTrPath)) {
+                qtkeychainTranslator->load(qtkeychainTrFile, trPath);
             }
             if (!translator->isEmpty())
                 installTranslator(translator);

src/mirall/discoveryphase.cpp

@@ -16,9 +16,11 @@
 #include <csync_private.h>
 #include <qdebug.h>
 
+#include <QUrl>
+
 namespace Mirall {
 
-bool DiscoveryJob::isInBlackList(const QString& path) const
+bool DiscoveryJob::isInSelectiveSyncBlackList(const QString& path) const
 {
     if (_selectiveSyncBlackList.isEmpty()) {
         // If there is no black list, everything is allowed
@@ -35,19 +37,24 @@ bool DiscoveryJob::isInBlackList(const QString& path) const
 
     auto it = std::lower_bound(_selectiveSyncBlackList.begin(), _selectiveSyncBlackList.end(), pathSlash);
 
+    if (it != _selectiveSyncBlackList.end() && *it == pathSlash) {
+        return true;
+    }
+
 	if (it == _selectiveSyncBlackList.begin()) {
         return false;
     }
     --it;
-    if (pathSlash.startsWith(*it + QLatin1Char('/'))) {
+    Q_ASSERT(it->endsWith(QLatin1Char('/'))); // Folder::setSelectiveSyncBlackList makes sure of that
+    if (pathSlash.startsWith(*it)) {
         return true;
     }
     return false;
 }
 
-int DiscoveryJob::isInBlackListCallBack(void *data, const char *path)
+int DiscoveryJob::isInSelectiveSyncBlackListCallBack(void *data, const char *path)
 {
-    return static_cast<DiscoveryJob*>(data)->isInBlackList(QString::fromUtf8(path));
+    return static_cast<DiscoveryJob*>(data)->isInSelectiveSyncBlackList(QString::fromUtf8(path));
 }
 
 void DiscoveryJob::update_job_update_callback (bool local,
@@ -65,15 +72,15 @@ void DiscoveryJob::update_job_update_callback (bool local,
             updateJob->lastUpdateProgressCallbackCall.restart();
         }
 
-        QString path = QString::fromUtf8(dirUrl).section('/', -1);
+        QString path(QUrl::fromPercentEncoding(QByteArray(dirUrl)).section('/', -1));
         emit updateJob->folderDiscovered(local, path);
     }
 }
 
 void DiscoveryJob::start() {
     _selectiveSyncBlackList.sort();
-    _csync_ctx->checkBlackListHook = isInBlackListCallBack;
+    _csync_ctx->checkSelectiveSyncBlackListHook = isInSelectiveSyncBlackListCallBack;
-    _csync_ctx->checkBlackListData = this;
+    _csync_ctx->checkSelectiveSyncBlackListData = this;
 
     _csync_ctx->callbacks.update_callback = update_job_update_callback;
     _csync_ctx->callbacks.update_callback_userdata = this;
@@ -85,8 +92,8 @@ void DiscoveryJob::start() {
     lastUpdateProgressCallbackCall.invalidate();
     int ret = csync_update(_csync_ctx);
 
-    _csync_ctx->checkBlackListHook = 0;
+    _csync_ctx->checkSelectiveSyncBlackListHook = 0;
-    _csync_ctx->checkBlackListData = 0;
+    _csync_ctx->checkSelectiveSyncBlackListData = 0;
 
     _csync_ctx->callbacks.update_callback = 0;
     _csync_ctx->callbacks.update_callback_userdata = 0;

src/mirall/discoveryphase.h

@@ -40,8 +40,8 @@ class DiscoveryJob : public QObject {
      * return true if the given path should be synced,
      * false if the path should be ignored
      */
-    bool isInBlackList(const QString &path) const;
+    bool isInSelectiveSyncBlackList(const QString &path) const;
-    static int isInBlackListCallBack(void *, const char *);
+    static int isInSelectiveSyncBlackListCallBack(void *, const char *);
 
     static void update_job_update_callback (bool local,
                                             const char *dirname,

src/mirall/folder.cpp

@@ -60,6 +60,9 @@ Folder::Folder(const QString &alias, const QString &path, const QString& secondP
       , _csyncUnavail(false)
       , _wipeDb(false)
       , _proxyDirty(true)
+      , _forceSyncOnPollTimeout(false)
+      , _consecutiveFailingSyncs(0)
+      , _consecutiveFollowUpSyncs(0)
       , _journal(path)
       , _csync_ctx(0)
 {
@@ -269,13 +272,40 @@ void Folder::slotPollTimerTimeout()
         return;
     }
 
-    if (quint64(_timeSinceLastSync.elapsed()) > MirallConfigFile().forceSyncInterval() ||
+    bool forceSyncIntervalExpired =
-            _lastEtag.isNull() ||
+            quint64(_timeSinceLastSync.elapsed()) > MirallConfigFile().forceSyncInterval();
-            !(_syncResult.status() == SyncResult::Success ||_syncResult.status() == SyncResult::Problem)) {
+    bool syncAgainAfterFail = _consecutiveFailingSyncs > 0 && _consecutiveFailingSyncs < 3;
-        qDebug() << "** Force Sync now, state is " << _syncResult.statusString();
+
+    // There are several conditions under which we trigger a full-discovery sync:
+    // * When a suitably long time has passed since the last sync finished
+    // * When the last sync failed (only a couple of times)
+    // * When the last sync requested another sync to be done (only a couple of times)
+    //
+    // Note that the etag check (see below) and the file watcher may also trigger
+    // syncs.
+    if (forceSyncIntervalExpired
+            || _forceSyncOnPollTimeout
+            || syncAgainAfterFail) {
+
+        if (forceSyncIntervalExpired) {
+            qDebug() << "** Force Sync, because it has been " << _timeSinceLastSync.elapsed() << "ms "
+                     << "since the last sync";
+        }
+        if (_forceSyncOnPollTimeout) {
+            qDebug() << "** Force Sync, because it was requested";
+        }
+        if (syncAgainAfterFail) {
+            qDebug() << "** Force Sync, because the last"
+                     << _consecutiveFailingSyncs << "syncs failed, last status:"
+                     << _syncResult.statusString();
+        }
+        _forceSyncOnPollTimeout = false;
         emit scheduleToSync(alias());
+
     } else {
-        // do the ordinary etag check for the root folder.
+        // Do the ordinary etag check for the root folder and only schedule a real
+        // sync if it's different.
+
         RequestEtagJob* job = new RequestEtagJob(account, remotePath(), this);
         // check if the etag is different
         QObject::connect(job, SIGNAL(etagRetreived(QString)), this, SLOT(etagRetreived(QString)));
@@ -496,11 +526,88 @@ QString Folder::configFile()
     return _configFile;
 }
 
+static void addErroredSyncItemPathsToList(const SyncFileItemVector& items, QSet<QString>* set) {
+    Q_FOREACH(const SyncFileItem &item, items) {
+        if (item.hasErrorStatus()) {
+            set->insert(item._file);
+        }
+    }
+}
+
 void Folder::slotThreadTreeWalkResult(const SyncFileItemVector& items)
 {
+    addErroredSyncItemPathsToList(items, &this->_stateLastSyncItemsWithError);
     _syncResult.setSyncFileItemVector(items);
 }
 
+void Folder::slotAboutToPropagate(const SyncFileItemVector& items)
+{
+    // empty the tainted list since the status generation code will use the _syncedItems
+    // (which imply the folder) to generate the syncing state icon now.
+    _stateTaintedFolders.clear();
+
+    addErroredSyncItemPathsToList(items, &this->_stateLastSyncItemsWithError);
+}
+
+
+bool Folder::estimateState(QString fn, csync_ftw_type_e t, SyncFileStatus* s)
+{
+    if (t == CSYNC_FTW_TYPE_DIR) {
+        if (Utility::doesSetContainPrefix(_stateLastSyncItemsWithError, fn)) {
+            qDebug() << Q_FUNC_INFO << "Folder has error" << fn;
+            s->set(SyncFileStatus::STATUS_ERROR);
+            return true;
+        }
+        // If sync is running, check _syncedItems, possibly give it STATUS_EVAL (=syncing down)
+        if (!_engine.isNull()) {
+            if (_engine->estimateState(fn, t, s)) {
+                return true;
+            }
+        }
+        if (Utility::doesSetContainPrefix(_stateTaintedFolders, fn)) {
+            qDebug() << Q_FUNC_INFO << "Folder is tainted, EVAL!" << fn;
+            s->set(SyncFileStatus::STATUS_EVAL);
+            return true;
+        }
+        return false;
+    } else if ( t== CSYNC_FTW_TYPE_FILE) {
+        // check if errorList has the directory/file
+        if (Utility::doesSetContainPrefix(_stateLastSyncItemsWithError, fn)) {
+            s->set(SyncFileStatus::STATUS_ERROR);
+            return true;
+        }
+        // If sync running: _syncedItems -> SyncingState
+        if (!_engine.isNull()) {
+            if (_engine->estimateState(fn, t, s)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void Folder::watcherSlot(QString fn)
+{
+    // FIXME: On OS X we could not do this "if" since on OS X the file watcher ignores events for ourselves
+    // however to have the same behaviour atm on all platforms, we don't do it
+    if (!_engine.isNull()) {
+        qDebug() << Q_FUNC_INFO << "Sync running, IGNORE event for " << fn;
+        return;
+    }
+    QFileInfo fi(fn);
+    if (fi.isFile()) {
+        fn = fi.path(); // depending on OS, file watcher might be for dir or file
+    }
+    // Make it a relative path depending on the folder
+    QString relativePath = fn.remove(0, path().length());
+    qDebug() << Q_FUNC_INFO << fi.canonicalFilePath() << fn << relativePath;
+    _stateTaintedFolders.insert(relativePath);
+
+    // Notify the SocketAPI?
+}
+
+
+
 void Folder::slotTerminateSync()
 {
     qDebug() << "folder " << alias() << " Terminating!";
@@ -623,6 +730,8 @@ void Folder::startSync(const QStringList &pathList)
 
     connect( _engine.data(), SIGNAL(treeWalkResult(const SyncFileItemVector&)),
               this, SLOT(slotThreadTreeWalkResult(const SyncFileItemVector&)), Qt::QueuedConnection);
+    connect( _engine.data(), SIGNAL(aboutToPropagate(const SyncFileItemVector&)),
+              this, SLOT(slotAboutToPropagate(const SyncFileItemVector&)), Qt::QueuedConnection);
 
     connect(_engine.data(), SIGNAL(started()),  SLOT(slotSyncStarted()), Qt::QueuedConnection);
     connect(_engine.data(), SIGNAL(finished()), SLOT(slotSyncFinished()), Qt::QueuedConnection);
@@ -669,6 +778,17 @@ void Folder::setDirtyNetworkLimits()
     }
 }
 
+void Folder::setSelectiveSyncBlackList(const QStringList& blackList)
+{
+    _selectiveSyncBlackList = blackList;
+    for (int i = 0; i < _selectiveSyncBlackList.count(); ++i) {
+        if (!_selectiveSyncBlackList.at(i).endsWith(QLatin1Char('/'))) {
+            _selectiveSyncBlackList[i].append(QLatin1Char('/'));
+        }
+    }
+}
+
+
 void Folder::slotSyncError(const QString& err)
 {
     _errors.append( err );
@@ -689,8 +809,11 @@ void Folder::slotCsyncUnavailable()
 
 void Folder::slotSyncFinished()
 {
-    qDebug() << "-> CSync Finished slot with error " << _csyncError << "warn count" << _syncResult.warnCount();
+    if( _csyncError ) {
-
+        qDebug() << "-> SyncEngine finished with ERROR, warn count is" << _syncResult.warnCount();
+    } else {
+        qDebug() << "-> SyncEngine finished without problem.";
+    }
     bubbleUpSyncResult();
 
     bool anotherSyncNeeded = false;
@@ -701,6 +824,10 @@ void Folder::slotSyncFinished()
     // _watcher->setEventsEnabledDelayed(2000);
 
 
+    // This is for sync state calculation
+    _stateLastSyncItemsWithError = _stateLastSyncItemsWithErrorNew;
+    _stateLastSyncItemsWithErrorNew.clear();
+    _stateTaintedFolders.clear(); // heuristic: assume the sync had been done, new file watches needed to taint dirs
 
     if (_csyncError) {
         _syncResult.setStatus(SyncResult::Error);
@@ -717,6 +844,18 @@ void Folder::slotSyncFinished()
         _syncResult.setStatus(SyncResult::Success);
     }
 
+    // Count the number of syncs that have failed in a row.
+    if (_syncResult.status() == SyncResult::Success
+            || _syncResult.status() == SyncResult::Problem)
+    {
+        _consecutiveFailingSyncs = 0;
+    }
+    else
+    {
+        _consecutiveFailingSyncs++;
+        qDebug() << "the last" << _consecutiveFailingSyncs << "syncs failed";
+    }
+
     emit syncStateChange();
 
     // The syncFinished result that is to be triggered here makes the folderman
@@ -727,16 +866,28 @@ void Folder::slotSyncFinished()
     // all come in.
     QTimer::singleShot(200, this, SLOT(slotEmitFinishedDelayed() ));
 
-    if (!anotherSyncNeeded) {
-        _pollTimer.start();
     _timeSinceLastSync.restart();
+
+    // Increment the follow-up sync counter if necessary.
+    if (anotherSyncNeeded) {
+        _consecutiveFollowUpSyncs++;
+        qDebug() << "another sync was requested by the finished sync, this has"
+                 << "happened" << _consecutiveFollowUpSyncs << "times";
     } else {
-        // Another sync is required.  We will make sure that the poll timer occurs soon enough
+        _consecutiveFollowUpSyncs = 0;
-        // and we clear the etag to force a sync
-        _lastEtag.clear();
-        QTimer::singleShot(1000, this, SLOT(slotPollTimerTimeout() ));
     }
 
+    // Maybe force a follow-up sync to take place, but only a couple of times.
+    if (anotherSyncNeeded && _consecutiveFollowUpSyncs <= 3)
+    {
+        _forceSyncOnPollTimeout = true;
+        // We will make sure that the poll timer occurs soon enough.
+        // delay 1s, 4s, 9s
+        int c = _consecutiveFollowUpSyncs;
+        QTimer::singleShot(c*c * 1000, this, SLOT(slotPollTimerTimeout() ));
+    } else {
+        _pollTimer.start();
+    }
 }
 
 void Folder::slotEmitFinishedDelayed()
@@ -767,6 +918,10 @@ void Folder::slotTransmissionProgress(const Progress::Info &pi)
 // a job is completed: count the errors and forward to the ProgressDispatcher
 void Folder::slotJobCompleted(const SyncFileItem &item)
 {
+    if (item.hasErrorStatus()) {
+        _stateLastSyncItemsWithError.insert(item._file);
+    }
+
     if (Progress::isWarningKind(item._status)) {
         // Count all error conditions.
         _syncResult.setWarnCount(_syncResult.warnCount()+1);
@@ -799,7 +954,8 @@ void Folder::slotAboutToRemoveAllFiles(SyncFileItem::Direction, bool *cancel)
     if (*cancel) {
         wipe();
         // speed up next sync
-        _lastEtag = QString();
+        _lastEtag.clear();
+        _forceSyncOnPollTimeout = true;
         QTimer::singleShot(50, this, SLOT(slotPollTimerTimeout()));
     }
 }

src/mirall/folder.h

@@ -27,6 +27,7 @@
 
 #include <QDir>
 #include <QHash>
+#include <QSet>
 #include <QObject>
 #include <QStringList>
 
@@ -34,15 +35,12 @@
 #include <QTimer>
 #include <qelapsedtimer.h>
 
-class QFileSystemWatcher;
 class QThread;
 
 namespace Mirall {
 
 class SyncEngine;
 
-class FolderWatcher;
-
 class Folder : public QObject
 {
     Q_OBJECT
@@ -119,12 +117,11 @@ public:
 
      // Used by the Socket API
      SyncJournalDb *journalDb() { return &_journal; }
-     CSYNC *csyncContext() { return _csync_ctx; }
 
      QStringList selectiveSyncBlackList() { return _selectiveSyncBlackList; }
-     void setSelectiveSyncBlackList(const QStringList &blackList)
+     void setSelectiveSyncBlackList(const QStringList &blackList);
-     { _selectiveSyncBlackList = blackList; }
 
+     bool estimateState(QString fn, csync_ftw_type_e t, SyncFileStatus* s);
 
 signals:
     void syncStateChange();
@@ -170,10 +167,13 @@ private slots:
     void etagRetreived(const QString &);
     void slotNetworkUnavailable();
 
-    void slotThreadTreeWalkResult(const SyncFileItemVector& );
+    void slotAboutToPropagate(const SyncFileItemVector& );
+    void slotThreadTreeWalkResult(const SyncFileItemVector& ); // after sync is done
 
     void slotEmitFinishedDelayed();
 
+    void watcherSlot(QString);
+
 private:
     bool init();
 
@@ -202,6 +202,20 @@ private:
     QTimer        _pollTimer;
     QString       _lastEtag;
     QElapsedTimer _timeSinceLastSync;
+    bool          _forceSyncOnPollTimeout;
+
+    /// The number of syncs that failed in a row.
+    /// Reset when a sync is successful.
+    int           _consecutiveFailingSyncs;
+
+    /// The number of requested follow-up syncs.
+    /// Reset when no follow-up is requested.
+    int           _consecutiveFollowUpSyncs;
+
+    // For the SocketAPI folder states
+    QSet<QString>   _stateLastSyncItemsWithErrorNew; // gets moved to _stateLastSyncItemsWithError at end of sync
+    QSet<QString>   _stateLastSyncItemsWithError;
+    QSet<QString>   _stateTaintedFolders;
 
     SyncJournalDb _journal;
 

src/mirall/folderman.cpp

@@ -147,6 +147,9 @@ void FolderMan::registerFolderMonitor( Folder *folder )
         connect(fw, SIGNAL(folderChanged(QString)), _folderWatcherSignalMapper, SLOT(map()));
         _folderWatcherSignalMapper->setMapping(fw, folder->alias());
         _folderWatchers.insert(folder->alias(), fw);
+
+        // This is at the moment only for the behaviour of the SocketApi.
+        connect(fw, SIGNAL(folderChanged(QString)), folder, SLOT(watcherSlot(QString)));
     }
 
     // register the folder with the socket API
@@ -442,6 +445,24 @@ void FolderMan::slotScheduleSync( const QString& alias )
         return;
     }
 
+    // The folder watcher fires a lot of bogus notifications during
+    // a sync operation, both for actual user files and the database
+    // and log. Never enqueue a folder for sync while it is syncing.
+    // We lose some genuine sync requests that way, but that can't be
+    // helped.
+    // ^^ FIXME: Note that this is not the case on OS X
+    if( _currentSyncFolder == alias ) {
+        qDebug() << "folder " << alias << " is currently syncing. NOT scheduling.";
+        return;
+    }
+
+    if( _socketApi ) {
+        // We want the SocketAPI to already now update so that it can show the EVAL icon
+        // for files/folders. Only do this when not syncing, else we might get a lot
+        // of those notifications.
+        _socketApi->slotUpdateFolderView(alias);
+    }
+
     qDebug() << "Schedule folder " << alias << " to sync!";
 
     if( ! _scheduleQueue.contains(alias) ) {
@@ -532,6 +553,8 @@ void FolderMan::slotFolderSyncStarted( )
 /*
   * a folder indicates that its syncing is finished.
   * Start the next sync after the system had some milliseconds to breath.
+  * This delay is particularly useful to avoid late file change notifications
+  * (that we caused ourselves by syncing) from triggering another spurious sync.
   */
 void FolderMan::slotFolderSyncFinished( const SyncResult& )
 {
@@ -566,11 +589,11 @@ Folder *FolderMan::folderForPath(const QString &path)
         const QString folderPath = QDir::cleanPath(folder->path())+QLatin1Char('/');
 
         if(absolutePath.startsWith(folderPath)) {
-            qDebug() << "found folder: " << folder->path() << " for " << absolutePath;
+            //qDebug() << "found folder: " << folder->path() << " for " << absolutePath;
             return folder;
         }
     }
-
+    qDebug() << "ERROR: could not find folder for " << absolutePath;
     return 0;
 }
 
@@ -675,6 +698,17 @@ bool FolderMan::startFromScratch( const QString& localFolder )
             qDebug() << "startFromScratch: Directory is empty!";
             return true;
         }
+        // Disconnect the socket api from the database to avoid that locking of the
+        // db file does not allow to move this dir.
+        if( _socketApi ) {
+            Folder *f = folderForPath(localFolder);
+            if(f) {
+                if( localFolder.startsWith(f->path()) ) {
+                    _socketApi->slotUnregisterPath(f->alias());
+                }
+            }
+        }
+
         // Make a backup of the folder/file.
         QString newName = getBackupName( parentDir.absoluteFilePath( folderName ) );
         if( !parentDir.rename( fi.absoluteFilePath(), newName ) ) {

src/mirall/folderwatcher.cpp

@@ -81,7 +81,7 @@ bool FolderWatcher::pathIsIgnored( const QString& path )
 
         QFileInfo fInfo(path);
         if( fInfo.isHidden() ) {
-            qDebug() << "* Discarded as is hidden!";
+            qDebug() << "* Discarded as is hidden!" << fInfo.filePath();
             return true;
         }
 

src/mirall/folderwizard.cpp

@@ -232,6 +232,9 @@ FolderWizardRemotePath::FolderWizardRemotePath()
     _ui.setupUi(this);
     _ui.warnFrame->hide();
 
+    _ui.folderTreeWidget->setSortingEnabled(true);
+    _ui.folderTreeWidget->sortByColumn(0, Qt::AscendingOrder);
+
     connect(_ui.addFolderButton, SIGNAL(clicked()), SLOT(slotAddRemoteFolder()));
     connect(_ui.refreshButton, SIGNAL(clicked()), SLOT(slotRefreshFolders()));
     connect(_ui.folderTreeWidget, SIGNAL(itemClicked(QTreeWidgetItem*,int)), SIGNAL(completeChanged()));

src/mirall/logger.cpp

@@ -16,6 +16,7 @@
 
 #include <QDir>
 #include <QStringList>
+#include <QThread>
 
 namespace Mirall {
 
@@ -85,6 +86,7 @@ void Logger::log(Log log)
     } else {
         // msg += "ownCloud - ";
     }
+    msg += QString().sprintf("%p ", (void*)QThread::currentThread());
     msg += log.message;
     // _logs.append(log);
     // std::cout << qPrintable(log.message) << std::endl;

src/mirall/mirallconfigfile.cpp

@@ -206,15 +206,16 @@ QString MirallConfigFile::configPathWithAppName() const
     return QFileInfo( configFile() ).dir().absolutePath().append("/");
 }
 
+static const QLatin1String exclFile("sync-exclude.lst");
+
 QString MirallConfigFile::excludeFile(Scope scope) const
 {
     // prefer sync-exclude.lst, but if it does not exist, check for
     // exclude.lst for compatibility reasons in the user writeable
     // directories.
-    const QString exclFile("sync-exclude.lst");
-    QFileInfo fi;
 
     if (scope != SystemScope) {
+        QFileInfo fi;
         fi.setFile( configPath(), exclFile );
 
         if( ! fi.isReadable() ) {
@@ -223,11 +224,18 @@ QString MirallConfigFile::excludeFile(Scope scope) const
         if( ! fi.isReadable() ) {
             fi.setFile( configPath(), exclFile );
         }
+        return fi.absoluteFilePath();
+    } else if (scope != UserScope) {
+        return MirallConfigFile::excludeFileFromSystem();
+    } else {
+        Q_ASSERT(false);
+        return QString(); // unreachable
+    }
 }
 
-    if (scope != UserScope) {
+QString MirallConfigFile::excludeFileFromSystem()
-        // Check alternative places...
+{
-        if( ! fi.isReadable() ) {
+    QFileInfo fi;
 #ifdef Q_OS_WIN
     fi.setFile( QCoreApplication::applicationDirPath(), exclFile );
 #endif
@@ -247,8 +255,6 @@ QString MirallConfigFile::excludeFile(Scope scope) const
     fi.setFile( QCoreApplication::applicationDirPath(),
                 QLatin1String("../Resources/") + exclFile );
 #endif
-        }
-    }
     return fi.absoluteFilePath();
 }
 

src/mirall/mirallconfigfile.h

@@ -38,6 +38,7 @@ public:
     QString configPathWithAppName() const;
     QString configFile() const;
     QString excludeFile(Scope scope) const;
+    static QString excludeFileFromSystem(); // doesn't access config dir
 
     bool exists();
 

src/mirall/networkjobs.cpp

@@ -39,6 +39,8 @@ Q_DECLARE_METATYPE(QTimer*)
 
 namespace Mirall {
 
+bool AbstractNetworkJob::preOc7WasDetected = false;
+
 AbstractNetworkJob::AbstractNetworkJob(Account *account, const QString &path, QObject *parent)
     : QObject(parent)
     , _duration(0)
@@ -48,7 +50,12 @@ AbstractNetworkJob::AbstractNetworkJob(Account *account, const QString &path, QO
     , _path(path)
 {
     _timer.setSingleShot(true);
+    if (!AbstractNetworkJob::preOc7WasDetected) {
         _timer.setInterval(10*1000); // default to 10 seconds.
+    } else {
+        qDebug() << "Pre-oc7 server detected, adjusting timeout values";
+        _timer.setInterval(60*1000); // long PROPFINDs in oc6 might take too long
+    }
     connect(&_timer, SIGNAL(timeout()), this, SLOT(slotTimeout()));
 
     connect(this, SIGNAL(networkActivity()), SLOT(resetTimeout()));
@@ -430,7 +437,9 @@ bool CheckServerJob::finished()
 
     bool success = false;
     QByteArray body = reply()->readAll();
-    if( body.isEmpty() ) {
+    int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if( body.isEmpty() || httpStatus != 200) {
+        qDebug() << "error: status.php replied " << httpStatus << body;
         emit instanceNotFound(reply());
     } else {
         QVariantMap status = QtJson::parse(QString::fromUtf8(body), success).toMap();
@@ -443,6 +452,12 @@ bool CheckServerJob::finished()
         if( status.contains("installed")
                 && status.contains("version")
                 && status.contains("versionstring") ) {
+
+            QString versionString = status.value("version").toString();
+            if (versionString.contains('.') && versionString.split('.')[0].toInt() < 7) {
+                AbstractNetworkJob::preOc7WasDetected = true;
+            }
+
             emit instanceFound(reply()->url(), status);
         } else {
             qDebug() << "No proper answer on " << requestedUrl;

src/mirall/networkjobs.h

@@ -94,6 +94,9 @@ protected:
     QElapsedTimer _durationTimer;
     quint64       _duration;
 
+    // Timeout workarounds (Because of PHP session locking)
+    static bool preOc7WasDetected;
+
 private slots:
     void slotFinished();
     virtual void slotTimeout();

src/mirall/openfilemanager.cpp

@@ -90,18 +90,22 @@ void showInFileManager(const QString &localPath)
         }
 #endif
         QString explorer = "explorer.exe "; // FIXME: we trust it's in PATH
+        QFileInfo fi(localPath);
 
-        if (!QFileInfo(localPath).isDir()) {
+        // canonicalFilePath returns empty if the file does not exist
+        if( !fi.canonicalFilePath().isEmpty() ) {
+            if (!fi.isDir()) {
                 explorer += QLatin1String("/select,");
             }
             explorer += QLatin1Char('"');
-        explorer += QDir::toNativeSeparators(localPath);
+            explorer += QDir::toNativeSeparators(fi.canonicalFilePath());
             explorer += QLatin1Char('"');
 
             qDebug() << "OO Open explorer commandline:" << explorer;
             QProcess p;
             p.start(explorer);
             p.waitForFinished(5000);
+        }
     } else if (Utility::isMac()) {
         QStringList scriptArgs;
         scriptArgs << QLatin1String("-e")

src/mirall/owncloudgui.cpp

@@ -50,7 +50,6 @@ ownCloudGui::ownCloudGui(Application *parent) :
     _settingsDialog(new SettingsDialog(this)),
 #endif
     _logBrowser(0),
-    _contextMenu(0),
     _recentActionsMenu(0),
     _folderOpenActionMapper(new QSignalMapper(this)),
     _recentItemsMapper(new QSignalMapper(this)),
@@ -102,8 +101,9 @@ ownCloudGui::ownCloudGui(Application *parent) :
 
 void ownCloudGui::setupOverlayIcons()
 {
-
+#ifdef Q_OS_MAC
-    if( Utility::isMac() && QFile::exists("/Library/ScriptingAdditions/OwnCloudFinder.osax") ) {
+    const QLatin1String finderExtension("/Library/ScriptingAdditions/SyncStateFinder.osax");
+    if(QFile::exists(finderExtension) ) {
         QString aScript = QString::fromUtf8("tell application \"Finder\"\n"
                                             "  try\n"
                                             "    «event OWNCload»\n"
@@ -123,7 +123,10 @@ void ownCloudGui::setupOverlayIcons()
           QString resultAsString(result); // if appropriate
           qDebug() << "Laod Finder Overlay-Plugin: " << resultAsString << ": " << p.exitCode()
                    << (p.exitCode() != 0 ? p.errorString() : QString::null);
+    } else  {
+        qDebug() << finderExtension << "does not exist! Finder Overlay Plugin loading failed";
     }
+#endif
 }
 
 // This should rather be in application.... or rather in MirallConfigFile?
@@ -303,11 +306,11 @@ void ownCloudGui::setupContextMenu()
         _recentActionsMenu->addAction(tr("None."));
         _recentActionsMenu->addAction(_actionRecent);
     } else {
-        _contextMenu = new QMenu(_contextMenu);
+        _contextMenu.reset(new QMenu());
-        _recentActionsMenu = new QMenu(tr("Recent Changes"));
+        _recentActionsMenu = new QMenu(tr("Recent Changes"), _contextMenu.data());
         // this must be called only once after creating the context menu, or
         // it will trigger a bug in Ubuntu's SNI bridge patch (11.10, 12.04).
-        _tray->setContextMenu(_contextMenu);
+        _tray->setContextMenu(_contextMenu.data());
     }
     _contextMenu->setTitle(Theme::instance()->appNameGUI() );
     _contextMenu->addAction(_actionOpenoC);
@@ -464,7 +467,7 @@ void ownCloudGui::slotUpdateProgress(const QString &folder, const Progress::Info
     Q_UNUSED(folder);
 
      if (!progress._currentDiscoveredFolder.isEmpty()) {
-                 _actionStatus->setText( tr("Discovering %1")
+                 _actionStatus->setText( tr("Discovering '%1'")
                      .arg( progress._currentDiscoveredFolder ));
      } else if (progress._totalSize == 0 ) {
             quint64 currentFile =  progress._completedFileCount + progress._currentItems.count();           

src/mirall/owncloudgui.h

@@ -85,7 +85,7 @@ private:
 #endif
     QPointer<LogBrowser>_logBrowser;
        // tray's menu
-    QMenu *_contextMenu;
+    QScopedPointer<QMenu> _contextMenu;
     QMenu *_recentActionsMenu;
 
     QAction *_actionLogin;

src/mirall/owncloudpropagator.cpp

@@ -56,11 +56,10 @@ void PropagateItemJob::done(SyncFileItem::Status status, const QString &errorStr
         }
     }
 
-    if( _propagator->_abortRequested.fetchAndAddRelaxed(0) ) {
+    if( _propagator->_abortRequested.fetchAndAddRelaxed(0) &&
+            (status == SyncFileItem::NormalError || status == SyncFileItem::FatalError)) {
         // an abort request is ongoing. Change the status to Soft-Error
-
         status = SyncFileItem::SoftError;
-        _item._errorString = tr("Operation was canceled by user interaction.");
     }
 
     _item._status = status;
@@ -78,7 +77,7 @@ void PropagateItemJob::done(SyncFileItem::Status status, const QString &errorStr
         }
         retries = defaultRetriesCount.fetchAndAddAcquire(0);
     }
-    SyncJournalBlacklistRecord record(_item, retries);;
+    SyncJournalBlacklistRecord record(_item, retries);
 
     switch( status ) {
     case SyncFileItem::SoftError:
@@ -98,9 +97,13 @@ void PropagateItemJob::done(SyncFileItem::Status status, const QString &errorStr
         break;
     case SyncFileItem::Success:
     case SyncFileItem::Restoration:
-        if( _item._blacklistedInDb ) {
+        if( _item._hasBlacklistEntry ) {
             // wipe blacklist entry.
             _propagator->_journal->wipeBlacklistEntry(_item._file);
+            // remove a blacklist entry in case the file was moved.
+            if( _item._originalFile != _item._file ) {
+                _propagator->_journal->wipeBlacklistEntry(_item._originalFile);
+            }
         }
         break;
     case SyncFileItem::Conflict:
@@ -382,10 +385,10 @@ bool OwncloudPropagator::localFileNameClash( const QString& relFile )
             // returns false.
         } else {
             QString realFileName = QString::fromWCharArray( FindFileData.cFileName );
-            qDebug() << Q_FUNC_INFO << "Real file name is " << realFileName;
             FindClose(hFind);
 
             if( ! file.endsWith(realFileName, Qt::CaseSensitive) ) {
+                qDebug() << Q_FUNC_INFO << "Detected case clash between" << file << "and" << realFileName;
                 re = true;
             }
         }

src/mirall/owncloudsetupwizard.cpp

@@ -401,7 +401,6 @@ void OwncloudSetupWizard::slotAssistantFinished( int result )
         _ocWizard->account()->deleteLater();
         qDebug() << "Rejected the new config, use the old!";
     } else if( result == QDialog::Accepted ) {
-
         Account *newAccount = _ocWizard->account();
         Account *origAccount = AccountManager::instance()->account();
 
@@ -410,6 +409,13 @@ void OwncloudSetupWizard::slotAssistantFinished( int result )
             localFolder.append(QLatin1Char('/'));
         }
 
+        Folder *f = folderMan->folderForPath(localFolder);
+        if( f ) {
+            folderMan->setSyncEnabled(false);
+            folderMan->terminateSyncProcess(f->alias());
+            f->journalDb()->close();
+        }
+
         bool isInitialSetup = (origAccount == 0);
 
         // check if either the account or the local folder changed, than reinit

src/mirall/owncloudtheme.cpp

@@ -52,7 +52,7 @@ QString ownCloudTheme::about() const
                "<p>Copyright ownCloud, Inc.</p>"
                "<p>Licensed under the GNU General Public License (GPL) Version 2.0<br/>"
                "ownCloud and the ownCloud Logo are registered trademarks of ownCloud, "
-               "Inc. in the United States, other countries, or both</p>"
+               "Inc. in the United States, other countries, or both.</p>"
                )
             .arg(MIRALL_VERSION_STRING)
             .arg("http://" MIRALL_STRINGIFY(APPLICATION_DOMAIN))

src/mirall/ownsql.cpp

@@ -0,0 +1,292 @@
+/*
+ * Copyright (C) by Klaas Freitag <freitag@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 <QDateTime>
+#include <QString>
+#include <QDebug>
+
+#include "ownsql.h"
+#include "utility.h"
+
+#define SQLITE_SLEEP_TIME_USEC 100000
+#define SQLITE_REPEAT_COUNT 20
+
+#define SQLITE_DO(A) if(1) { \
+    _errId = (A); if(_errId != SQLITE_OK) { _error= QString::fromUtf8(sqlite3_errmsg(_db)); \
+     } }
+
+namespace Mirall {
+
+SqlDatabase::SqlDatabase()
+    :_db(0),
+      _errId(0)
+{
+
+}
+
+bool SqlDatabase::isOpen()
+{
+    return _db != 0;
+}
+
+bool SqlDatabase::open( const QString& filename )
+{
+    if(isOpen()) {
+        return true;
+    }
+
+    int flag = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_NOMUTEX;
+    SQLITE_DO( sqlite3_open_v2(filename.toUtf8().constData(), &_db, flag, 0) );
+
+    if( _errId != SQLITE_OK ) {
+        close(); // FIXME: Correct?
+        _db = 0;
+    }
+
+    sqlite3_busy_timeout(_db, 5000);
+
+    return isOpen();
+}
+
+QString SqlDatabase::error() const
+{
+    const QString err(_error);
+    // _error.clear();
+    return err;
+}
+
+void SqlDatabase::close()
+{
+    if( _db ) {
+        SQLITE_DO(sqlite3_close(_db) );
+        _db = 0;
+    }
+}
+
+bool SqlDatabase::transaction()
+{
+    if( ! _db ) {
+        return false;
+    }
+    SQLITE_DO(sqlite3_exec(_db, "BEGIN", 0, 0, 0));
+    return _errId == SQLITE_OK;
+}
+
+bool SqlDatabase::commit()
+{
+    if( ! _db ) {
+        return false;
+    }
+    SQLITE_DO(sqlite3_exec(_db, "COMMIT", 0, 0, 0));
+    return _errId == SQLITE_OK;
+}
+
+sqlite3* SqlDatabase::sqliteDb()
+{
+    return _db;
+}
+
+/* =========================================================================================== */
+
+SqlQuery::SqlQuery( SqlDatabase& db )
+    :_db(db.sqliteDb()),
+      _stmt(0)
+{
+
+}
+
+SqlQuery::~SqlQuery()
+{
+    if( _stmt ) {
+        finish();
+    }
+}
+
+SqlQuery::SqlQuery(const QString& sql, SqlDatabase& db)
+    :_db(db.sqliteDb()),
+      _stmt(0)
+{
+    prepare(sql);
+}
+
+int SqlQuery::prepare( const QString& sql)
+{
+    QString s(sql);
+    _sql = s.trimmed();
+    if(_stmt ) {
+        finish();
+    }
+    if(!_sql.isEmpty() ) {
+        int n = 0;
+        int rc;
+        do {
+            rc = sqlite3_prepare_v2(_db, _sql.toUtf8().constData(), -1, &_stmt, 0);
+            if( (rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED) ) {
+                n++;
+                Mirall::Utility::usleep(SQLITE_SLEEP_TIME_USEC);
+            }
+        } while( (n < SQLITE_REPEAT_COUNT) && ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED)));
+        _errId = rc;
+
+        if( _errId != SQLITE_OK ) {
+            qDebug() << "Sqlite prepare statement error:" << _error << "in"<<_sql;
+        }
+        // Q_ASSERT(_errId == SQLITE_OK);
+    }
+    return _errId;
+}
+
+bool SqlQuery::isSelect()
+{
+    return (!_sql.isEmpty() && _sql.startsWith("SELECT", Qt::CaseInsensitive));
+}
+
+bool SqlQuery::isPragma()
+{
+    return (!_sql.isEmpty() && _sql.startsWith("PRAGMA", Qt::CaseInsensitive));
+}
+
+bool SqlQuery::exec()
+{
+    // Don't do anything for selects, that is how we use the lib :-|
+    if(_stmt && !isSelect() && !isPragma() ) {
+        int rc, n = 0;
+        do {
+            rc = sqlite3_step(_stmt);
+            if( rc == SQLITE_LOCKED ) {
+                rc = sqlite3_reset(_stmt); /* This will also return SQLITE_LOCKED */
+                n++;
+                Mirall::Utility::usleep(SQLITE_SLEEP_TIME_USEC);
+            } else if( rc == SQLITE_BUSY ) {
+                Mirall::Utility::usleep(SQLITE_SLEEP_TIME_USEC);
+                n++;
+            }
+        } while( (n < SQLITE_REPEAT_COUNT) && ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED)));
+        _errId = rc;
+
+        return (_errId == SQLITE_DONE); // either SQLITE_ROW or SQLITE_DONE
+    }
+
+    return true;
+}
+
+bool SqlQuery::next()
+{
+    SQLITE_DO(sqlite3_step(_stmt));
+    return _errId == SQLITE_ROW;
+}
+
+void SqlQuery::bindValue(int pos, const QVariant& value)
+{
+    int res = -1;
+    if( _stmt ) {
+        switch (value.type()) {
+        case QVariant::Int:
+        case QVariant::Bool:
+            res = sqlite3_bind_int(_stmt, pos, value.toInt());
+            break;
+        case QVariant::Double:
+            res = sqlite3_bind_double(_stmt, pos, value.toDouble());
+            break;
+        case QVariant::UInt:
+        case QVariant::LongLong:
+            res = sqlite3_bind_int64(_stmt, pos, value.toLongLong());
+            break;
+        case QVariant::DateTime: {
+            const QDateTime dateTime = value.toDateTime();
+            const QString str = dateTime.toString(QLatin1String("yyyy-MM-ddThh:mm:ss.zzz"));
+            res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
+                                      str.size() * sizeof(ushort), SQLITE_TRANSIENT);
+            break;
+        }
+        case QVariant::Time: {
+            const QTime time = value.toTime();
+            const QString str = time.toString(QLatin1String("hh:mm:ss.zzz"));
+            res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
+                                      str.size() * sizeof(ushort), SQLITE_TRANSIENT);
+            break;
+        }
+        case QVariant::String: {
+            if( !value.toString().isNull() ) {
+                // lifetime of string == lifetime of its qvariant
+                const QString *str = static_cast<const QString*>(value.constData());
+                res = sqlite3_bind_text16(_stmt, pos, str->utf16(),
+                                          (str->size()) * sizeof(QChar), SQLITE_TRANSIENT);
+            } else {
+                // unbound value create a null entry.
+                res = SQLITE_OK;
+            }
+            break; }
+        default: {
+            QString str = value.toString();
+            // SQLITE_TRANSIENT makes sure that sqlite buffers the data
+            res = sqlite3_bind_text16(_stmt, pos, str.utf16(),
+                                      (str.size()) * sizeof(QChar), SQLITE_TRANSIENT);
+            break; }
+        }
+    }
+    if (res != SQLITE_OK) {
+        qDebug() << Q_FUNC_INFO << "ERROR" << value.toString() << res;
+    }
+    Q_ASSERT( res == SQLITE_OK );
+}
+
+QString SqlQuery::stringValue(int index)
+{
+    return QString::fromUtf16(static_cast<const ushort*>(sqlite3_column_text16(_stmt, index)));
+}
+
+int SqlQuery::intValue(int index)
+{
+    return sqlite3_column_int(_stmt, index);
+}
+
+quint64 SqlQuery::int64Value(int index)
+{
+    return sqlite3_column_int64(_stmt, index);
+}
+
+QByteArray SqlQuery::baValue(int index)
+{
+    return QByteArray( static_cast<const char*>(sqlite3_column_blob(_stmt, index)),
+                       sqlite3_column_bytes(_stmt, index));
+}
+
+QString SqlQuery::error() const
+{
+    return _error;
+}
+
+QString SqlQuery::lastQuery() const
+{
+    return _sql;
+}
+
+int SqlQuery::numRowsAffected()
+{
+    return 1;
+}
+
+void SqlQuery::finish()
+{
+    SQLITE_DO(sqlite3_finalize(_stmt));
+    _stmt = 0;
+}
+
+void SqlQuery::reset()
+{
+    SQLITE_DO(sqlite3_reset(_stmt));
+}
+
+} // namespace Mirall

src/mirall/ownsql.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) by Klaas Freitag <freitag@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 OWNSQL_H
+#define OWNSQL_H
+
+#include <sqlite3.h>
+
+#include <QObject>
+#include <QVariant>
+
+#include "owncloudlib.h"
+
+namespace Mirall {
+
+class OWNCLOUDSYNC_EXPORT SqlDatabase
+{
+    Q_DISABLE_COPY(SqlDatabase)
+public:
+    explicit SqlDatabase();
+
+    bool isOpen();
+    bool open( const QString& filename );
+    bool transaction();
+    bool commit();
+    void close();
+    QString error() const;
+    sqlite3* sqliteDb();
+
+private:
+    sqlite3 *_db;
+    QString _error; // last error string
+    int _errId;
+
+};
+
+class OWNCLOUDSYNC_EXPORT SqlQuery
+{
+    Q_DISABLE_COPY(SqlQuery)
+public:
+    explicit SqlQuery();
+    explicit SqlQuery(SqlDatabase& db);
+    explicit SqlQuery(const QString& sql, SqlDatabase& db);
+
+    ~SqlQuery();
+    QString error() const;
+
+    QString stringValue(int index);
+    int intValue(int index);
+    quint64 int64Value(int index);
+    QByteArray baValue(int index);
+
+    bool isSelect();
+    bool isPragma();
+    bool exec();
+    int  prepare( const QString& sql );
+    bool next();
+    void bindValue(int pos, const QVariant& value);
+    QString lastQuery() const;
+    int numRowsAffected();
+    void reset();
+    void finish();
+
+private:
+    sqlite3 *_db;
+    sqlite3_stmt *_stmt;
+    QString _error;
+    int _errId;
+    QString _sql;
+};
+
+} // namespace Mirall
+
+#endif // OWNSQL_H

src/mirall/propagator_qnam.cpp

@@ -310,6 +310,7 @@ void PropagateUploadFileQNAM::slotPutFinished()
             // Precondition Failed:   Maybe the bad etag is in the database, we need to clear the
             // parent folder etag so we won't read from DB next sync.
             _propagator->_journal->avoidReadFromDbOnNextSync(_item._file);
+            _propagator->_anotherSyncNeeded = true;
         }
 
         done(classifyError(err, _item._httpErrorCode), errorString);
@@ -448,6 +449,12 @@ GETFileJob::GETFileJob(Account* account, const QUrl& url, QFile *device,
 
 
 void GETFileJob::start() {
+    if (_resumeStart > 0) {
+        _headers["Range"] = "bytes=" + QByteArray::number(_resumeStart) +'-';
+        _headers["Accept-Ranges"] = "bytes";
+        qDebug() << "Retry with range " << _headers["Range"];
+    }
+
     QNetworkRequest req;
     for(QMap<QByteArray, QByteArray>::const_iterator it = _headers.begin(); it != _headers.end(); ++it) {
         req.setRawHeader(it.key(), it.value());
@@ -476,9 +483,15 @@ void GETFileJob::start() {
 
 void GETFileJob::slotMetaDataChanged()
 {
-    if (reply()->error() != QNetworkReply::NoError
+    int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-            || reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() / 100 != 2) {
+
-        // We will handle the error when the job is finished.
+    // If the status code isn't 2xx, don't write the reply body to the file.
+    // For any error: handle it when the job is finished, not here.
+    if (httpStatus / 100 != 2) {
+        _device->close();
+        return;
+    }
+    if (reply()->error() != QNetworkReply::NoError) {
         return;
     }
     _etag = get_etag_from_reply(reply());
@@ -548,6 +561,7 @@ void GETFileJob::slotReadyRead()
             return;
         }
 
+        if (_device->isOpen()) {
             qint64 w = _device->write(buffer.constData(), r);
             if (w != r) {
                 _errorString = _device->errorString();
@@ -558,6 +572,7 @@ void GETFileJob::slotReadyRead()
             }
         }
     }
+}
 
 void GETFileJob::slotTimeout()
 {
@@ -626,18 +641,13 @@ void PropagateDownloadFileQNAM::start()
 
     QMap<QByteArray, QByteArray> headers;
 
-    quint64 startSize = 0;
+    quint64 startSize = _tmpFile.size();
-    if (_tmpFile.size() > 0) {
+    if (startSize > 0) {
-        quint64 done = _tmpFile.size();
+        if (startSize == _item._size) {
-        if (done == _item._size) {
             qDebug() << "File is already complete, no need to download";
             downloadFinished();
             return;
         }
-        headers["Range"] = "bytes=" + QByteArray::number(done) +'-';
-        headers["Accept-Ranges"] = "bytes";
-        qDebug() << "Retry with range " << headers["Range"];
-        startSize = done;
     }
 
     if (_item._directDownloadUrl.isEmpty()) {
@@ -647,14 +657,27 @@ void PropagateDownloadFileQNAM::start()
                             &_tmpFile, headers, expectedEtagForResume, startSize);
     } else {
         // We were provided a direct URL, use that one
+        qDebug() << Q_FUNC_INFO << "directDownloadUrl given for " << _item._file << _item._directDownloadUrl;
+
+        // Direct URLs don't support resuming, so clear an existing tmp file
+        if (startSize > 0) {
+            qDebug() << Q_FUNC_INFO << "resuming not supported for directDownloadUrl, deleting temporary";
+            _tmpFile.close();
+            if (!_tmpFile.open(QIODevice::WriteOnly | QIODevice::Unbuffered)) {
+                done(SyncFileItem::NormalError, _tmpFile.errorString());
+                return;
+            }
+            startSize = 0;
+        }
+
         if (!_item._directDownloadCookies.isEmpty()) {
             headers["Cookie"] = _item._directDownloadCookies.toUtf8();
         }
+
         QUrl url = QUrl::fromUserInput(_item._directDownloadUrl);
         _job = new GETFileJob(AccountManager::instance()->account(),
                               url,
                               &_tmpFile, headers);
-        qDebug() << Q_FUNC_INFO << "directDownloadUrl given for " << _item._file << _item._directDownloadUrl;
     }
     _job->setTimeout(_propagator->httpTimeout() * 1000);
     connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotGetFinished()));
@@ -677,18 +700,34 @@ void PropagateDownloadFileQNAM::slotGetFinished()
 
     QNetworkReply::NetworkError err = job->reply()->error();
     if (err != QNetworkReply::NoError) {
-        if (_tmpFile.size() == 0) {
+        _item._httpErrorCode = job->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-            // don't keep the temporary file if it is empty.
+
+        // If we sent a 'Range' header and get 416 back, we want to retry
+        // without the header.
+        bool badRangeHeader = job->resumeStart() > 0 && _item._httpErrorCode == 416;
+        if (badRangeHeader) {
+            qDebug() << Q_FUNC_INFO << "server replied 416 to our range request, trying again without";
+            _propagator->_anotherSyncNeeded = true;
+        }
+
+        // Don't keep the temporary file if it is empty or we
+        // used a bad range header.
+        if (_tmpFile.size() == 0 || badRangeHeader) {
             _tmpFile.close();
             _tmpFile.remove();
             _propagator->_journal->setDownloadInfo(_item._file, SyncJournalDb::DownloadInfo());
         }
-        _item._httpErrorCode = job->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
         _propagator->_activeJobs--;
         SyncFileItem::Status status = job->errorStatus();
         if (status == SyncFileItem::NoStatus) {
             status = classifyError(err, _item._httpErrorCode);
         }
+        if (badRangeHeader) {
+            // Can't do this in classifyError() because 416 without a
+            // Range header should result in NormalError.
+            status = SyncFileItem::SoftError;
+        }
         done(status, job->errorString());
         return;
     }

src/mirall/propagatorjobs.cpp

@@ -247,6 +247,17 @@ void PropagateLocalRename::start()
         qDebug() << "MOVE " << _propagator->_localDir + _item._file << " => " << _propagator->_localDir + _item._renameTarget;
         QFile file(_propagator->_localDir + _item._file);
 
+        if (QString::compare(_item._file, _item._renameTarget, Qt::CaseInsensitive) != 0
+                && _propagator->localFileNameClash(_item._renameTarget)) {
+            // Only use localFileNameClash for the destination if we know that the source was not
+            // the one conflicting  (renaming  A.txt -> a.txt is OK)
+
+            // Fixme: the file that is the reason for the clash could be named here,
+            // it would have to come out the localFileNameClash function
+            done(SyncFileItem::NormalError, tr( "File %1 can not be renamed to %2 because of a local file name clash")
+                 .arg(QDir::toNativeSeparators(_item._file)).arg(QDir::toNativeSeparators(_item._renameTarget)) );
+            return;
+        }
         if (!file.rename(_propagator->_localDir + _item._file, _propagator->_localDir + _item._renameTarget)) {
             done(SyncFileItem::NormalError, file.errorString());
             return;

src/mirall/protocolwidget.cpp

@@ -29,6 +29,8 @@
 
 #include "ui_protocolwidget.h"
 
+#include <climits>
+
 namespace Mirall {
 
 ProtocolWidget::ProtocolWidget(QWidget *parent) :
@@ -252,7 +254,7 @@ void ProtocolWidget::computeResyncButtonEnabled()
 
     QString t = tr("Currently no files are ignored because of previous errors.");
     if(cnt > 0) {
-        t = tr("%1 files are ignored because of previous errors.\n Try to sync these again.").arg(cnt);
+        t = tr("%n files are ignored because of previous errors.\n Try to sync these again.", 0, cnt);
     }
 
     _clearBlacklistBtn->setEnabled(cnt > 0);
@@ -262,7 +264,7 @@ void ProtocolWidget::computeResyncButtonEnabled()
 
 void ProtocolWidget::slotProgressInfo( const QString& folder, const Progress::Info& progress )
 {
-    if( progress._completedFileCount == std::numeric_limits<quint64>::max() ) {
+    if( progress._completedFileCount == ULLONG_MAX ) {
         // The sync is restarting, clean the old items
         cleanIgnoreItems(folder);
         computeResyncButtonEnabled();

src/mirall/selectivesyncdialog.cpp

@@ -31,8 +31,9 @@
 namespace Mirall {
 
 SelectiveSyncTreeView::SelectiveSyncTreeView(Account *account, QWidget* parent)
-    : QTreeWidget(parent), _account(account)
+    : QTreeWidget(parent), _inserting(false), _account(account)
 {
+    _loading = new QLabel(tr("Loading ..."), this);
     connect(this, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(slotItemExpanded(QTreeWidgetItem*)));
     connect(this, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(slotItemChanged(QTreeWidgetItem*,int)));
     header()->hide();
@@ -47,6 +48,8 @@ void SelectiveSyncTreeView::refreshFolders()
             this, SLOT(slotUpdateDirectories(QStringList)));
     job->start();
     clear();
+    _loading->show();
+    _loading->move(10,10);
 }
 
 static QTreeWidgetItem* findFirstChild(QTreeWidgetItem *parent, const QString& text)
@@ -78,7 +81,7 @@ void SelectiveSyncTreeView::recursiveInsert(QTreeWidgetItem* parent, QStringList
                     || parent->checkState(0) == Qt::PartiallyChecked) {
                 item->setCheckState(0, Qt::Checked);
                 foreach(const QString &str , _oldBlackList) {
-                    if (str + "/" == path) {
+                    if (str == path) {
                         item->setCheckState(0, Qt::Unchecked);
                         break;
                     } else if (str.startsWith(path)) {
@@ -104,6 +107,8 @@ void SelectiveSyncTreeView::slotUpdateDirectories(const QStringList&list)
     QScopedValueRollback<bool> isInserting(_inserting);
     _inserting = true;
 
+    _loading->hide();
+
     QTreeWidgetItem *root = topLevelItem(0);
     if (!root) {
         root = new QTreeWidgetItem(this);
@@ -132,6 +137,9 @@ void SelectiveSyncTreeView::slotUpdateDirectories(const QStringList&list)
         if (paths.last().isEmpty()) paths.removeLast();
         if (paths.isEmpty())
             continue;
+        if (!path.endsWith('/')) {
+            path.append('/');
+        }
         recursiveInsert(root, paths, path);
     }
     root->setExpanded(true);
@@ -218,7 +226,7 @@ QStringList SelectiveSyncTreeView::createBlackList(QTreeWidgetItem* root) const
 
     switch(root->checkState(0)) {
     case Qt::Unchecked:
-        return QStringList(root->data(0, Qt::UserRole).toString());
+        return QStringList(root->data(0, Qt::UserRole).toString() + "/");
     case  Qt::Checked:
         return QStringList();
     case Qt::PartiallyChecked:
@@ -260,9 +268,10 @@ SelectiveSyncDialog::SelectiveSyncDialog(Account* account, const QStringList& bl
 
 void SelectiveSyncDialog::init(Account *account)
 {
+    setWindowTitle(tr("Choose What to Sync"));
     QVBoxLayout *layout = new QVBoxLayout(this);
     _treeView = new SelectiveSyncTreeView(account, this);
-    layout->addWidget(new QLabel(tr("Only checked folders will sync to this computer")));
+    layout->addWidget(new QLabel(tr("Unchecked folders will not be sync to this computer")));
     layout->addWidget(_treeView);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(Qt::Horizontal);
     QPushButton *button;
@@ -276,6 +285,7 @@ void SelectiveSyncDialog::init(Account *account)
 void SelectiveSyncDialog::accept()
 {
     if (_folder) {
+        auto oldBlackListSet = _folder->selectiveSyncBlackList().toSet();
         QStringList blackList = _treeView->createBlackList();
         _folder->setSelectiveSyncBlackList(blackList);
 
@@ -283,11 +293,19 @@ void SelectiveSyncDialog::accept()
         QSettings settings(_folder->configFile(), QSettings::IniFormat);
         settings.beginGroup(FolderMan::escapeAlias(_folder->alias()));
         settings.setValue("blackList", blackList);
-
         FolderMan *folderMan = FolderMan::instance();
         if (_folder->isBusy()) {
             _folder->slotTerminateSync();
         }
+
+        //The part that changed should not be read from the DB on next sync because there might be new folders
+        // (the ones that are no longer in the blacklist)
+        auto blackListSet = blackList.toSet();
+        auto changes = (oldBlackListSet - blackListSet) + (blackListSet - oldBlackListSet);
+        foreach(const auto &it, changes) {
+            _folder->journalDb()->avoidReadFromDbOnNextSync(it);
+        }
+
         folderMan->slotScheduleSync(_folder->alias());
     }
     QDialog::accept();

src/mirall/selectivesyncdialog.h

@@ -18,6 +18,7 @@
 
 class QTreeWidgetItem;
 class QTreeWidget;
+class QLabel;
 namespace Mirall {
 
 class Account;
@@ -28,8 +29,12 @@ class SelectiveSyncTreeView : public QTreeWidget {
     Q_OBJECT
 public:
     explicit SelectiveSyncTreeView(Account *account, QWidget* parent = 0);
+
+    /// Returns a list of blacklisted paths, each including the trailing /
     QStringList createBlackList(QTreeWidgetItem* root = 0) const;
     void refreshFolders();
+
+    // oldBlackList is a list of excluded paths, each including a trailing /
     void setFolderInfo(const QString &folderPath, const QString &rootName,
                        const QStringList &oldBlackList = QStringList()) {
         _folderPath = folderPath;
@@ -46,8 +51,9 @@ private:
     QString _folderPath;
     QString _rootName;
     QStringList _oldBlackList;
-    bool _inserting = false; // set to true when we are inserting new items on the list
+    bool _inserting; // set to true when we are inserting new items on the list
     Account *_account;
+    QLabel *_loading;
 };
 
 class SelectiveSyncDialog : public QDialog {

src/mirall/socketapi.cpp

@@ -35,6 +35,9 @@
 #include <QApplication>
 #include <QLocalSocket>
 
+#include <sqlite3.h>
+
+
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #include <QStandardPaths>
 #endif
@@ -60,184 +63,23 @@ CSYNC_EXCLUDE_TYPE csync_excluded_no_ctx(c_strlist_t *excludes, const char *path
 int csync_exclude_load(const char *fname, c_strlist_t **list);
 }
 
-namespace {
-    const int PORT = 34001;
-}
-
 namespace Mirall {
 
 #define DEBUG qDebug() << "SocketApi: "
 
-namespace SocketApiHelper {
-
-SyncFileStatus fileStatus(Folder *folder, const QString& systemFileName, c_strlist_t *excludes );
-
-/**
- * @brief recursiveFolderStatus
- * @param fileName - the relative file name to examine
- * @return the resulting status
- *
- * The resulting status can only be either SYNC which means all files
- * are in sync, ERROR if an error occured, or EVAL if something needs
- * to be synced underneath this dir.
- */
-// compute the file status of a directory recursively. It returns either
-// "all in sync" or "needs update" or "error", no more details.
-SyncFileStatus recursiveFolderStatus(Folder *folder, const QString& fileName, c_strlist_t *excludes  )
-{
-    QDir dir(folder->path() + fileName);
-
-    const QStringList dirEntries = dir.entryList( QDir::AllEntries | QDir::NoDotAndDotDot );
-
-    SyncFileStatus result(SyncFileStatus::STATUS_SYNC);
-
-    foreach( const QString entry, dirEntries ) {
-        QString normalizedFile = QString(fileName + QLatin1Char('/') + entry).normalized(QString::NormalizationForm_C);
-        QFileInfo fi(entry);
-        SyncFileStatus sfs;
-
-        if( fi.isDir() ) {
-            sfs = recursiveFolderStatus(folder, normalizedFile, excludes );
-        } else {
-            QString fs( normalizedFile );
-            if( fileName.isEmpty() ) {
-                // toplevel, no slash etc. needed.
-                fs = entry.normalized(QString::NormalizationForm_C);
-            }
-            sfs = fileStatus(folder, fs, excludes);
-        }
-
-        if( sfs.tag() == SyncFileStatus::STATUS_STAT_ERROR || sfs.tag() == SyncFileStatus::STATUS_ERROR ) {
-            return SyncFileStatus::STATUS_ERROR;
-        } else if( sfs.tag() == SyncFileStatus::STATUS_EVAL || sfs.tag() == SyncFileStatus::STATUS_NEW) {
-            result.set(SyncFileStatus::STATUS_EVAL);
-        }
-    }
-    return result;
-}
-
-SyncJournalFileRecord dbFileRecord( Folder *folder, QString fileName )
-{
-    QFileInfo fi(fileName);
-    if( !folder ) {
-        return SyncJournalFileRecord();
-    }
-    if( fi.isAbsolute() ) {
-        fileName.remove(0, folder->path().length());
-    }
-    return( folder->journalDb()->getFileRecord(fileName) );
-}
-
-/**
- * Get status about a single file.
- */
-SyncFileStatus fileStatus(Folder *folder, const QString& systemFileName, c_strlist_t *excludes )
-{
-    QString file = folder->path();
-    QString fileName = systemFileName.normalized(QString::NormalizationForm_C);
-
-    bool isSyncRootFolder = true;
-    if( fileName != QLatin1String("/") && !fileName.isEmpty() ) {
-        file = folder->path() + fileName;
-        isSyncRootFolder = false;
-    }
-
-    if( fileName.endsWith(QLatin1Char('/')) ) {
-        fileName.truncate(fileName.length()-1);
-        qDebug() << "Removed trailing slash: " << fileName;
-    }
-
-    QFileInfo fi(file);
-
-    if( !fi.exists() ) {
-        qDebug() << "OO File " << file << " is not existing";
-        return SyncFileStatus(SyncFileStatus::STATUS_STAT_ERROR);
-    }
-
-    // file is ignored?
-    if( fi.isSymLink() ) {
-        return SyncFileStatus(SyncFileStatus::STATUS_IGNORE);
-    }
-    int type = CSYNC_FTW_TYPE_FILE;
-    if( fi.isDir() ) {
-        type = CSYNC_FTW_TYPE_DIR;
-    }
-
-    // '\' is ignored, so convert to unix path before passing the path in.
-    QString unixFileName = QDir::fromNativeSeparators(fileName);
-
-    CSYNC_EXCLUDE_TYPE excl = csync_excluded_no_ctx(excludes, unixFileName.toUtf8(), type);
-    if( excl != CSYNC_NOT_EXCLUDED ) {
-        return SyncFileStatus(SyncFileStatus::STATUS_IGNORE);
-    }
-
-    // Problem: for the sync dir itself we do not have a record in the sync journal
-    // so the next check must not be used for the sync root folder.
-    SyncJournalFileRecord rec = dbFileRecord(folder, unixFileName );
-    if( !isSyncRootFolder && !rec.isValid() ) {
-        // check the parent folder if it is shared and if it is allowed to create a file/dir within
-        QDir d( fi.path() );
-        QString parentPath = d.path();
-        SyncJournalFileRecord dirRec = dbFileRecord(folder, parentPath);
-        while( !d.isRoot() && !(d.exists() && dirRec.isValid()) ) {
-            d.cdUp(); // returns true if the dir exists.
-
-            parentPath = d.path();
-            // cut the folder path
-            dirRec = dbFileRecord(folder, parentPath);
-        }
-        if( dirRec.isValid() ) {
-            if( dirRec._type == CSYNC_FTW_TYPE_DIR ) {
-                if( !dirRec._remotePerm.contains("K") ) {
-                    return SyncFileStatus::STATUS_ERROR;
-                }
-            } else {
-                if( !dirRec._remotePerm.contains("C") ) {
-                    return SyncFileStatus::STATUS_ERROR;
-                }
-            }
-        }
-        return SyncFileStatus(SyncFileStatus::STATUS_NEW);
-    }
-
-    SyncFileStatus status(SyncFileStatus::STATUS_NONE);
-    if( type == CSYNC_FTW_TYPE_DIR ) {
-        // compute recursive status of the directory
-        status = recursiveFolderStatus( folder, fileName, excludes );
-    } else if( FileSystem::getModTime(fi.absoluteFilePath()) != Utility::qDateTimeToTime_t(rec._modtime) ) {
-        // file was locally modified.
-        status.set(SyncFileStatus::STATUS_EVAL);
-    } else {
-        status.set(SyncFileStatus::STATUS_SYNC);
-    }
-
-    if (rec._remotePerm.contains("S")) {
-       status.setSharedWithMe(true);
-    }
-
-    return status;
-}
-
-
-}
-
 SocketApi::SocketApi(QObject* parent)
     : QObject(parent)
     , _excludes(0)
 {
-
-#ifdef SOCKETAPI_TCP
-    // setup socket
-    DEBUG << "Establishing SocketAPI server at" << PORT;
-    if (!_localServer.listen(QHostAddress::LocalHost, PORT)) {
-        DEBUG << "Failed to bind to port" << PORT;
-    }
-#else
     QString socketPath;
 
     if (Utility::isWindows()) {
         socketPath = QLatin1String("\\\\.\\pipe\\")
-                + Theme::instance()->appName();
+        + QLatin1String("ownCloud");
+        // TODO: once the windows extension supports multiple
+        // client connections, switch back to the theme name
+        // See issue #2388
+        // + Theme::instance()->appName();
     } else if (Utility::isMac()) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
         // Always using Qt5 on OS X
@@ -274,7 +116,6 @@ SocketApi::SocketApi(QObject* parent)
         DEBUG << "server started, listening at " << socketPath;
     }
 
-#endif
     connect(&_localServer, SIGNAL(newConnection()), this, SLOT(slotNewConnection()));
 
     // folder watcher
@@ -387,11 +228,30 @@ void SocketApi::slotUnregisterPath( const QString& alias )
     Folder *f = FolderMan::instance()->folder(alias);
     if (f) {
         broadcastMessage(QLatin1String("UNREGISTER_PATH"), f->path(), QString::null, true );
+
+        if( _dbQueries.contains(f)) {
+            SqlQuery *h = _dbQueries[f];
+            if( h ) {
+                h->finish();
+            }
+            _dbQueries.remove(f);
+        }
+        if( _openDbs.contains(f) ) {
+            SqlDatabase *db = _openDbs[f];
+            if( db ) {
+                db->close();
+            }
+            _openDbs.remove(f);
+        }
     }
 }
 
 void SocketApi::slotUpdateFolderView(const QString& alias)
 {
+    if (_listeners.isEmpty()) {
+        return;
+    }
+
     Folder *f = FolderMan::instance()->folder(alias);
     if (f) {
         // do only send UPDATE_VIEW for a couple of status
@@ -401,17 +261,23 @@ void SocketApi::slotUpdateFolderView(const QString& alias)
                 f->syncResult().status() == SyncResult::Problem ||
                 f->syncResult().status() == SyncResult::Error   ||
                 f->syncResult().status() == SyncResult::SetupError ) {
-            if( Utility::isWindows() ) {
+
-                Utility::winShellChangeNotify( f->path() );
+            broadcastMessage(QLatin1String("STATUS"), f->path() ,
-            } else {
+                             this->fileStatus(f, "", _excludes).toSocketAPIString());
+
             broadcastMessage(QLatin1String("UPDATE_VIEW"), f->path() );
-            }
+        } else {
+            qDebug() << "Not sending UPDATE_VIEW for" << alias << "because status() is" << f->syncResult().status();
         }
     }
 }
 
 void SocketApi::slotJobCompleted(const QString &folder, const SyncFileItem &item)
 {
+    if (_listeners.isEmpty()) {
+        return;
+    }
+
     Folder *f = FolderMan::instance()->folder(folder);
     if (!f) {
         return;
@@ -428,6 +294,10 @@ void SocketApi::slotJobCompleted(const QString &folder, const SyncFileItem &item
 
 void SocketApi::slotSyncItemDiscovered(const QString &folder, const SyncFileItem &item)
 {
+    if (_listeners.isEmpty()) {
+        return;
+    }
+
     if (item._instruction == CSYNC_INSTRUCTION_NONE) {
         return;
     }
@@ -452,11 +322,13 @@ void SocketApi::sendMessage(SocketType *socket, const QString& message, bool doW
     if( ! localMessage.endsWith(QLatin1Char('\n'))) {
         localMessage.append(QLatin1Char('\n'));
     }
-    qint64 sent = socket->write(localMessage.toUtf8());
+
+    QByteArray bytesToSend = localMessage.toUtf8();
+    qint64 sent = socket->write(bytesToSend);
     if( doWait ) {
         socket->waitForBytesWritten(1000);
     }
-    if( sent != localMessage.toUtf8().length() ) {
+    if( sent != bytesToSend.length() ) {
         qDebug() << "WARN: Could not send all data on socket for " << localMessage;
     }
 
@@ -475,7 +347,8 @@ void SocketApi::broadcastMessage( const QString& verb, const QString& path, cons
         msg.append(QDir::toNativeSeparators(path));
     }
 
-    DEBUG << "Broadcasting to" << _listeners.count() << "listeners: " << msg;
+    // sendMessage already has a debug output
+    //DEBUG << "Broadcasting to" << _listeners.count() << "listeners: " << msg;
     foreach(SocketType *socket, _listeners) {
         sendMessage(socket, msg, doWait);
     }
@@ -485,7 +358,7 @@ void SocketApi::command_RETRIEVE_FOLDER_STATUS(const QString& argument, SocketTy
 {
     // This command is the same as RETRIEVE_FILE_STATUS
 
-    qDebug() << Q_FUNC_INFO << argument;
+    //qDebug() << Q_FUNC_INFO << argument;
     command_RETRIEVE_FILE_STATUS(argument, socket);
 }
 
@@ -506,8 +379,10 @@ void SocketApi::command_RETRIEVE_FILE_STATUS(const QString& argument, SocketType
         DEBUG << "folder offline or not watched:" << argument;
         statusString = QLatin1String("NOP");
     } else {
-        const QString file = argument.mid(syncFolder->path().length());
+
-        SyncFileStatus fileStatus = SocketApiHelper::fileStatus(syncFolder, file, _excludes);
+
+        const QString file = QDir::cleanPath(argument).mid(QDir::cleanPath(syncFolder->path()).length()+1);
+        SyncFileStatus fileStatus = this->fileStatus(syncFolder, file, _excludes);
 
         statusString = fileStatus.toSocketAPIString();
     }
@@ -522,6 +397,219 @@ void SocketApi::command_VERSION(const QString&, SocketType* socket)
     sendMessage(socket, QLatin1String("VERSION:" MIRALL_VERSION_STRING ":" MIRALL_SOCKET_API_VERSION));
 }
 
+SqlQuery* SocketApi::getSqlQuery( Folder *folder )
+{
+    if( !folder ) {
+        return 0;
+    }
+
+    if( _dbQueries.contains(folder) ) {
+        return _dbQueries[folder];
+    }
+
+    /* No valid sql query object yet for this folder */
+    int rc;
+    const QString sql("SELECT inode, mode, modtime, type, md5, fileid, remotePerm FROM "
+                      "metadata WHERE phash=?1");
+    QString dbFileName = folder->journalDb()->databaseFilePath();
+
+    QFileInfo fi(dbFileName);
+    if( fi.exists() ) {
+        SqlDatabase *db = new SqlDatabase;
+
+        if( db && db->open(dbFileName) ) {
+            _openDbs.insert(folder, db);
+
+            SqlQuery *query = new SqlQuery(*db);
+            rc = query->prepare(sql);
+
+            if( rc != SQLITE_OK ) {
+                delete query;
+                qDebug() << "Unable to prepare the query statement:" << rc;
+                return 0; // do not insert into hash
+            }
+            _dbQueries.insert( folder, query);
+            return query;
+        }
+    } else {
+        qDebug() << Q_FUNC_INFO << "Journal to query does not yet exist.";
+    }
+    return 0;
+}
+
+SyncJournalFileRecord SocketApi::dbFileRecord_capi( Folder *folder, QString fileName )
+{
+    if( !(folder && folder->journalDb()) ) {
+        return SyncJournalFileRecord();
+    }
+
+    if( fileName.startsWith( folder->path() )) {
+        fileName.remove(0, folder->path().length());
+    }
+
+    SqlQuery *query = getSqlQuery(folder);
+    SyncJournalFileRecord rec;
+
+    if( query ) {
+        qlonglong phash = SyncJournalDb::getPHash( fileName );
+        query->bindValue(1, phash);
+        // int column_count = sqlite3_column_count(stmt);
+
+        if (query->next()) {
+            rec._path    = fileName;
+            rec._inode   = query->int64Value(0);
+            rec._mode    = query->intValue(1);
+            rec._modtime = Utility::qDateTimeFromTime_t( query->int64Value(2));
+            rec._type    = query->intValue(3);
+            rec._etag    = query->baValue(4);
+            rec._fileId  = query->baValue(5);
+            rec._remotePerm = query->baValue(6);
+        }
+        query->reset();
+    }
+    return rec;
+}
+
+/**
+ * Get status about a single file.
+ */
+SyncFileStatus SocketApi::fileStatus(Folder *folder, const QString& systemFileName, c_strlist_t *excludes )
+{
+    QString file = folder->path();
+    QString fileName = systemFileName.normalized(QString::NormalizationForm_C);
+    QString fileNameSlash = fileName;
+
+    if( fileName != QLatin1String("/") && !fileName.isEmpty() ) {
+        file = folder->path() + fileName;
+    }
+
+    if( fileName.endsWith(QLatin1Char('/')) ) {
+        fileName.truncate(fileName.length()-1);
+        qDebug() << "Removed trailing slash: " << fileName;
+    } else {
+        fileNameSlash += QLatin1Char('/');
+    }
+
+    QFileInfo fi(file);
+
+    if( !fi.exists() ) {
+        qDebug() << "OO File " << file << " is not existing";
+        return SyncFileStatus(SyncFileStatus::STATUS_STAT_ERROR);
+    }
+
+    // file is ignored?
+    if( fi.isSymLink() ) {
+        return SyncFileStatus(SyncFileStatus::STATUS_IGNORE);
+    }
+
+    csync_ftw_type_e type = CSYNC_FTW_TYPE_FILE;
+    if( fi.isDir() ) {
+        type = CSYNC_FTW_TYPE_DIR;
+    }
+
+    // Is it excluded?
+    CSYNC_EXCLUDE_TYPE excl = csync_excluded_no_ctx(excludes, fileName.toUtf8(), type);
+    if( excl != CSYNC_NOT_EXCLUDED ) {
+        return SyncFileStatus(SyncFileStatus::STATUS_IGNORE);
+    }
+
+    // Error if it is in the selective sync blacklistr
+    foreach(const auto &s, folder->selectiveSyncBlackList()) {
+        if (fileNameSlash.startsWith(s)) {
+            return SyncFileStatus(SyncFileStatus::STATUS_ERROR);
+        }
+    }
+
+    SyncFileStatus status(SyncFileStatus::STATUS_NONE);
+    SyncJournalFileRecord rec = dbFileRecord_capi(folder, fileName );
+
+    if (folder->estimateState(fileName, type, &status)) {
+        qDebug() << Q_FUNC_INFO << "Folder estimated status for" << fileName << "to" << status.toSocketAPIString();
+    } else if (fileName == "") {
+        // sync folder itself
+        switch (folder->syncResult().status()) {
+        case SyncResult::Undefined:
+        case SyncResult::NotYetStarted:
+        case SyncResult::SyncPrepare:
+        case SyncResult::SyncRunning:
+            status.set(SyncFileStatus::STATUS_EVAL);
+            return status;
+
+        case SyncResult::Success:
+        case SyncResult::Problem:
+            status.set(SyncFileStatus::STATUS_SYNC);
+            return status;
+
+        case SyncResult::Error:
+        case SyncResult::SetupError:
+        case SyncResult::SyncAbortRequested:
+            status.set(SyncFileStatus::STATUS_ERROR);
+            return status;
+
+        case SyncResult::Paused:
+            status.set(SyncFileStatus::STATUS_IGNORE);
+            return status;
+        }
+    } else if (type == CSYNC_FTW_TYPE_DIR) {
+        if (rec.isValid()) {
+            status.set(SyncFileStatus::STATUS_SYNC);
+        } else {
+            qDebug() << Q_FUNC_INFO << "Could not determine state for folder" << fileName << "will set STATUS_NEW";
+            status.set(SyncFileStatus::STATUS_NEW);
+        }
+    } else if (type == CSYNC_FTW_TYPE_FILE) {
+        if (rec.isValid()) {
+            if( FileSystem::getModTime(fi.absoluteFilePath()) == Utility::qDateTimeToTime_t(rec._modtime) ) {
+                status.set(SyncFileStatus::STATUS_SYNC);
+            } else {
+                if (rec._remotePerm.isNull() || rec._remotePerm.contains("W") ) {
+                    status.set(SyncFileStatus::STATUS_EVAL);
+                } else {
+                    status.set(SyncFileStatus::STATUS_ERROR);
+                }
+            }
+        } else {
+            qDebug() << Q_FUNC_INFO << "Could not determine state for file" << fileName << "will set STATUS_NEW";
+            status.set(SyncFileStatus::STATUS_NEW);
+        }
+    }
+
+    if (rec.isValid()) {
+        if (rec._remotePerm.isNull()) {
+            // probably owncloud 6, that does not have permissions flag yet.
+            QString url = folder->remoteUrl().toString() + fileName;
+            if (url.contains(QLatin1String("/remote.php/webdav/Shared/"))) {
+                status.setSharedWithMe(true);
+            }
+        } else if (rec._remotePerm.contains("S")) {
+            status.setSharedWithMe(true);
+        }
+    }
+    if (status.tag() == SyncFileStatus::STATUS_NEW) {
+        // check the parent folder if it is shared and if it is allowed to create a file/dir within
+        QDir d( fi.path() );
+        auto parentPath = d.path();
+        auto dirRec = dbFileRecord_capi(folder, parentPath);
+        bool isDir = type == CSYNC_FTW_TYPE_DIR;
+        while( !d.isRoot() && !(d.exists() && dirRec.isValid()) ) {
+            d.cdUp(); // returns true if the dir exists.
+
+            parentPath = d.path();
+            // cut the folder path
+            dirRec = dbFileRecord_capi(folder, parentPath);
+
+            isDir = true;
+        }
+        if( dirRec.isValid() && !dirRec._remotePerm.isNull()) {
+            if( (isDir && !dirRec._remotePerm.contains("K"))
+                    || (!isDir && !dirRec._remotePerm.contains("C")) ) {
+                status.set(SyncFileStatus::STATUS_ERROR);
+            }
+        }
+    }
+    return status;
+}
+
 
 } // namespace Mirall
 

src/mirall/socketapi.h

@@ -20,12 +20,16 @@ extern "C" {
 #include <std/c_string.h>
 }
 
+#include <sqlite3.h>
+
 #include <QWeakPointer>
 #include <QTcpSocket>
 #include <QTcpServer>
 #include <QLocalServer>
 
 #include "mirall/syncfileitem.h"
+#include "mirall/syncjournalfilerecord.h"
+#include "mirall/ownsql.h"
 
 class QUrl;
 class QLocalSocket;
@@ -33,19 +37,10 @@ class QStringList;
 
 namespace Mirall {
 
-//Define this to use the old school TCP API. Maybe we should offer both APIs
-// and have the old TCP one be enableable via command line switch?
-//#define SOCKETAPI_TCP
-#if defined(Q_OS_WIN)
-// Windows plugin has not been ported
-#define SOCKETAPI_TCP
-#endif
-
-#ifdef SOCKETAPI_TCP
-typedef QTcpSocket SocketType;
-#else
 typedef QLocalSocket SocketType;
-#endif
+
+class SyncFileStatus;
+class Folder;
 
 class SocketApi : public QObject
 {
@@ -69,6 +64,11 @@ private slots:
     void slotSyncItemDiscovered(const QString &, const SyncFileItem &);
 
 private:
+    SyncFileStatus fileStatus(Folder *folder, const QString& systemFileName, c_strlist_t *excludes );
+    SyncJournalFileRecord dbFileRecord_capi( Folder *folder, QString fileName );
+    SyncFileStatus recursiveFolderStatus(Folder *folder, const QString& fileName, c_strlist_t *excludes  );
+    SqlQuery *getSqlQuery( Folder *folder );
+
     void sendMessage(SocketType* socket, const QString& message, bool doWait = false);
     void broadcastMessage(const QString& verb, const QString &path, const QString &status = QString::null, bool doWait = false);
 
@@ -77,7 +77,6 @@ private:
 
     Q_INVOKABLE void command_VERSION(const QString& argument, SocketType* socket);
 
-private:
 #ifdef SOCKETAPI_TCP
     QTcpServer _localServer;
 #else
@@ -85,6 +84,8 @@ private:
 #endif
     QList<SocketType*> _listeners;
     c_strlist_t *_excludes;
+    QHash<Folder*, SqlQuery*> _dbQueries;
+    QHash<Folder*, SqlDatabase*> _openDbs;
 };
 
 }

src/mirall/sslerrordialog.cpp

@@ -149,11 +149,10 @@ bool SslErrorDialog::checkFailingCertsKnown( const QList<QSslError> &errors )
     }
     msg += QL("</div></body></html>");
 
-    qDebug() << "#  # # # # # ";
+    //qDebug() << "#  # # # # # ";
-    qDebug() << msg;
+    //qDebug() << msg;
     QTextDocument *doc = new QTextDocument(0);
     QString style = styleSheet();
-    qDebug() << "Style: " << style;
     doc->addResource( QTextDocument::StyleSheetResource, QUrl( QL("format.css") ), style);
     doc->setHtml( msg );
 

src/mirall/syncengine.cpp

@@ -22,6 +22,7 @@
 #include "discoveryphase.h"
 #include "creds/abstractcredentials.h"
 #include "csync_util.h"
+#include "mirall/syncfilestatus.h"
 
 #ifdef Q_OS_WIN
 #include <windows.h>
@@ -29,6 +30,7 @@
 #include <unistd.h>
 #endif
 
+#include <climits>
 #include <assert.h>
 
 #include <QDebug>
@@ -196,12 +198,12 @@ bool SyncEngine::checkBlacklisting( SyncFileItem *item )
     }
 
     SyncJournalBlacklistRecord entry = _journal->blacklistEntry(item->_file);
-    item->_blacklistedInDb = false;
+    item->_hasBlacklistEntry = false;
 
     // if there is a valid entry in the blacklist table and the retry count is
     // already null or smaller than 0, the file is blacklisted.
     if( entry.isValid() ) {
-        item->_blacklistedInDb = true;
+        item->_hasBlacklistEntry = true;
 
         if( entry._retryCount <= 0 ) {
             re = true;
@@ -288,7 +290,7 @@ void SyncEngine::deleteStaleBlacklistEntries()
     // Find all blacklisted paths that we want to preserve.
     QSet<QString> blacklist_file_paths;
     foreach(const SyncFileItem& it, _syncedItems) {
-        if (it._status == SyncFileItem::FileIgnored)
+        if (it._hasBlacklistEntry)
             blacklist_file_paths.insert(it._file);
     }
 
@@ -401,7 +403,7 @@ int SyncEngine::treewalkFile( TREE_WALK_FILE *file, bool remote )
     int re = 0;
     switch(file->instruction) {
     case CSYNC_INSTRUCTION_NONE:
-        if (file->should_update_etag && !item._isDirectory) {
+        if (remote && item._should_update_etag && !item._isDirectory && item._instruction == CSYNC_INSTRUCTION_NONE) {
             // Update the database now already  (new fileid or etag or remotePerm)
             // Those are files that were detected as "resolved conflict".
             // They should have been a conflict because they both were new, or both
@@ -523,17 +525,15 @@ void SyncEngine::startSync()
 
     csync_resume(_csync_ctx);
 
+    int fileRecordCount = -1;
     if (!_journal->exists()) {
-        qDebug() << "=====sync looks new (no DB exists), activating recursive PROPFIND if csync supports it";
+        qDebug() << "=====sync looks new (no DB exists)";
-        bool no_recursive_propfind = false;
-        csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
     } else {
-        // retrieve the file count from the db and close it afterwards because
+        qDebug() << "=====sync with existing DB";
-        // csync_update also opens the database.
+    }
-        int fileRecordCount = 0;
+
-        fileRecordCount = _journal->getFileRecordCount();
+    fileRecordCount = _journal->getFileRecordCount(); // this creates the DB if it does not exist yet
     bool isUpdateFrom_1_5 = _journal->isUpdateFrom_1_5();
-        _journal->close();
 
     if( fileRecordCount == -1 ) {
         qDebug() << "No way to create a sync journal!";
@@ -541,19 +541,25 @@ void SyncEngine::startSync()
         finalize();
         return;
         // database creation error!
-        } else if ( fileRecordCount < 50 ) {
+    }
-            qDebug() << "=====sync DB has only" << fileRecordCount << "items, enable recursive PROPFIND if csync supports it";
+
+    if (fileRecordCount >= 1 && isUpdateFrom_1_5) {
+        qDebug() << "detected update from 1.5" << fileRecordCount << isUpdateFrom_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);
+    } else {
+        csync_set_read_from_db(_csync_ctx, true);
+    }
+
+    bool usingSelectiveSync = (!_selectiveSyncBlackList.isEmpty());
+    qDebug() << (usingSelectiveSync ? "====Using Selective Sync" : "====NOT Using Selective Sync");
+    if (fileRecordCount >= 0 && fileRecordCount < 50 && !usingSelectiveSync) {
+        qDebug() << "===== Activating recursive PROPFIND (currently" << fileRecordCount << "file records)";
         bool no_recursive_propfind = false;
         csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
     } else {
-            qDebug() << "=====sync with existing DB";
+        bool no_recursive_propfind = true;
-        }
+        csync_set_module_property(_csync_ctx, "no_recursive_propfind", &no_recursive_propfind);
-
-        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_userdata(_csync_ctx, this);
@@ -609,6 +615,17 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
     }
     qDebug() << "<<#### Discovery end #################################################### " << _stopWatch.addLapTime(QLatin1String("Discovery Finished"));
 
+    // Sanity check
+    if (!_journal->isConnected()) {
+        qDebug() << "Bailing out, DB failure";
+        emit csyncError(tr("Cannot open the sync journal"));
+        finalize();
+        return;
+    } else {
+        // Commits a possibly existing (should not though) transaction and starts a new one for the propagate phase
+        _journal->commitIfNeededAndStartNewTransaction("Post discovery");
+    }
+
     if( csync_reconcile(_csync_ctx) < 0 ) {
         handleSyncError(_csync_ctx, "csync_reconcile");
         return;
@@ -646,17 +663,9 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
     // make sure everything is allowed
     checkForPermission();
 
-    // Sanity check
-    if (!_journal->isConnected()) {
-        qDebug() << "Bailing out, DB failure";
-        emit csyncError(tr("Cannot open the sync journal"));
-        finalize();
-        return;
-    }
-
     // To announce the beginning of the sync
     emit aboutToPropagate(_syncedItems);
-    _progressInfo._completedFileCount = std::numeric_limits<quint64>::max(); // indicate the start with max
+    _progressInfo._completedFileCount = ULLONG_MAX; // indicate the start with max
     emit transmissionProgress(_progressInfo);
     _progressInfo._completedFileCount = 0;
 
@@ -680,14 +689,16 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
     Q_ASSERT(session);
 
     // post update phase script: allow to tweak stuff by a custom script in debug mode.
-#ifndef NDEBUG
     if( !qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT").isEmpty() ) {
+#ifndef NDEBUG
         QString script = qgetenv("OWNCLOUD_POST_UPDATE_SCRIPT");
 
         qDebug() << "OOO => Post Update Script: " << script;
         QProcess::execute(script.toUtf8());
-    }
+#else
+    qDebug() << "**** Attention: POST_UPDATE_SCRIPT installed, but not executed because compiled with NDEBUG";
 #endif
+    }
 
     // do a database commit
     _journal->commit("post treewalk");
@@ -819,6 +830,11 @@ QString SyncEngine::adjustRenamedPath(const QString& original)
     return original;
 }
 
+/**
+ *
+ * Make sure that we are allowed to do what we do by checking the permissions and the selective sync list
+ *
+ */
 void SyncEngine::checkForPermission()
 {
     for (SyncFileItemVector::iterator it = _syncedItems.begin(); it != _syncedItems.end(); ++it) {
@@ -828,6 +844,25 @@ void SyncEngine::checkForPermission()
             continue;
         }
 
+        // Do not propagate anything in the server if it is in the selective sync blacklist
+        const QString path = it->destination() + QLatin1Char('/');
+        if (std::binary_search(_selectiveSyncBlackList.constBegin(), _selectiveSyncBlackList.constEnd(),
+                                path)) {
+            it->_instruction = CSYNC_INSTRUCTION_IGNORE;
+            it->_status = SyncFileItem::FileIgnored;
+            it->_errorString = tr("Ignored because of the \"choose what to sync\" blacklist");
+
+            if (it->_isDirectory) {
+                for (SyncFileItemVector::iterator it_next = it + 1; it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
+                    it = it_next;
+                    it->_instruction = CSYNC_INSTRUCTION_IGNORE;
+                    it->_status = SyncFileItem::FileIgnored;
+                    it->_errorString = tr("Ignored because of the \"choose what to sync\" blacklist");
+                }
+            }
+            continue;
+        }
+
         switch(it->_instruction) {
             case CSYNC_INSTRUCTION_NEW: {
                 int slashPos = it->_file.lastIndexOf('/');
@@ -842,7 +877,6 @@ void SyncEngine::checkForPermission()
                     it->_status = SyncFileItem::NormalError;
                     it->_errorString = tr("Not allowed because you don't have permission to add sub-directories in that directory");
 
-                    const QString path = it->_file + QLatin1Char('/');
                     for (SyncFileItemVector::iterator it_next = it + 1; it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
                         it = it_next;
                         it->_instruction = CSYNC_INSTRUCTION_ERROR;
@@ -895,7 +929,6 @@ void SyncEngine::checkForPermission()
 
                     if (it->_isDirectory) {
                         // restore all sub items
-                        const QString path = it->_file + QLatin1Char('/');
                         for (SyncFileItemVector::iterator it_next = it + 1;
                              it_next != _syncedItems.end() && it_next->_file.startsWith(path); ++it_next) {
                             it = it_next;
@@ -915,8 +948,7 @@ void SyncEngine::checkForPermission()
                             it->_errorString = tr("Not allowed to remove, restoring");
                         }
                     }
-                }
+                } else if(perms.contains("S") && perms.contains("D")) {
-                if(perms.contains("S") && perms.contains("D")) {
                     // this is a top level shared dir which can be removed to unshare it,
                     // regardless if it is a read only share or not.
                     // To avoid that we try to restore files underneath this dir which have
@@ -925,8 +957,6 @@ void SyncEngine::checkForPermission()
                     // underneath, propagator sees that.
                     if( it->_isDirectory ) {
                         SyncFileItemVector::iterator it_prev = it - 1;
-                        const QString path = it->_file + QLatin1Char('/');
-
 
                         // put a more descriptive message if really a top level share dir is removed.
                         if( it_prev != _syncedItems.begin() && !(path.startsWith(it_prev->_file)) ) {
@@ -1009,7 +1039,6 @@ void SyncEngine::checkForPermission()
 
 
                     if (it->_isDirectory) {
-                        const QString path = it->_renameTarget + QLatin1Char('/');
                         for (SyncFileItemVector::iterator it_next = it + 1;
                              it_next != _syncedItems.end() && it_next->destination().startsWith(path); ++it_next) {
                             it = it_next;
@@ -1040,6 +1069,24 @@ QByteArray SyncEngine::getPermissions(const QString& file) const
     return _remotePerms.value(file);
 }
 
+void SyncEngine::setSelectiveSyncBlackList(const QStringList& list)
+{
+    _selectiveSyncBlackList = list;
+}
+
+bool SyncEngine::estimateState(QString fn, csync_ftw_type_e t, SyncFileStatus* s)
+{
+    Q_UNUSED(t);
+    Q_FOREACH(const SyncFileItem &item, _syncedItems) {
+        //qDebug() << Q_FUNC_INFO << fn << item._file << fn.startsWith(item._file) << item._file.startsWith(fn);
+        if (item._file.startsWith(fn)) {
+            qDebug() << Q_FUNC_INFO << "Setting" << fn << " to STATUS_EVAL";
+            s->set(SyncFileStatus::STATUS_EVAL);
+            return true;
+        }
+    }
+    return false;
+}
 
 void SyncEngine::abort()
 {

src/mirall/syncengine.h

@@ -33,6 +33,7 @@
 #include "mirall/syncfileitem.h"
 #include "mirall/progressdispatcher.h"
 #include "mirall/utility.h"
+#include "mirall/syncfilestatus.h"
 
 class QProcess;
 
@@ -61,12 +62,13 @@ public:
 
     Utility::StopWatch &stopWatch() { return _stopWatch; }
 
-    void setSelectiveSyncBlackList(const QStringList &list)
+    void setSelectiveSyncBlackList(const QStringList &list);
-    { _selectiveSyncBlackList = list; }
 
     /* Return true if we detected that another sync is needed to complete the sync */
     bool isAnotherSyncNeeded() { return _anotherSyncNeeded; }
 
+    bool estimateState(QString fn, csync_ftw_type_e t, SyncFileStatus* s);
+
 signals:
     void csyncError( const QString& );
     void csyncUnavailable();
@@ -124,7 +126,11 @@ private:
     void finalize();
 
     static bool _syncRunning; //true when one sync is running somewhere (for debugging)
+
     QMap<QString, SyncFileItem> _syncItemMap;
+
+    // should be called _syncItems (present tense). It's the items from the _syncItemMap but
+    // sorted and re-adjusted based on permissions.
     SyncFileItemVector _syncedItems;
 
     CSYNC *_csync_ctx;

src/mirall/syncfileitem.h

@@ -46,13 +46,13 @@ public:
 
         Success, ///< The file was properly synced
         Conflict, ///< The file was properly synced, but a conflict was created
-        FileIgnored, ///< The file is in the ignored list
+        FileIgnored, ///< The file is in the ignored list (or blacklisted with no retries left)
         Restoration ///< The file was restored because what should have been done was not allowed
     };
 
     SyncFileItem() : _type(UnknownType),  _direction(None), _isDirectory(false),
         _instruction(CSYNC_INSTRUCTION_NONE), _modtime(0),
-        _size(0), _inode(0), _should_update_etag(false), _blacklistedInDb(false),
+        _size(0), _inode(0), _should_update_etag(false), _hasBlacklistEntry(false),
         _status(NoStatus), _httpErrorCode(0), _requestDuration(0), _isRestoration(false) {}
 
     friend bool operator==(const SyncFileItem& item1, const SyncFileItem& item2) {
@@ -72,6 +72,13 @@ public:
         return _file.isEmpty();
     }
 
+    bool hasErrorStatus() const {
+        return _status == SyncFileItem::SoftError
+                || _status == SyncFileItem::NormalError
+                || _status == SyncFileItem::FatalError
+                || !_errorString.isEmpty();
+    }
+
     // Variables usefull for everybody
     QString _file;
     QString _renameTarget;
@@ -91,7 +98,11 @@ public:
     QByteArray           _remotePerm;
     QString              _directDownloadUrl;
     QString              _directDownloadCookies;
-    bool                 _blacklistedInDb;
+
+    /// Whether there's an entry in the blacklist table.
+    /// Note: that entry may have retries left, so this can be true
+    /// without the status being FileIgnored.
+    bool                 _hasBlacklistEntry;
 
     // Variables usefull to report to the user
     Status               _status;

src/mirall/syncjournaldb.h

@@ -17,11 +17,10 @@
 #include <QObject>
 #include <qmutex.h>
 #include <QDateTime>
-#include <QSqlDatabase>
 #include <QHash>
-#include <QSqlQuery>
 
 #include "utility.h"
+#include "ownsql.h"
 
 namespace Mirall {
 class SyncJournalFileRecord;
@@ -43,6 +42,10 @@ public:
     bool deleteFileRecord( const QString& filename, bool recursively = false );
     int getFileRecordCount();
     bool exists();
+    void walCheckpoint();
+
+    QString databaseFilePath();
+    static qint64 getPHash(const QString& );
 
     void updateBlacklistEntry( const SyncJournalBlacklistRecord& item );
     void wipeBlacklistEntry(const QString& file);
@@ -91,6 +94,7 @@ public:
      * Commit will actually commit the transaction and create a new one.
      */
     void commit(const QString &context, bool startTrans = true);
+    void commitIfNeededAndStartNewTransaction(const QString &context);
 
     void close();
 
@@ -106,31 +110,30 @@ public:
     bool isUpdateFrom_1_5();
 
 private:
-    qint64 getPHash(const QString& ) const;
     bool updateDatabaseStructure();
-    bool sqlFail(const QString& log, const QSqlQuery &query );
+    bool sqlFail(const QString& log, const SqlQuery &query );
     void commitInternal(const QString &context, bool startTrans = true);
     void startTransaction();
     void commitTransaction();
     QStringList tableColumns( const QString& table );
     bool checkConnect();
 
-    QSqlDatabase _db;
+    SqlDatabase _db;
     QString _dbFile;
     QMutex _mutex; // Public functions are protected with the mutex.
     int _transaction;
     bool _possibleUpgradeFromMirall_1_5;
-    QScopedPointer<QSqlQuery> _getFileRecordQuery;
+    QScopedPointer<SqlQuery> _getFileRecordQuery;
-    QScopedPointer<QSqlQuery> _setFileRecordQuery;
+    QScopedPointer<SqlQuery> _setFileRecordQuery;
-    QScopedPointer<QSqlQuery> _getDownloadInfoQuery;
+    QScopedPointer<SqlQuery> _getDownloadInfoQuery;
-    QScopedPointer<QSqlQuery> _setDownloadInfoQuery;
+    QScopedPointer<SqlQuery> _setDownloadInfoQuery;
-    QScopedPointer<QSqlQuery> _deleteDownloadInfoQuery;
+    QScopedPointer<SqlQuery> _deleteDownloadInfoQuery;
-    QScopedPointer<QSqlQuery> _getUploadInfoQuery;
+    QScopedPointer<SqlQuery> _getUploadInfoQuery;
-    QScopedPointer<QSqlQuery> _setUploadInfoQuery;
+    QScopedPointer<SqlQuery> _setUploadInfoQuery;
-    QScopedPointer<QSqlQuery> _deleteUploadInfoQuery;
+    QScopedPointer<SqlQuery> _deleteUploadInfoQuery;
-    QScopedPointer<QSqlQuery> _deleteFileRecordPhash;
+    QScopedPointer<SqlQuery> _deleteFileRecordPhash;
-    QScopedPointer<QSqlQuery> _deleteFileRecordRecursively;
+    QScopedPointer<SqlQuery> _deleteFileRecordRecursively;
-    QScopedPointer<QSqlQuery> _blacklistQuery;
+    QScopedPointer<SqlQuery> _blacklistQuery;
 
     /* This is the list of paths we called avoidReadFromDbOnNextSync on.
      * It means that they should not be written to the DB in any case since doing
@@ -139,5 +142,10 @@ private:
     QList<QString> _avoidReadFromDbOnNextSyncFilter;
 };
 
+bool operator==(const SyncJournalDb::DownloadInfo & lhs,
+                const SyncJournalDb::DownloadInfo & rhs);
+bool operator==(const SyncJournalDb::UploadInfo & lhs,
+                const SyncJournalDb::UploadInfo & rhs);
+
 }  // namespace Mirall
 #endif // SYNCJOURNALDB_H