Use OWNCLOUD_BIN_DIR directly in C++ code.

No need to do a STR replacement. It actually broke test execution for
Debian.

See https://bugs.debian.org/844937

csync/src/csync.c

@@ -89,7 +89,7 @@ static int _data_cmp(const void *key, const void *data) {
   return 0;
 }
 
-void csync_create(CSYNC **csync, const char *local) {
+void csync_create(CSYNC **csync, const char *local, const char *remote) {
   CSYNC *ctx;
   size_t len = 0;
 
@@ -103,6 +103,12 @@ void csync_create(CSYNC **csync, const char *local) {
 
   ctx->local.uri = c_strndup(local, len);
 
+  /* remove trailing slashes */
+  len = strlen(remote);
+  while(len > 0 && remote[len - 1] == '/') --len;
+
+  ctx->remote.uri = c_strndup(remote, len);
+
   ctx->status_code = CSYNC_STATUS_OK;
 
   ctx->current_fs = NULL;
@@ -193,7 +199,7 @@ int csync_update(CSYNC *ctx) {
   ctx->current = REMOTE_REPLICA;
   ctx->replica = ctx->remote.type;
 
-  rc = csync_ftw(ctx, "", csync_walker, MAX_DEPTH);
+  rc = csync_ftw(ctx, ctx->remote.uri, csync_walker, MAX_DEPTH);
   if (rc < 0) {
       if(ctx->status_code == CSYNC_STATUS_OK) {
           ctx->status_code = csync_errno_to_status(errno, CSYNC_STATUS_UPDATE_ERROR);
@@ -573,6 +579,7 @@ int csync_destroy(CSYNC *ctx) {
   _csync_clean_ctx(ctx);
 
   SAFE_FREE(ctx->local.uri);
+  SAFE_FREE(ctx->remote.uri);
   SAFE_FREE(ctx->error_string);
 
 #ifdef WITH_ICONV

csync/src/csync.h

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

csync/src/csync_private.h

@@ -126,6 +126,7 @@ struct csync_s {
   } local;
 
   struct {
+    char *uri;
     c_rbtree_t *tree;
     enum csync_replica_e type;
     int  read_from_db;

csync/src/csync_update.c

@@ -56,13 +56,26 @@ static uint64_t _hash_of_file(CSYNC *ctx, const char *file) {
 
   if( ctx && file ) {
     path = file;
-    if (ctx->current == LOCAL_REPLICA) {
+    switch (ctx->current) {
+    case LOCAL_REPLICA:
       if (strlen(path) <= strlen(ctx->local.uri)) {
         return 0;
       }
       path += strlen(ctx->local.uri) + 1;
+      break;
+    case REMOTE_REPLICA:
+      if (strlen(path) <= strlen(ctx->remote.uri)) {
+        return 0;
+      }
+      path += strlen(ctx->remote.uri) + 1;
+      break;
+    default:
+      path = NULL;
+      return 0;
+      break;
     }
     len = strlen(path);
+
     h = c_jhash64((uint8_t *) path, len, 0);
   }
   return h;
@@ -175,12 +188,25 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
   }
 
   path = file;
-  if (ctx->current == LOCAL_REPLICA) {
+  switch (ctx->current) {
+    case LOCAL_REPLICA:
       if (strlen(path) <= strlen(ctx->local.uri)) {
         ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
         return -1;
       }
       path += strlen(ctx->local.uri) + 1;
+      break;
+    case REMOTE_REPLICA:
+      if (strlen(path) <= strlen(ctx->remote.uri)) {
+        ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+        return -1;
+      }
+      path += strlen(ctx->remote.uri) + 1;
+      break;
+    default:
+      path = NULL;
+      ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+      return -1;
   }
 
   len = strlen(path);
@@ -603,7 +629,16 @@ int csync_walker(CSYNC *ctx, const char *file, const csync_vio_file_stat_t *fs,
 
 static bool fill_tree_from_db(CSYNC *ctx, const char *uri)
 {
-    if( csync_statedb_get_below_path(ctx, uri) < 0 ) {
+    const char *path = NULL;
+
+    if( strlen(uri) < strlen(ctx->remote.uri)+1) {
+        CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "name does not contain remote uri!");
+        return false;
+    }
+
+    path = uri + strlen(ctx->remote.uri)+1;
+
+    if( csync_statedb_get_below_path(ctx, path) < 0 ) {
         CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "StateDB could not be read!");
         return false;
     }
@@ -645,6 +680,12 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
 
   bool do_read_from_db = (ctx->current == REMOTE_REPLICA && ctx->remote.read_from_db);
 
+  if (uri[0] == '\0') {
+    errno = ENOENT;
+    ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
+    goto error;
+  }
+
   read_from_db = ctx->remote.read_from_db;
 
   // if the etag of this dir is still the same, its content is restored from the
@@ -658,7 +699,16 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
       goto done;
   }
 
-  if ((dh = csync_vio_opendir(ctx, uri)) == NULL) {
+  const char *uri_for_vio = uri;
+  if (ctx->current == REMOTE_REPLICA) {
+      uri_for_vio += strlen(ctx->remote.uri);
+      if (strlen(uri_for_vio) > 0 && uri_for_vio[0] == '/') {
+          uri_for_vio++; // cut leading slash
+      }
+      CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "URI without fuzz for %s is \"%s\"", uri, uri_for_vio);
+  }
+
+  if ((dh = csync_vio_opendir(ctx, uri_for_vio)) == NULL) {
       if (ctx->abort) {
           CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Aborted!");
           ctx->status_code = CSYNC_STATUS_ABORTED;
@@ -731,32 +781,34 @@ int csync_ftw(CSYNC *ctx, const char *uri, csync_walker_fn fn,
       continue;
     }
 
-    if (uri[0] == '\0') {
-      filename = c_strdup(d_name);
-      flen = strlen(d_name);
-    } else {
-      flen = asprintf(&filename, "%s/%s", uri, d_name);
-    }
-    if (flen < 0 || !filename) {
+    flen = asprintf(&filename, "%s/%s", uri, d_name);
+    if (flen < 0) {
       csync_vio_file_stat_destroy(dirent);
       dirent = NULL;
       ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
       goto error;
     }
 
-    /* Create relative path: For local replica, we need to remove the base path.  */
-    path = filename;
-    if (ctx->current == LOCAL_REPLICA) {
+    /* Create relative path */
+    switch (ctx->current) {
+      case LOCAL_REPLICA:
         ulen = strlen(ctx->local.uri) + 1;
-        if (((size_t)flen) < ulen) {
-            csync_vio_file_stat_destroy(dirent);
-            dirent = NULL;
-            ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
-            goto error;
-        }
-        path += ulen;
+        break;
+      case REMOTE_REPLICA:
+        ulen = strlen(ctx->remote.uri) + 1;
+        break;
+      default:
+        break;
     }
 
+    if (((size_t)flen) < ulen) {
+      csync_vio_file_stat_destroy(dirent);
+      dirent = NULL;
+      ctx->status_code = CSYNC_STATUS_UNSUCCESSFUL;
+      goto error;
+    }
+
+    path = filename + ulen;
 
     /* skip ".csync_journal.db" and ".csync_journal.db.ctmp" */
     /* Isn't this done via csync_exclude already? */

csync/tests/csync_tests/check_csync_commit.c

@@ -30,7 +30,10 @@ static void setup(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     *state = csync;
 }
@@ -42,7 +45,10 @@ static void setup_module(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "dummy://foo/bar");
 
     csync_init(csync);
     *state = csync;
@@ -60,6 +66,9 @@ static void teardown(void **state) {
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
     *state = NULL;
 }
 

csync/tests/csync_tests/check_csync_create.c

@@ -42,7 +42,7 @@ static void check_csync_create(void **state)
 
     (void) state; /* unused */
 
-    csync_create(&csync, "/tmp/csync1");
+    csync_create(&csync, "/tmp/csync1", "/tmp/csync2");
 
     rc = csync_destroy(csync);
     assert_int_equal(rc, 0);

csync/tests/csync_tests/check_csync_exclude.c

@@ -32,7 +32,7 @@
 static void setup(void **state) {
     CSYNC *csync;
 
-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     *state = csync;
 }
@@ -41,7 +41,7 @@ static void setup_init(void **state) {
     CSYNC *csync;
     int rc;
 
-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     rc = csync_exclude_load(EXCLUDE_LIST_FILE, &(csync->excludes));
     assert_int_equal(rc, 0);

csync/tests/csync_tests/check_csync_init.c

@@ -30,7 +30,10 @@ static void setup(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     *state = csync;
 }
@@ -42,7 +45,10 @@ static void setup_module(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "dummy://foo/bar");
 
     *state = csync;
 }
@@ -59,6 +65,9 @@ static void teardown(void **state) {
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
     *state = NULL;
 }
 

csync/tests/csync_tests/check_csync_log.c

@@ -33,7 +33,10 @@ static void setup(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     *state = csync;
 }
@@ -50,6 +53,9 @@ static void teardown(void **state) {
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+
     *state = NULL;
 }
 

csync/tests/csync_tests/check_csync_statedb_load.c

@@ -36,7 +36,7 @@ static void setup(void **state) {
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
 
     csync->statedb.file = c_strdup( TESTDB );
     *state = csync;

csync/tests/csync_tests/check_csync_statedb_query.c

@@ -34,11 +34,15 @@ static void setup(void **state)
 
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
     rc = system("mkdir -p /tmp/check_csync");
     assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp/check_csync1");
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
     csync_init(csync);
 
     sqlite3 *db = NULL;
@@ -102,6 +106,8 @@ static void teardown(void **state) {
     assert_int_equal(rc, 0);
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
 
     *state = NULL;
 }

csync/tests/csync_tests/check_csync_update.c

@@ -91,7 +91,9 @@ static void setup(void **state)
     assert_int_equal(rc, 0);
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp/check_csync1");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+    csync_create(&csync, "/tmp/check_csync1", "/tmp/check_csync2");
     csync_init(csync);
 
     /* Create a new db with metadata */
@@ -120,7 +122,9 @@ static void setup_ftw(void **state)
     assert_int_equal(rc, 0);
     rc = system("mkdir -p /tmp/check_csync1");
     assert_int_equal(rc, 0);
-    csync_create(&csync, "/tmp");
+    rc = system("mkdir -p /tmp/check_csync2");
+    assert_int_equal(rc, 0);
+    csync_create(&csync, "/tmp", "/tmp");
     csync_init(csync);
 
     sqlite3 *db = NULL;
@@ -158,6 +162,8 @@ static void teardown_rm(void **state) {
     assert_int_equal(rc, 0);
     rc = system("rm -rf /tmp/check_csync1");
     assert_int_equal(rc, 0);
+    rc = system("rm -rf /tmp/check_csync2");
+    assert_int_equal(rc, 0);
 }
 
 /* create a file stat, caller must free memory */

csync/tests/vio_tests/check_vio.c

@@ -48,7 +48,7 @@ static void setup(void **state)
     rc = system("rm -rf /tmp/csync_test");
     assert_int_equal(rc, 0);
 
-    csync_create(&csync, "/tmp/csync1");
+    csync_create(&csync, "/tmp/csync1", "/tmp/csync2");
 
     csync->replica = LOCAL_REPLICA;
 

csync/tests/vio_tests/check_vio_ext.c

@@ -96,7 +96,7 @@ static void setup_testenv(void **state) {
     statevar *mystate = malloc( sizeof(statevar) );
     mystate->result = NULL;
 
-    csync_create(&(mystate->csync), "/tmp/csync1");
+    csync_create(&(mystate->csync), "/tmp/csync1", "/tmp/csync2");
 
     mystate->csync->replica = LOCAL_REPLICA;
 

doc/building.rst

@@ -68,17 +68,9 @@ To set up your build environment for development using HomeBrew_:
 
 1. Install Xcode
 2. Install Xcode command line tools::
-<<<<<<< HEAD
     xcode-select --install
 
 3. Install homebrew::
-=======
-
-    xcode-select --install
-
-3. Install homebrew::
-
->>>>>>> ca9ec4625391ae23940b3a62aaa0afe89f3d98e8
     /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
 
 4. Add the ownCloud repository using the following command::
@@ -108,7 +100,7 @@ To set up your build environment for development using HomeBrew_:
    its Common Name as a third parameter (use quotes) to have the package
    signed automatically.
 
-  .. note::  Contrary to earlier versions, ownCloud 1.7 and later are packaged
+   .. note:: Contrary to earlier versions, ownCloud 1.7 and later are packaged
              as a ``pkg`` installer. Do not call "make package" at any time when
              compiling for OS X, as this will build a disk image, and will not
              work correctly.
@@ -257,10 +249,6 @@ To build the most up-to-date version of the client:
 
    .. note:: Example:: cmake -DCMAKE_PREFIX_PATH=/usr/local/opt/qt5 -DCMAKE_INSTALL_PREFIX=/Users/path/to/client/install/  -D_OPENSSL_LIBDIR=/usr/local/opt/openssl/lib/ -D_OPENSSL_INCLUDEDIR=/usr/local/opt/openssl/include/   -DOPENSSL_INCLUDE_DIR=/usr/local/opt/openssl/include/ -DNO_SHIBBOLETH=1
 
-   .. note:: Example:: cmake -DCMAKE_PREFIX_PATH=/usr/local/opt/qt5 -DCMAKE_INSTALL_PREFIX=/Users/path/to/client/install/  -D_OPENSSL_LIBDIR=/usr/local/opt/openssl/lib/ -D_OPENSSL_INCLUDEDIR=/usr/local/opt/openssl/include/  -D_OPENSSL_VERSION=1.0.2a -DOPENSSL_INCLUDE_DIR=/usr/local/opt/openssl/include/ -DNO_SHIBBOLETH=1
-
-   qtkeychain must be compiled with the same prefix e.g CMAKE_INSTALL_PREFIX=/Users/path/to/client/install/ .
-
 4. Call ``make``.
 
    The owncloud binary will appear in the ``bin`` directory.

doc/introduction.rst

@@ -12,7 +12,7 @@ Desktop Sync client enables you to:
 Your files are always automatically synchronized between your ownCloud server 
 and local PC.
 
-Because of various technical issues, desktop sync clients older than 2.2.1 will 
+Because of various technical issues, desktop sync clients older than 1.7 will 
 not allowed to connect and sync with the ownCloud 8.1+ server. It is highly 
 recommended to keep your client updated.
 

mirall.desktop.in

@@ -502,51 +502,6 @@ X-GNOME-Autostart-Delay=3
 # Translations
 
 
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
-# Translations
-
-
 # Translations
 Comment[oc]=@APPLICATION_NAME@ sincronizacion del client
 GenericName[oc]=Dorsièr de Sincronizacion

shell_integration/dolphin/CMakeLists.txt

@@ -49,6 +49,5 @@ target_link_libraries(${OWNCLOUDDOLPHINOVERLAYPLUGIN} KF5::CoreAddons KF5::KIOCo
 set(OWNCLOUDDOLPHINACTIONPLUGIN ${APPLICATION_EXECUTABLE}dolphinactionplugin)
 add_library(${OWNCLOUDDOLPHINACTIONPLUGIN} MODULE ownclouddolphinactionplugin.cpp)
 target_link_libraries(${OWNCLOUDDOLPHINACTIONPLUGIN} KF5::CoreAddons KF5::KIOCore KF5::KIOWidgets ${OWNCLOUDDOLPHINHELPER})
-configure_file(ownclouddolphinactionplugin.desktop.in ${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop ESCAPE_QUOTES @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR})
+install(FILES ownclouddolphinactionplugin.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR} RENAME ${OWNCLOUDDOLPHINACTIONPLUGIN}.desktop)
 install(TARGETS ${OWNCLOUDDOLPHINACTIONPLUGIN} DESTINATION ${KDE_INSTALL_PLUGINDIR})

shell_integration/dolphin/ownclouddolphinactionplugin.desktop

@@ -1,6 +1,6 @@
 [Desktop Entry]
 Type=Service
-Name=@APPLICATION_NAME@Action
+Name=OwncloudAction
 ServiceTypes=KFileItemAction/Plugin
 MimeType=application/octet-stream;inode/directory;
-X-KDE-Library=@APPLICATION_EXECUTABLE@dolphinactionplugin
+X-KDE-Library=ownclouddolphinactionplugin

src/cmd/cmd.cpp

@@ -329,7 +329,8 @@ int main(int argc, char **argv) {
     if( !options.target_url.contains( account->davPath() )) {
         options.target_url.append(account->davPath());
     }
-
+    if (options.target_url.startsWith("http"))
+        options.target_url.replace(0, 4, "owncloud");
     QUrl url = QUrl::fromUserInput(options.target_url);
 
     // Order of retrieval attempt (later attempts override earlier ones):
@@ -370,6 +371,14 @@ int main(int argc, char **argv) {
          }
      }
 
+    // ### ensure URL is free of credentials
+    if (url.userName().isEmpty()) {
+        url.setUserName(user);
+    }
+    if (url.password().isEmpty()) {
+        url.setPassword(password);
+    }
+
     // take the unmodified url to pass to csync_create()
     QByteArray remUrl = options.target_url.toUtf8();
 
@@ -466,7 +475,7 @@ restart_sync:
         selectiveSyncFixup(&db, selectiveSyncList);
     }
 
-    SyncEngine engine(account, options.source_dir, folder, &db);
+    SyncEngine engine(account, options.source_dir, QUrl(options.target_url), folder, &db);
     engine.setIgnoreHiddenFiles(options.ignoreHiddenFiles);
     QObject::connect(&engine, SIGNAL(finished(bool)), &app, SLOT(quit()));
     QObject::connect(&engine, SIGNAL(transmissionProgress(ProgressInfo)), &cmd, SLOT(transmissionProgressSlot()));

src/gui/accountsettings.cpp

@@ -31,7 +31,6 @@
 #include "owncloudsetupwizard.h"
 #include "creds/abstractcredentials.h"
 #include "tooltipupdater.h"
-#include "filesystem.h"
 
 #include <math.h>
 
@@ -111,7 +110,7 @@ AccountSettings::AccountSettings(AccountState *accountState, QWidget *parent) :
 
     QAction *syncNowAction = new QAction(this);
     syncNowAction->setShortcut(QKeySequence(Qt::Key_F6));
-    connect(syncNowAction, SIGNAL(triggered()), SLOT(slotScheduleCurrentFolder()));
+    connect(syncNowAction, SIGNAL(triggered()), SLOT(slotSyncCurrentFolderNow()));
     addAction(syncNowAction);
 
     connect(ui->_folderList, SIGNAL(clicked(const QModelIndex &)),
@@ -229,11 +228,6 @@ void AccountSettings::slotCustomContextMenuRequested(const QPoint &pos)
         connect(ac, SIGNAL(triggered(bool)), this, SLOT(doExpand()));
     }
 
-    if (!folderPaused) {
-        ac = menu->addAction(tr("Force sync now"));
-        connect(ac, SIGNAL(triggered(bool)), this, SLOT(slotForceSyncCurrentFolder()));
-    }
-
     ac = menu->addAction(folderPaused ? tr("Resume sync") : tr("Pause sync"));
     connect(ac, SIGNAL(triggered(bool)), this, SLOT(slotEnableCurrentFolder()));
 
@@ -306,9 +300,8 @@ void AccountSettings::slotFolderWizardAccepted()
                                      tr("<p>Could not create local folder <i>%1</i>.")
                                         .arg(QDir::toNativeSeparators(definition.localPath)));
                 return;
-            } else {
-                FileSystem::setFolderMinimumPermissions(definition.localPath);
             }
+
         }
     }
 
@@ -468,7 +461,7 @@ void AccountSettings::slotEnableCurrentFolder()
     }
 }
 
-void AccountSettings::slotScheduleCurrentFolder()
+void AccountSettings::slotSyncCurrentFolderNow()
 {
     QModelIndex selected = ui->_folderList->selectionModel()->currentIndex();
     if( !selected.isValid() )
@@ -479,24 +472,6 @@ void AccountSettings::slotScheduleCurrentFolder()
     folderMan->scheduleFolder(folderMan->folder(alias));
 }
 
-void AccountSettings::slotForceSyncCurrentFolder()
-{
-    QModelIndex selected = ui->_folderList->selectionModel()->currentIndex();
-    if( !selected.isValid() )
-        return;
-    QString alias = _model->data( selected, FolderStatusDelegate::FolderAliasRole ).toString();
-    FolderMan *folderMan = FolderMan::instance();
-
-    // Terminate and reschedule any running sync
-    if (Folder* current = folderMan->currentSyncFolder()) {
-        folderMan->terminateSyncProcess();
-        folderMan->scheduleFolder(current);
-    }
-
-    // Insert the selected folder at the front of the queue
-    folderMan->scheduleFolderNext(folderMan->folder(alias));
-}
-
 void AccountSettings::slotOpenOC()
 {
   if( _OCUrl.isValid() )

src/gui/accountsettings.h

@@ -71,8 +71,7 @@ public slots:
 protected slots:
     void slotAddFolder();
     void slotEnableCurrentFolder();
-    void slotScheduleCurrentFolder();
-    void slotForceSyncCurrentFolder();
+    void slotSyncCurrentFolderNow();
     void slotRemoveCurrentFolder();
     void slotOpenCurrentFolder();
     void slotFolderWizardAccepted();

src/gui/activitywidget.cpp

@@ -617,7 +617,7 @@ void ActivitySettings::slotCopyToClipboard()
         message = tr("The sync activity list has been copied to the clipboard.");
     } else if(idx == 2 ) {
         // issues Widget
-        message = tr("The list of unsynced items has been copied to the clipboard.");
+        message = tr("The list of unsynched items has been copied to the clipboard.");
        _protocolWidget->storeSyncIssues(ts);
     }
 

src/gui/folder.cpp

@@ -81,7 +81,7 @@ Folder::Folder(const FolderDefinition& definition,
 
     _syncResult.setFolder(_definition.alias);
 
-    _engine.reset(new SyncEngine(_accountState->account(), path(), remotePath(), &_journal));
+    _engine.reset(new SyncEngine(_accountState->account(), path(), remoteUrl(), remotePath(), &_journal));
     // pass the setting if hidden files are to be ignored, will be read in csync_update
     _engine->setIgnoreHiddenFiles(_definition.ignoreHiddenFiles);
 
@@ -808,9 +808,6 @@ void Folder::slotSyncFinished(bool success)
     } else if( _syncResult.warnCount() > 0 ) {
         // there have been warnings on the way.
         _syncResult.setStatus(SyncResult::Problem);
-    } else if( _definition.paused ) {
-        // Maybe the sync was terminated because the user paused the folder
-        _syncResult.setStatus(SyncResult::Paused);
     } else {
         _syncResult.setStatus(SyncResult::Success);
     }

src/gui/folderman.cpp

@@ -520,26 +520,6 @@ void FolderMan::scheduleFolder( Folder *f )
     startScheduledSyncSoon();
 }
 
-void FolderMan::scheduleFolderNext(Folder* f)
-{
-    auto alias = f->alias();
-    qDebug() << "Schedule folder " << alias << " to sync! Front-of-queue.";
-
-    if( !f->canSync() ) {
-        qDebug() << "Folder is not ready to sync, not scheduled!";
-        return;
-    }
-
-    _scheduledFolders.removeAll(f);
-
-    f->prepareToSync();
-    emit folderSyncStateChange(f);
-    _scheduledFolders.prepend(f);
-    emit scheduleQueueChanged();
-
-    startScheduledSyncSoon();
-}
-
 void FolderMan::slotScheduleETagJob(const QString &/*alias*/, RequestEtagJob *job)
 {
     QObject::connect(job, SIGNAL(destroyed(QObject*)), this, SLOT(slotEtagJobDestroyed(QObject*)));
@@ -693,11 +673,12 @@ void FolderMan::slotStartScheduledFolderSync()
     }
 
     // Find the first folder in the queue that can be synced.
-    Folder* folder = 0;
+    Folder* f = 0;
     while( !_scheduledFolders.isEmpty() ) {
-        Folder* g = _scheduledFolders.dequeue();
-        if( g->canSync() ) {
-            folder = g;
+        f = _scheduledFolders.dequeue();
+        Q_ASSERT(f);
+
+        if( f->canSync() ) {
             break;
         }
     }
@@ -705,9 +686,9 @@ void FolderMan::slotStartScheduledFolderSync()
     emit scheduleQueueChanged();
 
     // Start syncing this folder!
-    if( folder ) {
-        _currentSyncFolder = folder;
-        folder->startSync( QStringList() );
+    if( f ) {
+        _currentSyncFolder = f;
+        f->startSync( QStringList() );
     }
 }
 

src/gui/folderman.h

@@ -161,22 +161,12 @@ public:
     /** Queues a folder for syncing. */
     void scheduleFolder(Folder*);
 
-    /** Puts a folder in the very front of the queue. */
-    void scheduleFolderNext(Folder*);
-
     /** Queues all folders for syncing. */
     void scheduleAllFolders();
 
     void setDirtyProxy(bool value = true);
     void setDirtyNetworkLimits();
 
-    /**
-     * Terminates the current folder sync.
-     *
-     * It does not switch the folder to paused state.
-     */
-    void terminateSyncProcess();
-
 signals:
     /**
       * signal to indicate a folder has changed its sync state.
@@ -257,6 +247,12 @@ private slots:
     void slotScheduleFolderByTime();
 
 private:
+    /**
+     * Terminates the current folder sync.
+     *
+     * It does not switch the folder to paused state.
+     */
+    void terminateSyncProcess();
 
     /** Adds a new folder, does not add it to the account settings and
      *  does not set an account on the new folder.

src/gui/folderstatusmodel.cpp

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

src/gui/owncloudsetupwizard.cpp

@@ -31,7 +31,6 @@
 #include "sslerrordialog.h"
 #include "accountmanager.h"
 #include "clientproxy.h"
-#include "filesystem.h"
 
 #include "creds/credentialsfactory.h"
 #include "creds/abstractcredentials.h"
@@ -203,34 +202,10 @@ void OwncloudSetupWizard::slotOwnCloudFoundAuth(const QUrl& url, const QVariantM
 
 void OwncloudSetupWizard::slotNoOwnCloudFoundAuth(QNetworkReply *reply)
 {
-    int resultCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    QString contentType = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-
-    // Do this early because reply might be deleted in message box event loop
-    QString msg = tr("Failed to connect to %1 at %2:<br/>%3")
-            .arg(Theme::instance()->appNameGUI(),
-                 reply->url().toString(),
-                 reply->errorString());
-    bool isDowngradeAdvised = checkDowngradeAdvised(reply);
-
-    // If a client cert is needed, nginx sends:
-    // 400 "<html>\r\n<head><title>400 No required SSL certificate was sent</title></head>\r\n<body bgcolor=\"white\">\r\n<center><h1>400 Bad Request</h1></center>\r\n<center>No required SSL certificate was sent</center>\r\n<hr><center>nginx/1.10.0</center>\r\n</body>\r\n</html>\r\n"
-    // If the IP needs to be added as "trusted domain" in oC, oC sends:
-    // https://gist.github.com/guruz/ab6d11df1873c2ad3932180de92e7d82
-    if (resultCode != 200 && contentType.startsWith("text/")) {
-        // FIXME: Synchronous dialogs are not so nice because of event loop recursion
-        // (we already create a dialog further below)
-        QString serverError = reply->peek(1024*20);
-        qDebug() << serverError;
-        QMessageBox messageBox(_ocWizard);
-        messageBox.setText(serverError);
-        messageBox.addButton(QMessageBox::Ok);
-        messageBox.setTextFormat(Qt::RichText);
-        messageBox.exec();
-    }
-
-    // Displays message inside wizard and possibly also another message box
-    _ocWizard->displayError(msg, isDowngradeAdvised);
+    _ocWizard->displayError(tr("Failed to connect to %1 at %2:<br/>%3")
+                            .arg(Theme::instance()->appNameGUI(),
+                                 reply->url().toString(),
+                                 reply->errorString()), checkDowngradeAdvised(reply));
 
     // Allow the credentials dialog to pop up again for the same URL.
     // Maybe the user just clicked 'Cancel' by accident or changed his mind.
@@ -365,8 +340,8 @@ void OwncloudSetupWizard::slotCreateLocalAndRemoteFolders(const QString& localFo
     } else {
         QString res = tr("Creating local sync folder %1...").arg(localFolder);
         if( fi.mkpath( localFolder ) ) {
-            FileSystem::setFolderMinimumPermissions(localFolder);
             Utility::setupFavLink( localFolder );
+            // FIXME: Create a local sync folder.
             res += tr("ok");
         } else {
             res += tr("failed.");

src/gui/wizard/owncloudsetuppage.cpp

@@ -256,7 +256,6 @@ void OwncloudSetupPage::setErrorString( const QString& err, bool retryHTTPonly )
 
                 OwncloudConnectionMethodDialog dialog;
                 dialog.setUrl(url);
-                // FIXME: Synchronous dialogs are not so nice because of event loop recursion
                 int retVal = dialog.exec();
 
                 switch (retVal) {

src/libsync/account.cpp

@@ -57,11 +57,6 @@ Account::~Account()
 
 QString Account::davPath() const
 {
-    if (capabilities().chunkingNg()) {
-        // The chunking-ng means the server prefer to use the new webdav URL
-        return QLatin1String("/remote.php/dav/files/") + davUser() + QLatin1Char('/');
-    }
-
     // make sure to have a trailing slash
     if( !_davPath.endsWith('/') ) {
         QString dp(_davPath);
@@ -81,19 +76,19 @@ AccountPtr Account::sharedFromThis()
     return _sharedThis.toStrongRef();
 }
 
-QString Account::davUser() const
+QString Account::user() const
 {
-    return _davUser.isEmpty() ? _credentials->user() : _davUser;
+    return _user.isEmpty() ? _credentials->user() : _user;
 }
 
-void Account::setDavUser(const QString &newDavUser)
+void Account::setUser(const QString &user)
 {
-    _davUser = newDavUser;
+    _user = user;
 }
 
 QString Account::displayName() const
 {
-    QString dn = QString("%1@%2").arg(davUser(), _url.host());
+    QString dn = QString("%1@%2").arg(user(), _url.host());
     int port = url().port();
     if (port > 0 && port != 80 && port != 443) {
         dn.append(QLatin1Char(':'));

src/libsync/account.h

@@ -69,14 +69,9 @@ public:
 
     AccountPtr sharedFromThis();
 
-    /**
-     * The user that can be used in dav url.
-     *
-     * This can very well be different frome the login user that's
-     * stored in credentials()->user().
-     */
-    QString davUser() const;
-    void setDavUser(const QString &newDavUser);
+    /// The user that can be used in dav url
+    QString user() const;
+    void setUser(const QString &user);
 
     /// The name of the account as shown in the toolbar
     QString displayName() const;
@@ -208,7 +203,7 @@ private:
 
     QWeakPointer<Account> _sharedThis;
     QString _id;
-    QString _davUser;
+    QString _user;
     QMap<QString, QVariant> _settingsMap;
     QUrl _url;
     QList<QSslCertificate> _approvedCerts;

src/libsync/capabilities.cpp

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

src/libsync/connectionvalidator.cpp

@@ -246,7 +246,7 @@ void ConnectionValidator::slotUserFetched(const QVariantMap &json)
 {
     QString user = json.value("ocs").toMap().value("data").toMap().value("id").toString();
     if (!user.isEmpty()) {
-        _account->setDavUser(user);
+        _account->setUser(user);
     }
     reportResult(Connected);
 }

src/libsync/filesystem.cpp

@@ -146,17 +146,6 @@ void FileSystem::setFileReadOnly(const QString& filename, bool readonly)
     file.setPermissions(permissions);
 }
 
-void FileSystem::setFolderMinimumPermissions(const QString& filename)
-{
-#ifdef Q_OS_MAC
-    QFile::Permissions perm = QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner;
-    QFile file(filename);
-    file.setPermissions(perm);
-#else
-    Q_UNUSED(filename);
-#endif
-}
-
 
 void FileSystem::setFileReadOnlyWeak(const QString& filename, bool readonly)
 {

src/libsync/filesystem.h

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

src/libsync/networkjobs.cpp

@@ -463,7 +463,7 @@ bool CheckServerJob::finished()
     }
 
     bool success = false;
-    QByteArray body = reply()->peek(4*1024);
+    QByteArray body = reply()->readAll();
     int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
     if( body.isEmpty() || httpStatus != 200) {
         qDebug() << "error: status.php replied " << httpStatus << body;

src/libsync/owncloudpropagator.cpp

@@ -108,11 +108,6 @@ static bool blacklistCheck(SyncJournalDb* journal, const SyncFileItem& item)
 
     if (newEntry.isValid()) {
         journal->updateErrorBlacklistEntry(newEntry);
-        // Also clear upload info if any so we don't resume from the same transfer-id if there was too many failures (#5344)
-        // (maybe the reason is that the state for this transfer id is broken on the server.)
-        if (newEntry._retryCount > 3) {
-            journal->setUploadInfo(item._file, SyncJournalDb::UploadInfo());
-        }
     } else if (oldEntry.isValid()) {
         journal->wipeErrorBlacklistEntry(item._file);
     }
@@ -276,7 +271,9 @@ PropagateItemJob* OwncloudPropagator::createJob(const SyncFileItemPtr &item) {
                 return job;
             } else {
                 PropagateUploadFileCommon *job = 0;
-                if (item->_size > chunkSize() && account()->capabilities().chunkingNg()) {
+                static const auto chunkng = qgetenv("OWNCLOUD_CHUNKING_NG");
+                if (item->_size > chunkSize()
+                        && (account()->capabilities().chunkingNg() || chunkng == "1") && chunkng != "0") {
                     job = new PropagateUploadFileNG(this, item);
                 } else {
                     job = new PropagateUploadFileV1(this, item);
@@ -317,7 +314,7 @@ void OwncloudPropagator::start(const SyncFileItemVector& items)
 
         if (!removedDirectory.isEmpty() && item->_file.startsWith(removedDirectory)) {
             // this is an item in a directory which is going to be removed.
-            PropagateDirectory *delDirJob = qobject_cast<PropagateDirectory*>(directoriesToRemove.first());
+            PropagateDirectory *delDirJob = dynamic_cast<PropagateDirectory*>(directoriesToRemove.first());
 
             if (item->_instruction == CSYNC_INSTRUCTION_REMOVE) {
                 // already taken care of. (by the removal of the parent directory)
@@ -401,16 +398,9 @@ void OwncloudPropagator::start(const SyncFileItemVector& items)
     }
 
     foreach(PropagatorJob* it, directoriesToRemove) {
-        // ensure that these items will go last in the root folder and append
-        it->setLastOutJobPriority();
         _rootJob->append(it);
     }
 
-    // at this point, all priority values for items in the folders should be set
-    // update priority attribute for folders containing these items
-    // this will move _containerJobs to _subJobs updating their evaluation attributes
-    _rootJob->updateJobPriorityAttributeValues();
-
     connect(_rootJob.data(), SIGNAL(itemCompleted(const SyncFileItem &, const PropagatorJob &)),
             this, SIGNAL(itemCompleted(const SyncFileItem &, const PropagatorJob &)));
     connect(_rootJob.data(), SIGNAL(progress(const SyncFileItem &,quint64)), this, SIGNAL(progress(const SyncFileItem &,quint64)));
@@ -422,12 +412,10 @@ void OwncloudPropagator::start(const SyncFileItemVector& items)
     QTimer::singleShot(0, this, SLOT(scheduleNextJob()));
 }
 
-// ownCloud server  < 7.0 did not had permissions so we need some other euristics
-// to detect wrong doing in a Shared directory
 bool OwncloudPropagator::isInSharedDirectory(const QString& file)
 {
     bool re = false;
-    if( _remoteFolder.startsWith( QLatin1String("Shared") ) ) {
+    if( _remoteDir.contains( _account->davPath() + QLatin1String("Shared") ) ) {
         // The Shared directory is synced as its own sync connection
         re = true;
     } else {
@@ -581,52 +569,20 @@ OwncloudPropagator::DiskSpaceResult OwncloudPropagator::diskSpaceCheck() const
 
 // ================================================================================
 
-void PropagateDirectory::insertItemByPriority(PropagatorJob *subJob){
-    // if job is prioritised, take priority into account, otherwise use modification time
-    int priority = subJob->getJobPriorityAttributeValue();
-
-    if(subJob->_priority == JobPriority::NormalPriority){
-        // jobs are prioritised by timestamp, thus higher timestamp, higher the priority
-        // QMultiMap is sorted in increasing order, so substract from max possible quint64
-        int modificationTimestamp = subJob->getJobPriorityAttributeValue();
-        priority = std::numeric_limits<quint64>::max() - modificationTimestamp;
-    }
-
-    _subJobs.insertMulti(priority, subJob);
-}
-
-void PropagateDirectory::updateJobPriorityAttributeValues()
-{
-    // This uses recursion to perform Depth-First Traversal of the directories with changes trees
-    // If the given (this) directory contains _containerJobs, it will call updateJob on that child dir job, otherwise does nothing
-
-    //this will get the _container jobs within this parent directory and iterate over them
-    QMutableVectorIterator<PropagatorJob *> containerJobsIterator(_containerJobs);
-    while (containerJobsIterator.hasNext()) {
-        //take next Container Job
-        PropagatorJob * subJob = containerJobsIterator.next();
-
-        //ascend to its child folders to update their priorities
-        subJob->updateJobPriorityAttributeValues();
-
-        //at this point, all child folders are updated, add job to _subJobs and remote job from _containerJobs
-         insertItemByPriority(subJob);
-         containerJobsIterator.remove();
-    }
-}
-
 PropagatorJob::JobParallelism PropagateDirectory::parallelism()
 {
     // If any of the non-finished sub jobs is not parallel, we have to wait
+
+    // FIXME!  we should probably cache this result
+
     if (_firstJob && _firstJob->_state != Finished) {
         if (_firstJob->parallelism() != FullParallelism)
             return WaitForFinished;
     }
 
-    QMapIterator<quint64, PropagatorJob *> subJobsIterator(_subJobs);
-    while (subJobsIterator.hasNext()) {
-        subJobsIterator.next();
-        if (subJobsIterator.value()->_state != Finished && subJobsIterator.value()->parallelism() != FullParallelism) {
+    // FIXME: use the cached value of finished job
+    for (int i = 0; i < _subJobs.count(); ++i) {
+        if (_subJobs.at(i)->_state != Finished && _subJobs.at(i)->parallelism() != FullParallelism) {
             return WaitForFinished;
         }
     }
@@ -643,11 +599,6 @@ bool PropagateDirectory::scheduleNextJob()
     if (_state == NotYetStarted) {
         _state = Running;
 
-        // at the begining of the Directory Job, update expected number of Jobs to be synced
-        _totalJobs = _subJobs.count();
-        if (_firstJob)
-            _totalJobs++;
-
         if (!_firstJob && _subJobs.isEmpty()) {
             finalize();
             return true;
@@ -662,27 +613,30 @@ bool PropagateDirectory::scheduleNextJob()
         return false;
     }
 
+    // cache the value of first unfinished subjob
     bool stopAtDirectory = false;
+    int i = _firstUnfinishedSubJob;
+    int subJobsCount = _subJobs.count();
+    while (i < subJobsCount && _subJobs.at(i)->_state == Finished) {
+      _firstUnfinishedSubJob = ++i;
+    }
 
-    QMutableMapIterator<quint64, PropagatorJob *> subJobsIterator(_subJobs);
-    while (subJobsIterator.hasNext()) {
-        subJobsIterator.next();
-        if (subJobsIterator.value()->_state == Finished) {
-            subJobsIterator.remove();
+    for (int i = _firstUnfinishedSubJob; i < subJobsCount; ++i) {
+        if (_subJobs.at(i)->_state == Finished) {
             continue;
         }
 
-        if (stopAtDirectory && qobject_cast<PropagateDirectory*>(subJobsIterator.value())) {
+        if (stopAtDirectory && qobject_cast<PropagateDirectory*>(_subJobs.at(i))) {
             return false;
         }
 
-        if (possiblyRunNextJob(subJobsIterator.value())) {
+        if (possiblyRunNextJob(_subJobs.at(i))) {
             return true;
         }
 
-        Q_ASSERT(subJobsIterator.value()->_state == Running);
+        Q_ASSERT(_subJobs.at(i)->_state == Running);
 
-        auto paral = subJobsIterator.value()->parallelism();
+        auto paral = _subJobs.at(i)->parallelism();
         if (paral == WaitForFinished) {
             return false;
         }
@@ -707,9 +661,14 @@ void PropagateDirectory::slotSubJobFinished(SyncFileItem::Status status)
     _runningNow--;
     _jobsFinished++;
 
+    int totalJobs = _subJobs.count();
+    if (_firstJob) {
+        totalJobs++;
+    }
+
     // We finished processing all the jobs
     // check if we finished
-    if (_jobsFinished >= _totalJobs) {
+    if (_jobsFinished >= totalJobs) {
         Q_ASSERT(!_runningNow); // how can we be finished if there are still jobs running now
         finalize();
     } else {

src/libsync/owncloudpropagator.h

@@ -15,7 +15,6 @@
 #ifndef OWNCLOUDPROPAGATOR_H
 #define OWNCLOUDPROPAGATOR_H
 
-#include <limits>
 #include <QHash>
 #include <QObject>
 #include <QMap>
@@ -25,12 +24,12 @@
 #include <QPointer>
 #include <QIODevice>
 #include <QMutex>
-#include <QDebug>
 
 #include "syncfileitem.h"
 #include "syncjournaldb.h"
 #include "bandwidthmanager.h"
 #include "accountfwd.h"
+
 namespace OCC {
 
 /** Free disk space threshold below which syncs will abort and not even start.
@@ -61,32 +60,7 @@ protected:
     OwncloudPropagator *_propagator;
 
 public:
-    enum JobPriority {
-        /**
-         * Jobs are prioritized, so that they will be executed unconditionaly first,
-         * according to insertion order withing the items of the same priority
-        */
-        FirstOutPriority,
-
-        /**
-         * Jobs are prioritized, so that they will be executed unconditionaly last,
-         * according to insertion order withing the items of the same priority
-        */
-        LastOutPriority,
-
-        /** Jobs are normaly prioritized, so that they will be executed according to some evaluation attribute represented by integer*/
-        NormalPriority,
-
-        /** To contruct predicate for this Priority, all subitem has to be classified and contenerised  */
-        ContainerItemsPriority,
-    };
-
-    explicit PropagatorJob(OwncloudPropagator* propagator, JobPriority priority) : _propagator(propagator), _priority(priority), _state(NotYetStarted) {}
-
-    /*
-    * Keeps track of the priority of the object
-    */
-    JobPriority _priority;
+    explicit PropagatorJob(OwncloudPropagator* propagator) : _propagator(propagator), _state(NotYetStarted) {}
 
     enum JobState {
         NotYetStarted,
@@ -126,41 +100,6 @@ public:
      */
     virtual qint64 committedDiskSpace() const { return 0; }
 
-    /**
-     * Returns job priority predicate value according to LastOut or FirstOut priority
-     * or method can be overriden to return a specific priority attribute value
-     *
-     * FirstOut priority will return minimum value for quint64 since QMultiMap keys are sorted in increasing order
-     *
-     * This method returns 0 in case of error
-     */
-    virtual quint64 getJobPriorityAttributeValue() const {
-        if (_priority==JobPriority::FirstOutPriority) {
-            return std::numeric_limits<quint64>::min();
-        } else if (_priority==JobPriority::LastOutPriority){
-            return std::numeric_limits<quint64>::max();
-        } else {
-            return 0;
-        }
-    }
-
-    /**
-     * Updates job priorities for the given job
-     */
-    virtual void updateJobPriorityAttributeValues() {}
-
-    /**
-     * Enforces FirstOut job priority.
-     * NOTE: This has to be set before item is being added to _subJobs queue to be propagated!
-     */
-    virtual void setFirstOutJobPriority() { _priority = JobPriority::FirstOutPriority; }
-
-    /**
-     * Enforces LastOut job priority
-     * NOTE: This has to be set before item is being added to _subJobs queue to be propagated!
-     */
-    virtual void setLastOutJobPriority() { _priority = JobPriority::LastOutPriority; }
-
 public slots:
     virtual void abort() {}
 
@@ -219,15 +158,14 @@ private:
     QScopedPointer<PropagateItemJob> _restoreJob;
 
 public:
-    PropagateItemJob(OwncloudPropagator* propagator, const SyncFileItemPtr &item, JobPriority priority)
-        : PropagatorJob(propagator, priority), _item(item) {}
+    PropagateItemJob(OwncloudPropagator* propagator, const SyncFileItemPtr &item)
+        : PropagatorJob(propagator), _item(item) {}
 
     bool scheduleNextJob() Q_DECL_OVERRIDE {
         if (_state != NotYetStarted) {
             return false;
         }
         _state = Running;
-        qDebug() << "Modification Time - Priority" << _item->_modtime << "Item" << _item->_file;
         QMetaObject::invokeMethod(this, "start"); // We could be in a different thread (neon jobs)
         return true;
     }
@@ -249,45 +187,27 @@ public:
     // e.g: create the directory
     QScopedPointer<PropagateItemJob>_firstJob;
 
-    /*
-     * All the sub files or sub directories. This map has to be updated with _containerJobs
-     * QMultiMap is ordered by the key value, or in case of equal keys (e.g 0) by insertion order.
-     * <quint64 predicate, PropagatorJob * job>, where predicate is obtained by call to getJobPredicateValue()
-     */
-    QMultiMap<quint64, PropagatorJob *> _subJobs;
-
-    /*
-     * This vector is just temporary structure used to keep the "container" jobs like directory job.
-     * After the updateJobPredicateValues() is called on this directories, these container jobs will be inserted
-     * to _subJobs queue. Note: This has to be called after all items are added to the _subJobs for whole the sync!
-     */
-    QVector<PropagatorJob *> _containerJobs;
+    // all the sub files or sub directories.
+    QVector<PropagatorJob *> _subJobs;
 
     SyncFileItemPtr _item;
 
     int _jobsFinished; // number of jobs that have completed
-    int _totalJobs; // number of jobs that will be defined to be synced
     int _runningNow; // number of subJobs running right now
     SyncFileItem::Status _hasError;  // NoStatus,  or NormalError / SoftError if there was an error
+    int _firstUnfinishedSubJob;
 
     explicit PropagateDirectory(OwncloudPropagator *propagator, const SyncFileItemPtr &item = SyncFileItemPtr(new SyncFileItem))
-        : PropagatorJob(propagator, JobPriority::ContainerItemsPriority)
-        , _firstJob(0), _item(item),  _jobsFinished(0),  _totalJobs(0), _runningNow(0), _hasError(SyncFileItem::NoStatus)
+        : PropagatorJob(propagator)
+        , _firstJob(0), _item(item),  _jobsFinished(0), _runningNow(0), _hasError(SyncFileItem::NoStatus), _firstUnfinishedSubJob(0)
     { }
 
     virtual ~PropagateDirectory() {
         qDeleteAll(_subJobs);
-        qDeleteAll(_containerJobs);
     }
 
     void append(PropagatorJob *subJob) {
-        // we do not yet have all items in all the folders, so add it temporarly to _containerJobs and move to _subJobs
-        // directly before start of the sync (after updating priority attributes)
-        if(subJob->_priority == JobPriority::ContainerItemsPriority){
-            _containerJobs.append(subJob);
-        } else {
-            insertItemByPriority(subJob);
-        }
+        _subJobs.append(subJob);
     }
 
     virtual bool scheduleNextJob() Q_DECL_OVERRIDE;
@@ -307,21 +227,6 @@ public:
 
     qint64 committedDiskSpace() const Q_DECL_OVERRIDE;
 
-    // this item is prioritized normaly, so get priority by its sub items highest modification timestamp (most recent modification)
-    // because _subJobs are already sorted, take first job priority attribute
-    quint64 getJobPriorityAttributeValue() const  Q_DECL_OVERRIDE {
-        if (_priority == JobPriority::ContainerItemsPriority && !_subJobs.empty())
-            return _subJobs.first()->getJobPriorityAttributeValue();
-
-        // subJobs empty or forced priority, return priority of folder itself
-        return PropagatorJob::getJobPriorityAttributeValue();
-    }
-
-    // this method should decide about prioritising single items during their insert
-    void insertItemByPriority(PropagatorJob *subJob);
-
-    // this method should decide about prioritising container items during their insert
-    void updateJobPriorityAttributeValues();
 private slots:
     bool possiblyRunNextJob(PropagatorJob *next) {
         if (next->_state == NotYetStarted) {
@@ -347,7 +252,7 @@ class PropagateIgnoreJob : public PropagateItemJob {
     Q_OBJECT
 public:
     PropagateIgnoreJob(OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority) {}
+        : PropagateItemJob(propagator, item) {}
     void start() Q_DECL_OVERRIDE {
         SyncFileItem::Status status = _item->_status;
         done(status == SyncFileItem::NoStatus ? SyncFileItem::FileIgnored : status, _item->_errorString);
@@ -362,7 +267,8 @@ class OwncloudPropagator : public QObject {
 
 public:
     const QString _localDir; // absolute path to the local directory. ends with '/'
-    const QString _remoteFolder; // remote folder, ends with '/'
+    const QString _remoteDir; // path to the root of the remote. ends with '/'  (include WebDAV path)
+    const QString _remoteFolder; // folder. (same as remoteDir but without the WebDAV path)
 
     SyncJournalDb * const _journal;
     bool _finishedEmited; // used to ensure that finished is only emitted once
@@ -370,8 +276,10 @@ public:
 
 public:
     OwncloudPropagator(AccountPtr account, const QString &localDir,
-                       const QString &remoteFolder, SyncJournalDb *progressDb)
+                       const QString &remoteDir, const QString &remoteFolder,
+                       SyncJournalDb *progressDb)
             : _localDir((localDir.endsWith(QChar('/'))) ? localDir : localDir+'/' )
+            , _remoteDir((remoteDir.endsWith(QChar('/'))) ? remoteDir : remoteDir+'/' )
             , _remoteFolder((remoteFolder.endsWith(QChar('/'))) ? remoteFolder : remoteFolder+'/' )
             , _journal(progressDb)
             , _finishedEmited(false)

src/libsync/propagatedownload.h

@@ -110,16 +110,13 @@ class PropagateDownloadFile : public PropagateItemJob {
     Q_OBJECT
 public:
     PropagateDownloadFile(OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::NormalPriority), _resumeStart(0), _downloadProgress(0), _deleteExisting(false) {}
+        : PropagateItemJob(propagator, item), _resumeStart(0), _downloadProgress(0), _deleteExisting(false) {}
     void start() Q_DECL_OVERRIDE;
     qint64 committedDiskSpace() const Q_DECL_OVERRIDE;
 
     // We think it might finish quickly because it is a small file.
     bool isLikelyFinishedQuickly() Q_DECL_OVERRIDE { return _item->_size < 100*1024; }
 
-    // this item is prioritized normaly, so get priority by its modification time
-    quint64 getJobPriorityAttributeValue() const Q_DECL_OVERRIDE { return _item->_modtime; }
-
     /**
      * Whether an existing folder with the same name may be deleted before
      * the download.

src/libsync/propagateremotedelete.h

@@ -48,7 +48,7 @@ class PropagateRemoteDelete : public PropagateItemJob {
     QPointer<DeleteJob> _job;
 public:
     PropagateRemoteDelete (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::LastOutPriority) {}
+        : PropagateItemJob(propagator, item) {}
     void start() Q_DECL_OVERRIDE;
     void abort() Q_DECL_OVERRIDE;
 

src/libsync/propagateremotemkdir.h

@@ -29,7 +29,7 @@ class PropagateRemoteMkdir : public PropagateItemJob {
     friend class PropagateDirectory; // So it can access the _item;
 public:
     PropagateRemoteMkdir (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority), _deleteExisting(false) {}
+        : PropagateItemJob(propagator, item), _deleteExisting(false) {}
     void start() Q_DECL_OVERRIDE;
     void abort() Q_DECL_OVERRIDE;
 

src/libsync/propagateremotemove.cpp

@@ -20,7 +20,6 @@
 #include "filesystem.h"
 #include <QFile>
 #include <QStringList>
-#include <QDir>
 
 namespace OCC {
 
@@ -102,11 +101,10 @@ void PropagateRemoteMove::start()
         }
     }
 
-    QString destination = QDir::cleanPath(_propagator->account()->url().path() + QLatin1Char('/')
-            + _propagator->account()->davPath() + _propagator->_remoteFolder + _item->_renameTarget);
     _job = new MoveJob(_propagator->account(),
                         _propagator->_remoteFolder + _item->_file,
-                        destination, this);
+                        _propagator->_remoteDir + _item->_renameTarget,
+                        this);
     connect(_job, SIGNAL(finishedSignal()), this, SLOT(slotMoveJobFinished()));
     _propagator->_activeJobList.append(this);
     _job->start();

src/libsync/propagateremotemove.h

@@ -51,7 +51,7 @@ class PropagateRemoteMove : public PropagateItemJob {
     QPointer<MoveJob> _job;
 public:
     PropagateRemoteMove (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority) {}
+        : PropagateItemJob(propagator, item) {}
     void start() Q_DECL_OVERRIDE;
     void abort() Q_DECL_OVERRIDE;
     JobParallelism parallelism() Q_DECL_OVERRIDE { return OCC::PropagatorJob::WaitForFinishedInParentDirectory; }

src/libsync/propagateupload.h

@@ -197,7 +197,7 @@ protected:
 
 public:
     PropagateUploadFileCommon(OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::NormalPriority), _finished(false), _deleteExisting(false) {}
+        : PropagateItemJob(propagator, item), _finished(false), _deleteExisting(false) {}
 
     /**
      * Whether an existing entity with the same name may be deleted before
@@ -211,9 +211,6 @@ public:
 
     bool isLikelyFinishedQuickly() Q_DECL_OVERRIDE { return _item->_size < 100*1024; }
 
-    // this item is prioritized normaly, so get priority by its modification time
-    quint64 getJobPriorityAttributeValue() const Q_DECL_OVERRIDE { return _item->_modtime; }
-
 private slots:
     void slotComputeContentChecksum();
     // Content checksum computed, compute the transmission checksum

src/libsync/propagateuploadng.cpp

@@ -38,7 +38,7 @@ namespace OCC {
 QUrl PropagateUploadFileNG::chunkUrl(int chunk)
 {
     QString path = QLatin1String("remote.php/dav/uploads/")
-        + _propagator->account()->davUser()
+        + _propagator->account()->user()
         + QLatin1Char('/') + QString::number(_transferId);
     if (chunk >= 0) {
         path += QLatin1Char('/') + QString::number(chunk);
@@ -268,8 +268,9 @@ void PropagateUploadFileNG::startNextChunk()
         Q_ASSERT(_jobs.isEmpty()); // There should be no running job anymore
         _finished = true;
         // Finish with a MOVE
-        QString destination = QDir::cleanPath(_propagator->account()->url().path() + QLatin1Char('/')
-            + _propagator->account()->davPath() + _propagator->_remoteFolder + _item->_file);
+        QString destination = _propagator->account()->url().path()
+            + QLatin1String("/remote.php/dav/files/") + _propagator->account()->user()
+            + _propagator->_remoteFolder + _item->_file;
         auto headers = PropagateUploadFileCommon::headers();
 
         // "If-Match applies to the source, but we are interested in comparing the etag of the destination

src/libsync/propagatorjobs.h

@@ -40,8 +40,7 @@ static const char checkSumAdlerC[] = "Adler32";
 class PropagateLocalRemove : public PropagateItemJob {
     Q_OBJECT
 public:
-    PropagateLocalRemove (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority) {}
+    PropagateLocalRemove (OwncloudPropagator* propagator,const SyncFileItemPtr& item)  : PropagateItemJob(propagator, item) {}
     void start() Q_DECL_OVERRIDE;
 private:
     bool removeRecursively(const QString &path);
@@ -56,7 +55,7 @@ class PropagateLocalMkdir : public PropagateItemJob {
     Q_OBJECT
 public:
     PropagateLocalMkdir (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority), _deleteExistingFile(false) {}
+        : PropagateItemJob(propagator, item), _deleteExistingFile(false) {}
     void start() Q_DECL_OVERRIDE;
 
     /**
@@ -78,8 +77,7 @@ private:
 class PropagateLocalRename : public PropagateItemJob {
     Q_OBJECT
 public:
-    PropagateLocalRename (OwncloudPropagator* propagator,const SyncFileItemPtr& item)
-        : PropagateItemJob(propagator, item, JobPriority::FirstOutPriority) {}
+    PropagateLocalRename (OwncloudPropagator* propagator,const SyncFileItemPtr& item)  : PropagateItemJob(propagator, item) {}
     void start() Q_DECL_OVERRIDE;
     JobParallelism parallelism() Q_DECL_OVERRIDE { return WaitForFinishedInParentDirectory; }
 };

src/libsync/syncengine.cpp

@@ -57,11 +57,12 @@ bool SyncEngine::s_anySyncRunning = false;
 qint64 SyncEngine::minimumFileAgeForUpload = 2000;
 
 SyncEngine::SyncEngine(AccountPtr account, const QString& localPath,
-                       const QString& remotePath, OCC::SyncJournalDb* journal)
+                       const QUrl& remoteURL, const QString& remotePath, OCC::SyncJournalDb* journal)
   : _account(account)
   , _needsUpdate(false)
   , _syncRunning(false)
   , _localPath(localPath)
+  , _remoteUrl(remoteURL)
   , _remotePath(remotePath)
   , _journal(journal)
   , _progressInfo(new ProgressInfo)
@@ -82,7 +83,18 @@ SyncEngine::SyncEngine(AccountPtr account, const QString& localPath,
     // Everything in the SyncEngine expects a trailing slash for the localPath.
     Q_ASSERT(localPath.endsWith(QLatin1Char('/')));
 
-    csync_create(&_csync_ctx, localPath.toUtf8().data());
+    // We need to reconstruct the url because the path needs to be fully decoded, as csync will re-encode the path:
+    //  Remember that csync will just append the filename to the path and pass it to the vio plugin.
+    //  csync_owncloud will then re-encode everything.
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
+    QString url_string = _remoteUrl.scheme() + QLatin1String("://") + _remoteUrl.authority(QUrl::EncodeDelimiters) + _remoteUrl.path(QUrl::FullyDecoded);
+#else
+    // Qt4 was broken anyway as it did not encode the '#' as it should have done  (it was actually a problem when parsing the path from QUrl::setPath
+    QString url_string = _remoteUrl.toString();
+#endif
+    url_string = Utility::toCSyncScheme(url_string);
+
+    csync_create(&_csync_ctx, localPath.toUtf8().data(), url_string.toUtf8().data());
     csync_init(_csync_ctx);
     _excludedFiles.reset(new ExcludedFiles(&_csync_ctx->excludes));
     _syncFileStatusTracker.reset(new SyncFileStatusTracker(this));
@@ -819,6 +831,7 @@ void SyncEngine::startSync()
 
     // This is used for the DiscoveryJob to be able to request the main thread/
     // to read in directory contents.
+    qDebug() << Q_FUNC_INFO << _remotePath << _remoteUrl;
     _discoveryMainThread->setupHooks( discoveryJob, _remotePath);
 
     // Starts the update in a seperate thread
@@ -970,7 +983,7 @@ void SyncEngine::slotDiscoveryJobFinished(int discoveryResult)
     _journal->commit("post treewalk");
 
     _propagator = QSharedPointer<OwncloudPropagator>(
-        new OwncloudPropagator (_account, _localPath, _remotePath, _journal));
+        new OwncloudPropagator (_account, _localPath, _remoteUrl.path(), _remotePath, _journal));
     connect(_propagator.data(), SIGNAL(itemCompleted(const SyncFileItem &, const PropagatorJob &)),
             this, SLOT(slotItemCompleted(const SyncFileItem &, const PropagatorJob &)));
     connect(_propagator.data(), SIGNAL(progress(const SyncFileItem &,quint64)),

src/libsync/syncengine.h

@@ -58,7 +58,7 @@ class OWNCLOUDSYNC_EXPORT SyncEngine : public QObject
     Q_OBJECT
 public:
     SyncEngine(AccountPtr account, const QString &localPath,
-               const QString &remotePath, SyncJournalDb *journal);
+               const QUrl &remoteURL, const QString &remotePath, SyncJournalDb *journal);
     ~SyncEngine();
 
     static QString csyncErrorToString( CSYNC_STATUS);
@@ -196,6 +196,7 @@ private:
     bool _needsUpdate;
     bool _syncRunning;
     QString _localPath;
+    QUrl _remoteUrl;
     QString _remotePath;
     QString _remoteRootEtag;
     SyncJournalDb *_journal;

src/libsync/utility.cpp

@@ -243,6 +243,19 @@ QString Utility::compactFormatDouble(double value, int prec, const QString& unit
     return str;
 }
 
+QString Utility::toCSyncScheme(const QString &urlStr)
+{
+
+    QUrl url( urlStr );
+    if( url.scheme() == QLatin1String("http") ) {
+        url.setScheme( QLatin1String("owncloud") );
+    } else {
+        // connect SSL!
+        url.setScheme( QLatin1String("ownclouds") );
+    }
+    return url.toString();
+}
+
 QString Utility::escape(const QString &in)
 {
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)

src/libsync/utility.h

@@ -44,6 +44,7 @@ namespace Utility
     OWNCLOUDSYNC_EXPORT bool hasLaunchOnStartup(const QString &appName);
     OWNCLOUDSYNC_EXPORT void setLaunchOnStartup(const QString &appName, const QString& guiName, bool launch);
     OWNCLOUDSYNC_EXPORT qint64 freeDiskSpace(const QString &path);
+    OWNCLOUDSYNC_EXPORT QString toCSyncScheme(const QString &urlStr);
 
     /**
      * @brief compactFormatDouble - formats a double value human readable.

test/owncloud_add_test.cmake

@@ -21,6 +21,6 @@ macro(owncloud_add_test test_class additional_cpp)
     )
 
     add_definitions(-DOWNCLOUD_TEST)
-    add_definitions(-DOWNCLOUD_BIN_PATH=${CMAKE_BINARY_DIR}/bin)
+    add_definitions(-DOWNCLOUD_BIN_PATH="${CMAKE_BINARY_DIR}/bin")
     add_test(NAME ${OWNCLOUD_TEST_CLASS}Test COMMAND ${OWNCLOUD_TEST_CLASS}Test)
 endmacro()

test/syncenginetestutils.h

@@ -738,7 +738,7 @@ public:
         _account->setCredentials(new FakeCredentials{_fakeQnam});
 
         _journalDb.reset(new OCC::SyncJournalDb(localPath()));
-        _syncEngine.reset(new OCC::SyncEngine(_account, localPath(), "", _journalDb.get()));
+        _syncEngine.reset(new OCC::SyncEngine(_account, localPath(), sRootUrl, "", _journalDb.get()));
 
         // A new folder will update the local file state database on first sync.
         // To have a state matching what users will encounter, we have to a sync

test/testexcludedfiles.cpp

@@ -11,10 +11,6 @@
 
 using namespace OCC;
 
-#define STR_(X) #X
-#define STR(X) STR_(X)
-#define BIN_PATH STR(OWNCLOUD_BIN_PATH)
-
 class TestExcludedFiles: public QObject
 {
     Q_OBJECT
@@ -31,7 +27,7 @@ private slots:
         QVERIFY(!excluded.isExcluded("/a/.b", "/a", keepHidden));
         QVERIFY(excluded.isExcluded("/a/.b", "/a", excludeHidden));
 
-        QString path(BIN_PATH);
+        QString path(OWNCLOUD_BIN_PATH);
         path.append("/sync-exclude.lst");
         excluded.addExcludeFilePath(path);
         excluded.reloadExcludes();
@@ -39,9 +35,9 @@ private slots:
         QVERIFY(!excluded.isExcluded("/a/b", "/a", keepHidden));
         QVERIFY(excluded.isExcluded("/a/b~", "/a", keepHidden));
         QVERIFY(!excluded.isExcluded("/a/.b", "/a", keepHidden));
+        QVERIFY(excluded.isExcluded("/a/.b", "/a", excludeHidden));
         QVERIFY(excluded.isExcluded("/a/.Trashes", "/a", keepHidden));
         QVERIFY(excluded.isExcluded("/a/foo_conflict-bar", "/a", keepHidden));
-        QVERIFY(excluded.isExcluded("/a/.b", "/a", excludeHidden));
     }
 };
 

test/testutility.cpp

@@ -8,10 +8,6 @@
 
 #include "utility.h"
 
-#define STR_(X) #X
-#define STR(X) STR_(X)
-#define BIN_PATH STR(OWNCLOUD_BIN_PATH)
-
 using namespace OCC::Utility;
 
 class TestUtility : public QObject
@@ -64,6 +60,14 @@ private slots:
         QVERIFY(hasLaunchOnStartup(appName) == false);
     }
 
+    void testToCSyncScheme()
+    {
+        QVERIFY(toCSyncScheme("http://example.com/owncloud/") ==
+                              "owncloud://example.com/owncloud/");
+        QVERIFY(toCSyncScheme("https://example.com/owncloud/") ==
+                              "ownclouds://example.com/owncloud/");
+    }
+
     void testDurationToDescriptiveString()
     {
         QLocale::setDefault(QLocale("C"));
@@ -115,7 +119,7 @@ private slots:
             }
             // pass the binary name owncloud to the next call. This brakes branding,
             // but branding is not supposed to work with this.
-            QString ver = versionOfInstalledBinary(BIN_PATH+QLatin1String("/owncloud"));
+            QString ver = versionOfInstalledBinary(OWNCLOUD_BIN_PATH+QLatin1String("/owncloud"));
 	    qDebug() << "Version of installed ownCloud Binary: " << ver;
 	    QVERIFY( !ver.isEmpty());