12 files changed, 622 insertions, 0 deletions

diff --git a/trunk/src/AbstractSecushareController.cpp b/trunk/src/AbstractSecushareController.cpp
new file mode 100644
index 0000000..db720fb
--- /dev/null
+++ b/trunk/src/AbstractSecushareController.cpp
@@ -0,0 +1,242 @@
+/**
+ * @file AbstractSecushareController.cpp
+ * @brief Abstract controller class
+ *
+ * @author lurchi
+ * @date 2016-02-05
+ *
+ * @copyright 
+ * This file is part of redthread which may be redistributed and/or modified
+ * under the terms of the GNU General Public License, either version 3 or any
+ * later version. See COPYING and <http://www.gnu.org/licenses/>.
+ */
+
+#include "AbstractSecushareController.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace redthread;
+
+AbstractSecushareController::AbstractSecushareController(
+    std::shared_ptr<AbstractSecushareView> view,
+    const std::string& appName,
+    const std::string& appVersion,
+    const std::string& configPath
+)
+    : mView {view},
+      mAppName {appName},
+      mAppVersion {appVersion},
+      mConfigFilePath {configPath},
+      mRunning {false}
+{
+    auto config = mView->getUserConfigModel();
+
+    // TODO: read config from disk
+    config->setShowNewIdentityDialog(true);
+}
+
+int AbstractSecushareController::run()
+{
+    const std::vector<struct GNUNET_GETOPT_CommandLineOption> options
+    {
+        GNUNET_GETOPT_OPTION_END
+    };
+
+    std::string configFileOption {"-c"};
+
+    const std::vector<char*> argv
+    {
+        &mAppName[0],
+        &configFileOption[0],
+        &mConfigFilePath[0]
+    };
+
+    mRunning = true;
+  
+    return
+    GNUNET_PROGRAM_run(argv.size(),
+                       argv.data(),
+                       mAppName.data(),
+                       gettext_noop("binary description text"),
+                       options.data(),
+                       &AbstractSecushareController::runCb,
+                       this);
+}
+
+void AbstractSecushareController::addExternalEventFD()
+{
+    auto fileHandle = GNUNET_DISK_get_handle_from_int_fd(mGnunetTaskPipe.receiverFd());
+
+    mExternalEventFdHandle =
+    GNUNET_SCHEDULER_add_read_file
+    (
+        GNUNET_TIME_UNIT_FOREVER_REL,
+        fileHandle,
+        &AbstractSecushareController::processGnunetTasksCb,
+        this
+    );
+
+}
+
+void AbstractSecushareController::addToGnunetTaskQueue(std::function<void()> task)
+{
+    {
+        std::lock_guard<std::mutex> lock {mGnunetTasksMutex};
+        mGnunetTasks.push(task);
+    }
+
+    mGnunetTaskPipe.notify(); 
+}
+
+void AbstractSecushareController::processGnunetTasksCb(
+    void* closure,
+    const struct GNUNET_SCHEDULER_TaskContext* context
+)
+{
+    //DEBUG
+    std::cout << "AbstractSecushareController::processGnunetTasksCb" << std::endl;
+
+    AbstractSecushareController* controller {static_cast<AbstractSecushareController*>(closure)};
+    auto& tasks = controller->mGnunetTasks;
+
+    {
+        std::lock_guard<std::mutex> lock {controller->mGnunetTasksMutex};
+   
+        while(not tasks.empty())
+        {
+            tasks.front()();
+            tasks.pop();
+        }
+    }
+
+    if(controller->mRunning)
+    {
+        controller->addExternalEventFD();
+    }
+}
+
+void AbstractSecushareController::runCb(
+    void* closure,
+    char* const* args,
+    const char* configFilePath,
+    const struct GNUNET_CONFIGURATION_Handle* configHandle
+)
+{
+    AbstractSecushareController* controller {static_cast<AbstractSecushareController*>(closure)};
+
+    controller->mConfigHandle = configHandle;
+
+    controller->mAppHandle =
+    GNUNET_SOCIAL_app_connect(
+        configHandle,
+        controller->mAppName.c_str(),
+        &AbstractSecushareController::egoAvailableCb,
+        &AbstractSecushareController::placeAvailableAsHostCb,
+        &AbstractSecushareController::placeAvailableAsGuestCb,
+        closure
+    );
+
+    controller->mIdentityHandle =
+    GNUNET_IDENTITY_connect(controller->mConfigHandle,
+                            &AbstractSecushareController::egoCreatedCb,
+                            controller);
+
+    controller->addExternalEventFD();
+}
+
+void AbstractSecushareController::shutdown()
+{
+    addToGnunetTaskQueue(
+        [this]()
+        {
+            GNUNET_IDENTITY_disconnect(mIdentityHandle);
+            GNUNET_SOCIAL_app_disconnect(mAppHandle);
+        }
+    );
+
+    mRunning = false;
+}
+
+void AbstractSecushareController::addEgo(const std::string& name)
+{
+    addToGnunetTaskQueue(
+        [this, &name]()
+        {
+            GNUNET_IDENTITY_create(
+                mIdentityHandle,
+                name.data(),
+                &AbstractSecushareController::operationFinishedCb,
+                this
+            );
+        }
+    );
+}
+
+void AbstractSecushareController::addFriend(const std::string& nymPubKey, const std::string& name)
+{
+
+}
+
+void AbstractSecushareController::sendMessage(const PlaceId& placeId, const std::string& message)
+{
+
+}
+
+void AbstractSecushareController::egoAvailableCb(
+    void* closure,
+    struct GNUNET_SOCIAL_Ego* ego,
+    const struct GNUNET_CRYPTO_EcdsaPublicKey* egoPubKey,
+    const char* name
+)
+{
+    std::cout << "ego available: " << GNUNET_CRYPTO_ecdsa_public_key_to_string (egoPubKey) << std::endl;
+}
+
+void AbstractSecushareController::placeAvailableAsHostCb(
+    void* closure,
+    struct GNUNET_SOCIAL_HostConnection* connection,
+    struct GNUNET_SOCIAL_Ego* ego,
+    const struct GNUNET_CRYPTO_EddsaPublicKey* hostPubKey,
+    enum GNUNET_SOCIAL_PlaceState placeState
+)
+{
+    struct GNUNET_HashCode hostPubKeyHash;
+    GNUNET_CRYPTO_hash (hostPubKey, sizeof (*hostPubKey), &hostPubKeyHash);
+    std::cout << "place available as host: " << GNUNET_h2s(&hostPubKeyHash) << std::endl;
+}
+
+void AbstractSecushareController::placeAvailableAsGuestCb(
+    void* closure,
+    struct GNUNET_SOCIAL_GuestConnection* connection,
+    struct GNUNET_SOCIAL_Ego* ego,
+    const struct GNUNET_CRYPTO_EddsaPublicKey* guestPubKey,
+    enum GNUNET_SOCIAL_PlaceState placeState
+)
+{
+    struct GNUNET_HashCode guestPubKeyHash;
+    GNUNET_CRYPTO_hash (guestPubKey, sizeof (*guestPubKey), &guestPubKeyHash);
+    std::cout << "place available as guest: " << GNUNET_h2s(&guestPubKeyHash) << std::endl;
+}
+
+void AbstractSecushareController::egoCreatedCb(
+    void *closure,
+    struct GNUNET_IDENTITY_Ego* ego,
+    void** ctx,
+    const char* name
+)
+{
+    std::cout << "ego created" << name << std::endl; 
+}
+
+void AbstractSecushareController::operationFinishedCb(void* closure, const char* errorMessage)
+{
+    // DEBUG:
+    if(errorMessage)
+    {
+        std::cout << "ERROR: " << errorMessage << std::endl;
+    }
+    else
+    {
+        std::cout << "no error" << std::endl;
+    }
+}
diff --git a/trunk/src/AbstractSecushareView.cpp b/trunk/src/AbstractSecushareView.cpp
new file mode 100644
index 0000000..2dfc460
--- /dev/null
+++ b/trunk/src/AbstractSecushareView.cpp
@@ -0,0 +1,13 @@
+// AbstractSecushareView.cpp
+//
+// author: lurchi
+// date: 2016-02-01
+
+#include "AbstractSecushareView.hpp"
+
+using namespace redthread;
+
+AbstractSecushareView::AbstractSecushareView()
+{
+
+}
diff --git a/trunk/src/AbstractUserConfigModel.cpp b/trunk/src/AbstractUserConfigModel.cpp
new file mode 100644
index 0000000..bba79ed
--- /dev/null
+++ b/trunk/src/AbstractUserConfigModel.cpp
@@ -0,0 +1,8 @@
+#include "AbstractUserConfigModel.hpp"
+
+using namespace redthread;
+
+AbstractUserConfigModel::AbstractUserConfigModel()
+{
+
+}
diff --git a/trunk/src/CMakeLists.txt b/trunk/src/CMakeLists.txt
new file mode 100644
index 0000000..cd186ca
--- /dev/null
+++ b/trunk/src/CMakeLists.txt
@@ -0,0 +1,61 @@
+# src/CMakeLists.txt
+
+include(CheckIncludeFileCXX)
+
+set(THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party")
+
+# gnunet
+set(GNUNET_SOCIAL_NEEDED true)
+find_package(Gnunet REQUIRED)
+set(LIBS ${LIBS} ${GNUNET_LIBRARIES})
+set(REDTHREAD_INCLUDE_DIRS ${REDTHREAD_INCLUDE_DIRS} ${GNUNET_INCLUDE_DIRS})
+
+# ncurses
+set(CURSES_NEED_NCURSES true)
+find_package(Curses 6 REQUIRED)
+set(LIBS ${LIBS} ${CURSES_LIBRARIES})
+set(REDTHREAD_INCLUDE_DIRS ${REDTHREAD_INCLUDE_DIRS} ${CURSES_INCLUDE_DIRS})
+
+# Qt
+set(CMAKE_AUTOMOC ON)
+find_package(Qt5Widgets REQUIRED)
+find_package(Qt5Quick REQUIRED)
+file(GLOB hpp_files "${PROJECT_SOURCE_DIR}/include/*.hpp")
+qt_wrap_cpp(redthread qt_wrappers ${hpp_files})
+set(source_files ${source_files} ${qt_wrappers})
+set(LIBS ${LIBS} Qt5::Widgets Qt5::Quick)
+
+# sigc++
+#find_package(SigC++ REQUIRED)
+#set(LIBS ${LIBS} ${SIGC++_LIBRARIES})
+#set(REDTHREAD_INCLUDE_DIRS ${REDTHREAD_INCLUDE_DIRS} ${SIGC++_INCLUDE_DIRS})
+
+# boost::signals2 (header only)
+#find_package(Boost REQUIRED)
+#set(REDTHREAD_INCLUDE_DIRS ${REDTHREAD_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS})
+
+#set(CMAKE_CXX_FLAGS "-O2 -Os -std=c++11 -Wall -Wextra -pedantic -lstdc++" CACHE STRING "" FORCE)
+set(CMAKE_CXX_FLAGS "-g -std=c++11 -Wall -Wextra")
+set(CMAKE_EXE_LINKER_FLAGS "")
+
+set(source_files ${source_files}
+    AbstractSecushareController.cpp
+    AbstractSecushareView.cpp
+    AbstractUserConfigModel.cpp
+    Identity.cpp
+    main.cpp
+    NotifyPipe.cpp
+    Place.cpp
+    QtUserConfigModel.cpp
+    RedThreadQt.cpp
+    SecushareQtController.cpp
+    SecushareQtView.cpp
+)
+
+add_executable(redthread ${source_files})
+target_include_directories(redthread PUBLIC
+                           ${REDTHREAD_INCLUDE_DIRS}
+                           ${PROJECT_SOURCE_DIR} # for config.h
+                           ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(redthread ${LIBS})
+
diff --git a/trunk/src/Identity.cpp b/trunk/src/Identity.cpp
new file mode 100644
index 0000000..61e5344
--- /dev/null
+++ b/trunk/src/Identity.cpp
@@ -0,0 +1,27 @@
+#include "Identity.hpp"
+#include <algorithm>
+
+using namespace redthread;
+
+Identity::Identity(const std::string& masterPubKey,
+                   const std::vector<std::string>& subordinatePubKeys)
+    : mMasterPubKey {masterPubKey}, mSubordinatePubKeys {subordinatePubKeys}
+{
+
+}
+
+bool Identity::operator==(const Identity& other) const
+{
+    return
+    (mMasterPubKey == other.mMasterPubKey) or
+    std::any_of(
+        other.mSubordinatePubKeys.cbegin(),
+        other.mSubordinatePubKeys.cend(),
+        [this](const std::string& k)
+        {
+            return
+            std::find(mSubordinatePubKeys.cbegin(), mSubordinatePubKeys.cend(), k)
+            != mSubordinatePubKeys.cend();
+        }
+    );
+}
diff --git a/trunk/src/NotifyPipe.cpp b/trunk/src/NotifyPipe.cpp
new file mode 100644
index 0000000..3127cf4
--- /dev/null
+++ b/trunk/src/NotifyPipe.cpp
@@ -0,0 +1,36 @@
+#include "NotifyPipe.hpp"
+
+#include <unistd.h>
+#include <assert.h>
+#include <fcntl.h>
+
+using namespace Util;
+
+NotifyPipe::NotifyPipe()
+{
+    int pipefd[2];
+    int ret = pipe(pipefd);
+    assert(ret == 0); // For real usage put proper check here
+    m_receiveFd = pipefd[0];
+    m_sendFd = pipefd[1];
+    fcntl(m_sendFd, F_SETFL, O_NONBLOCK);
+}
+
+
+NotifyPipe::~NotifyPipe()
+{
+    close(m_sendFd);
+    close(m_receiveFd);
+}
+
+
+int NotifyPipe::receiverFd()
+{
+    return m_receiveFd;
+}
+
+
+void NotifyPipe::notify()
+{
+    write(m_sendFd, "1", 1);
+}
diff --git a/trunk/src/Place.cpp b/trunk/src/Place.cpp
new file mode 100644
index 0000000..a2a36b0
--- /dev/null
+++ b/trunk/src/Place.cpp
@@ -0,0 +1,9 @@
+#include "Place.hpp"
+
+using namespace redthread;
+
+Place::Place(const std::string& pubKey, const IdentityId& owner)
+    : mPubKey {pubKey}, mOwner {owner}
+{
+
+}
diff --git a/trunk/src/QtUserConfigModel.cpp b/trunk/src/QtUserConfigModel.cpp
new file mode 100644
index 0000000..fb6b96c
--- /dev/null
+++ b/trunk/src/QtUserConfigModel.cpp
@@ -0,0 +1,44 @@
+#include "QtUserConfigModel.hpp"
+
+using namespace redthread;
+
+QtUserConfigModel::QtUserConfigModel(QObject* parent)
+    : QAbstractItemModel(parent), AbstractUserConfigModel()
+{
+
+}
+
+QtUserConfigModel::~QtUserConfigModel()
+{
+
+}
+
+int QtUserConfigModel::columnCount(const QModelIndex & parent) const
+{
+    // FIXME
+    return 0;
+}
+
+QVariant QtUserConfigModel::data(const QModelIndex & index, int role) const
+{
+    // FIXME
+    return {};
+}
+
+QModelIndex QtUserConfigModel::index(int row, int column, const QModelIndex & parent) const
+{
+    // FIXME
+    return {};
+}
+
+QModelIndex QtUserConfigModel::parent(const QModelIndex & index) const
+{
+    // FIXME
+    return {};
+}
+
+int QtUserConfigModel::rowCount(const QModelIndex & parent) const
+{
+    // FIXME
+    return 0;
+}
diff --git a/trunk/src/RedThreadQt.cpp b/trunk/src/RedThreadQt.cpp
new file mode 100644
index 0000000..63e0ca8
--- /dev/null
+++ b/trunk/src/RedThreadQt.cpp
@@ -0,0 +1,40 @@
+// RedThread.cpp
+//
+// author: lurchi
+// date: 2016-02-01
+
+#include "RedThreadQt.hpp"
+#include <QApplication>
+
+using namespace redthread;
+
+RedThreadQt::RedThreadQt(int argc, char** argv)
+    : mView {new SecushareQtView(argc, argv)},
+      mController {mView, "redthread", "0.1", "/home/christian/.config/gnunet.conf"}
+{
+    auto view = mView.get();
+    auto controller = &mController;
+
+    QApplication::connect(view, &SecushareQtView::shutdownRequest, controller, &SecushareQtController::shutdown); 
+}
+
+RedThreadQt::~RedThreadQt()
+{
+    if(mControlThread.get_id() != std::thread::id {})
+    {
+        mControlThread.join();
+    }
+}
+
+int RedThreadQt::run()
+{
+    mControlThread = std::thread {&SecushareQtController::run, &mController};
+ 
+    /**
+     * FIXME:
+     * is there a race condition with GNUNET_SCHEDULER_run setting signal handlers?
+     */
+    int exitCode {mView->run()};
+
+    return exitCode;
+}
diff --git a/trunk/src/SecushareQtController.cpp b/trunk/src/SecushareQtController.cpp
new file mode 100644
index 0000000..512cc67
--- /dev/null
+++ b/trunk/src/SecushareQtController.cpp
@@ -0,0 +1,44 @@
+// SecushareQtController.cpp
+//
+// author: lurchi
+// date: 2016-02-01
+
+#include "SecushareQtController.hpp"
+
+using namespace redthread;
+
+SecushareQtController::SecushareQtController(std::shared_ptr<SecushareQtView> view,
+                                             const std::string& appName,
+                                             const std::string& appVersion,
+                                             const std::string& configPath,
+                                             QObject* parent)
+    : QObject(parent),
+      AbstractSecushareController(view, appName, appVersion, configPath)
+{
+    
+}
+
+SecushareQtController::~SecushareQtController()
+{
+
+}
+
+void SecushareQtController::shutdown()
+{
+    AbstractSecushareController::shutdown();
+}
+
+void SecushareQtController::addEgo(const std::string& name)
+{
+    AbstractSecushareController::addEgo(name);
+}
+
+void SecushareQtController::addFriend(const std::string& nymPubKey, const std::string& name)
+{
+    AbstractSecushareController::addFriend(nymPubKey, name);
+}
+
+void SecushareQtController::sendMessage(const PlaceId& placeId, const std::string& message)
+{
+    AbstractSecushareController::sendMessage(placeId, message);
+}
diff --git a/trunk/src/SecushareQtView.cpp b/trunk/src/SecushareQtView.cpp
new file mode 100644
index 0000000..2253d58
--- /dev/null
+++ b/trunk/src/SecushareQtView.cpp
@@ -0,0 +1,77 @@
+// SecushareQtView.cpp
+//
+// author: lurchi
+// date: 2016-02-01
+
+#include "SecushareQtView.hpp"
+#include "config.h"
+#include <signal.h>
+#include <QQuickView>
+#include <QQuickItem>
+#include <QQmlEngine>
+
+using namespace redthread;
+
+Util::NotifyPipe SecushareQtView::shutdownPipe {};
+
+SecushareQtView::SecushareQtView(int argc, char** argv)
+    : QObject(),
+      AbstractSecushareView(),
+      mArgc {argc},
+      mArgv {argv},
+      mUserConfigModel {new QtUserConfigModel()}
+{
+    std::cout << "SecushareQtView ctor" << std::endl;
+}
+
+SecushareQtView::~SecushareQtView()
+{
+
+}
+
+void SecushareQtView::catchUnixSignals(
+    const std::vector<int>& quitSignals,
+    const std::vector<int>& ignoreSignals
+)
+{
+    sigNotifier = new QSocketNotifier(shutdownPipe.receiverFd(), QSocketNotifier::Read, nullptr);
+    QApplication::connect(sigNotifier, &QSocketNotifier::activated, &QApplication::quit);
+
+    auto handler = [](int sig) -> void
+    {
+        shutdownPipe.notify();
+    };
+    
+    // all these signals will be ignored.
+    for(int sig : ignoreSignals)
+    {
+        signal(sig, SIG_IGN);
+    }
+    
+    // each of these signals calls the handler (quits the QCoreApplication).
+    for(int sig : quitSignals)
+    {
+        signal(sig, handler);
+    }
+}
+
+int SecushareQtView::run()
+{
+    QApplication app(mArgc, mArgv);
+
+    QObject::connect(&app, &QApplication::aboutToQuit, this, &SecushareQtView::shutdownRequest);
+
+    catchUnixSignals({SIGQUIT, SIGINT, SIGTERM, SIGHUP});
+
+    QQuickView view (QUrl::fromLocalFile(QML_DIR "/application.qml"));
+    QObject* root = view.rootObject();
+    QQmlEngine *engine = QtQml::qmlEngine(root);
+    //QObject::connect(root, SIGNAL(shutdownButtonClicked()), this, SIGNAL(shutdownRequest()));
+    QObject::connect(engine, SIGNAL(quit()), this, SIGNAL(shutdownRequest()));
+    QObject::connect(engine, SIGNAL(quit()), &app, SLOT(quit()));
+
+    //view.setSource(QUrl::fromLocalFile(QML_DIR "/application.qml"));
+    view.show();
+    
+    return app.exec();
+}
diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp
new file mode 100644
index 0000000..d505293
--- /dev/null
+++ b/trunk/src/main.cpp
@@ -0,0 +1,21 @@
+// main.cpp
+//
+// author: lurchi
+// date: 2016-02-01
+
+#include "RedThreadQt.hpp"
+#include <iostream>
+
+int main(int argc, char** argv)
+{
+    using namespace redthread;
+
+    std::cout << "red thread" << std::endl;   
+
+    RedThreadQt app {argc, argv};
+    int exitCode {app.run()};
+
+    std::cout << "exiting with code " << exitCode << std::endl;
+
+    return exitCode;
+}