perfect_programs.tar

perfect_programs/0000775000175200017500000000000012044520610015172 5ustar  maximalovmaximalovperfect_programs/zlib_compdecomp/0000775000175200017500000000000012044520417020345 5ustar  maximalovmaximalovperfect_programs/zlib_compdecomp/zlib_unbuffered.cc0000664000175200017500000000351412044517735024035 0ustar  maximalovmaximalov/*! @file zlib_unbuffered.cc
 *  @brief Implementation of the fast compression/decompression with Zlib.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */



#include "src/lib/common/zlib_unbuffered.h"
#include <assert.h>
#include <zlib.h>
#include "include/common.h"

namespace Zlib {

float compress_unbuffered(const void *inData, size_t inDataSize,
                         std::vector<char> *outData) {
  assert(outData != nullptr);

  z_stream strm;
  strm.zalloc = 0;
  strm.zfree = 0;
  strm.opaque = 0;
  strm.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(inData));
  strm.avail_in = inDataSize;

  deflateInit(&strm, Z_BEST_COMPRESSION);
  int bound = deflateBound(&strm, inDataSize);
  outData->resize(bound);
  strm.next_out = reinterpret_cast<Bytef *>(&(*outData)[0]);
  strm.avail_out = bound;

  int res = deflate(&strm, Z_FINISH);
  assert(res == Z_STREAM_END);
  res = deflateEnd(&strm);
  assert(res == Z_OK);

  outData->resize(strm.total_out);
  return (strm.total_out + .0f) / inDataSize;
}

void decompress_unbuffered(const void *inData, size_t inDataSize,
                           std::vector<char> *outData) {
  assert(outData != nullptr);

  z_stream strm;
  strm.zalloc = 0;
  strm.zfree = 0;
  strm.opaque = 0;
  strm.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(inData));
  strm.avail_in = inDataSize;
  strm.next_out = reinterpret_cast<Bytef *>(&(*outData)[0]);
  strm.avail_out = outData->size();

  inflateInit(&strm);
  int res = inflate(&strm, Z_FINISH);
  assert(res == Z_STREAM_END);
  res = inflateEnd(&strm);
  assert(res == Z_OK);
}

}  // namespace Zlib

perfect_programs/zlib_compdecomp/tests/0000775000175200017500000000000012044520421021502 5ustar  maximalovmaximalovperfect_programs/zlib_compdecomp/tests/zlib_unbuffered.cc0000664000175200017500000000665012044520421025165 0ustar  maximalovmaximalov/*! @file zlib_unbuffered.cc
 *  @brief Tests for zlib_unbuffered compression/decompression.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include <string.h>
#include <zlib.h>
#include "src/lib/common/zlib_unbuffered.h"
#include "tests/google/gtest/gtest.h"

const char data[] = "Как известно, для нормальной работы большинство софта "
    "должно быть не только скомпилировано, но и правильно установлено в "
    "системе. Программы ожидают найти нужные им файлы в определённых местах,"
    " и места эти в большинстве *nix-систем зашиты в код на этапе компиляции."
    " Помимо этого аспекта основным отличием процесса установки в "
    "linux/freebsd/whatever от таковой в Windows и MacOS является то, что "
    "программа не просто складывает кучу файлов в отдельную директорию в "
    "Program Files или /Applications, а «размазывает» себя по всей файловой "
    "системе. Библиотеки идут в lib, исполняемые файлы в bin, конфиги в etc, "
    "разного рода данные в var и так далее. Если вам вдруг понадобится её "
    "обновить, то всё это надо сначала как-то вычистить, т. к. при "
    "использовании новой версии остатки файлов от старой могут привести к "
    "совершенно непредсказуемым последствиям, зачастую нехорошим. "
    "Вероятность этого события не так велика, но оно вам надо на "
    "боевом сервере?";

TEST(Zlib, compress_unbuffered) {
  std::vector<char> compressed;
  Zlib::compress_unbuffered(data, sizeof(data), &compressed);
  auto dest = new Bytef[sizeof(data)];
  uLongf len = sizeof(data);
  uncompress(dest, &len, reinterpret_cast<Bytef *>(&compressed[0]),
             compressed.size());
  ASSERT_EQ(len, sizeof(data));
  ASSERT_EQ(memcmp(data, dest, sizeof(data)), 0);
  delete[] dest;
}

TEST(Zlib, decompress_unbuffered) {
  auto dest = new Bytef[sizeof(data)];
  uLongf len = sizeof(data);
  compress(dest, &len,
           const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data)),
           sizeof(data));
  std::vector<char> original(sizeof(data));
  Zlib::decompress_unbuffered(dest, len, &original);
  ASSERT_EQ(original.size(), sizeof(data));
  ASSERT_EQ(memcmp(data, &original[0], sizeof(data)), 0);
}

TEST(Zlib, compress_decompress) {
  std::vector<char> compressed;
  Zlib::compress_unbuffered(data, sizeof(data), &compressed);
  std::vector<char> original(sizeof(data));
  Zlib::decompress_unbuffered(&compressed[0], compressed.size(), &original);
  ASSERT_EQ(original.size(), sizeof(data));
  ASSERT_EQ(memcmp(data, &original[0], sizeof(data)), 0);
}

#include "tests/google/src/gtest_main.cc"

perfect_programs/zlib_compdecomp/zlib_unbuffered.h0000664000175200017500000000150212044517713023666 0ustar  maximalovmaximalov/*! @file zlib_unbuffered.h
 *  @brief Efficient compression/decompression with Zlib.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */



#ifndef SRC_LIB_COMMON_ZLIB_UNBUFFERED_H_
#define SRC_LIB_COMMON_ZLIB_UNBUFFERED_H_

#include <stddef.h>
#include <vector>

namespace Zlib {

float compress_unbuffered(const void *inData, size_t inDataSize,
                          std::vector<char> *outData);

void decompress_unbuffered(const void *inData, size_t inDataSize,
                           std::vector<char> *outData);

}  // namespace Zlib

#endif  // SRC_LIB_COMMON_ZLIB_UNBUFFERED_H_

perfect_programs/dbus_duplex/0000775000175200017500000000000012044520271017513 5ustar  maximalovmaximalovperfect_programs/dbus_duplex/dbus_duplex.h0000664000175200017500000002444112044517232022212 0ustar  maximalovmaximalov/*! @file dbus_duplex.h
 *  @brief DBus duplex connection implementation.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>, Moiseenko Andrey <moiseenko.a@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 *
 *  @section Usage
 *  #define PEER_MASTER 1
 *
 *  class Foo {
 *   public:
 *    void MyMethod(int x, std::string y) {
 *      std::cout <<  x << y << std::endl;
 *    }
 *
 *    int OtherMethod() {
 *      return 7;
 *    }
 *
 *    Foo() {
 *      DBusInterface interface("com.samsung.vconf.Foo");
 *      interface.AddHandler("MyMethod", Callback<void, int, std::string>(
 *                           std::bind(&Foo::MyMethod,
 *                                     this,
 *                                     std::placeholders::_1,
 *                                     std::placeholders::_2)))
 *               .AddHandler("OtherMethod", Callback<void>(
 *                           std::bind(&Foo::OtherMethod,
 *                                     this)));
 *      duplex_ = std::unique_ptr<DBusDuplex>(new DBusDuplex(interface));
 *      duplex_.AddPeer(PEER_MASTER, "com.samsung.vconf.Master");
 *    }
 *   private:
 *    std::unique_ptr<DBusDuplex> duplex_;
 *
 *    void MyLogic() {
 *      duplex_->Call(PEER_MASTER, "MasterMethod", "hello");
 *    }
 *  };
 *
 *  ...
 *
 *  void Master::MyMethodOnFoo() {
 *    duplex->Call(PEER_FOO, "MyMethod", 2, std::string("master"));
 *  }
 */

#ifndef SRC_LIB_COMMON_DBUS_DUPLEX_H_
#define SRC_LIB_COMMON_DBUS_DUPLEX_H_

#include <giomm.h>
#include <atomic>
#include <mutex>
#include <algorithm>
#include <memory>
#include <string>
#include <vector>
#include "include/eina_logger.h"
#include "src/lib/common/dbus_interface.h"

namespace Conference {

class GioObject {
 private:
  static bool gioIsInitialized;
  static std::mutex mutex_;
 public:
  GioObject();
};

typedef  void (*on_method_call_func_type)(
    const Glib::RefPtr<Gio::DBus::Connection>&,
    const Glib::ustring&, const Glib::ustring&,
    const Glib::ustring&, const Glib::ustring&,
    const Glib::VariantContainerBase&,
    const Glib::RefPtr<Gio::DBus::MethodInvocation>&);

struct DBusServerParameters {
  guint name_id_;
  guint registered_id_;
  GDBusConnection *connection_;
  std::shared_ptr<GDBusNodeInfo> introspection_data_;
  GDBusInterfaceVTable interface_vtable_;
  const char *path_;
  DBusInterface interface_;

  explicit DBusServerParameters(const DBusInterface &interface,
                                GDBusInterfaceMethodCallFunc on_method_call)
  : name_id_(0)
  , registered_id_(0)
  , connection_(nullptr)
  , path_(nullptr)
  , interface_(interface) {
    interface_vtable_.method_call = on_method_call;
  }
};

/// @brief Implementation of the thread-safe methods invocation using D-Bus
/// as the backend. This class hides all the D-Bus setup complexity from the
/// user and provides a simple interface. It takes an instance of DBusInterface
/// to initialize. To enable calling functions from remote peers one must
/// execute AddPeer(). Then, Call/CallAndWait become accessible.
/// @note Remember that there always should be a running Glib main loop
/// to make everything work. It is a good idea to ensure the complete D-Bus
/// registration with WaitForRegistration() before actually using the
/// class functionality.
class DBusDuplex
: public EinaLogger
, public GioObject {
 public:
  /// @brief Initializes a new instance of the DBusDuplex class.
  /// @param interface The D-Bus interface description.
  explicit DBusDuplex(const DBusInterface &interface);

  virtual ~DBusDuplex();

  /// @brief Blocks the calling thread until the D-Bus registration started
  /// asynchronously in the class constructor is complete.
  /// @return True if registration was successfull; otherwise, false.
  /// @note Usually, when the registration fails, an exception is thrown
  /// in the Glib main loop context.
  bool WaitForRegistration();

  /// @brief Adds the specified D-Bus path as a possible callee.
  /// @param id The remote peer id (set to any unique integer you like).
  /// @param dbusPath Path
  /// @return Reference to this class instance.
  DBusDuplex &AddPeer(int id, const std::string &dbusPath);

  /// @brief Adds the variable length list of D-Bus paths as a single callee.
  /// @param id The remote peer id (set to any unique integer you like).
  /// @param dbusPaths the list of strings corresponding to D-Bus paths.
  /// @note This overridden method allows to invoke callbacks in
  /// a broadcast way.
  /// @return Reference to this class instance.
  DBusDuplex &AddPeer(int id, std::initializer_list<const char *> dbusPaths);

  /// @brief Invokes a remote function asynchronously.
  /// @param id The remote peer id (the same as passed in AddPeer()).
  /// @param name The function name.
  /// @param args The arbitrary set of function arguments.
  template<typename... Args>
  void Call(int id, const std::string &name,
            Args... args) {
    assert(is_registered_ && "Not registered in D-Bus");
    CheckPeer(id);
    auto packedParameters = PackIntoVariantContainer(args...);
    if (peers_[id].size() > 1) {
      DBG("\033[35;1m%s\033[0m\n(id = %d, args count is %d, "
          "peers count is %d)",
          name.c_str(), id, sizeof...(Args), peers_[id].size());
    } else {
      DBG("\033[35;1m%s\033[0m @%s%s", name.c_str(),
          peers_[id][0]->get_name().c_str(),
          g_variant_get_type_string(packedParameters.gobj()));
    }
    for (auto ptr = peers_[id].begin(); ptr != peers_[id].end(); ++ptr) {
      activeCalls_++;
      if (peers_[id].size() > 1) {
        DBG("Calling %s%s", (*ptr)->get_name().c_str(),
            g_variant_get_type_string(packedParameters.gobj()));
      }
      auto userData = new AsyncCallParameters { this, packedParameters.gobj() };
      g_dbus_proxy_call((*ptr)->gobj(), name.c_str(),
                        // Ensure that this variant will not be disposed
                        // on next iteration / loop exit
                        packedParameters.gobj_copy(),
                        G_DBUS_CALL_FLAGS_NONE, -1,
                        nullptr, on_async_ready, userData);
    }
  }

  /// @brief Blocks the calling thread until there are no more active
  /// asynchronous invocations started with Call().
  /// @note The last invocation result can be obtained with LastResult().
  void Wait();

  /// @brief Invokes a remote function synchronously.
  /// @param id The remote peer id (the same as passed in AddPeer()).
  /// @param name The function name.
  /// @param args The arbitrary set of function arguments.
  /// @return The std::vector instance containing the result for
  /// each peer path. Usually, AddPeer() is called with a single D-Bus path,
  /// so this vector contains the single value. It can be unboxed with
  /// GetResult().
  template<typename... Args>
  std::vector<Glib::VariantContainerBase> CallAndWait(int id,
                                                      const std::string &name,
                                                      Args... args) {
    assert(is_registered_ && "Not registered in D-Bus");
    assert(!g_main_context_is_owner(g_main_context_default()) &&
           "Shooting yourself in the foot");
    CheckPeer(id);
    auto packedParameters = PackIntoVariantContainer(args...);
    if (peers_[id].size() > 1) {
      DBG("\033[35;1m%s\033[0m\n(id = %d, args count is %d, "
          "peers count is %d)",
          name.c_str(), id, sizeof...(Args), peers_[id].size());
    } else {
      DBG("\033[35;1m%s\033[0m @%s%s", name.c_str(),
          peers_[id][0]->get_name().c_str(),
          g_variant_get_type_string(packedParameters.gobj()));
    }
    std::vector<Glib::VariantContainerBase> results;
    for (auto ptr = peers_[id].begin(); ptr != peers_[id].end(); ++ptr) {
      try {
        if (peers_[id].size() > 1) {
          DBG("Calling %s%s", (*ptr)->get_name().c_str(),
              g_variant_get_type_string(packedParameters.gobj()));
        }
        auto res = (*ptr)->call_sync(name.c_str(), packedParameters);
        results.push_back(res);
      }
      catch(const Glib::Error &e) {
        ERR("Caught an instance of the Glib::Error exception: %s",
            e.what().c_str());
        throw e;
      }
    }
    return results;
  }

  /// @brief Returns the last result from the invocation performed with Call().
  template <class T>
  T LastResult() {
    assert(is_registered_ && "Not registered in D-Bus");
    std::lock_guard<std::mutex> lock(asyncResultMutex_);
    return GetResult<T>(asyncResult_);
  }

 private:
  struct AsyncCallParameters {
    DBusDuplex *self;
    GVariant *callArgs;
  };

  DBusServerParameters parameters_;
  std::unordered_map<int, std::vector<Glib::RefPtr<Gio::DBus::Proxy> > > peers_;
  std::unordered_map<std::string, Glib::RefPtr<Gio::DBus::Proxy> > proxyCache_;
  std::mutex blocker_;
  std::mutex asyncResultMutex_;
  std::atomic<bool> is_registered_;
  std::atomic<bool> failed_to_register_;
  std::atomic<int> activeCalls_;
  Glib::VariantContainerBase asyncResult_;

  static void on_async_ready(GObject *source_object,
                             GAsyncResult *res,
                             gpointer selfptr);

  static void on_bus_acquired(GObject *source_object,
                              GAsyncResult *res,
                              gpointer selfptr);

  static void on_name_acquired(GDBusConnection *connection,
                               const gchar *name,
                               gpointer selfptr);

  static void on_name_lost(
      GDBusConnection *connection,
      const gchar *name,
      gpointer selfptr);

  static void on_method_call(GDBusConnection       *connection,
                             const gchar           *sender,
                             const gchar           *object_path,
                             const gchar           *interface_name,
                             const gchar           *method_name,
                             GVariant              *parameters,
                             GDBusMethodInvocation *invocation,
                             gpointer               selfptr);

  /// @brief Checks whether the specified peer identifier is valid.
  void CheckPeer(int id);
};

}  // namespace Conference
#endif  // SRC_LIB_COMMON_DBUS_DUPLEX_H_

perfect_programs/dbus_duplex/dbus_duplex.cc0000664000175200017500000002763512044517252022362 0ustar  maximalovmaximalov/*! @file dbus_duplex.cc
 *  @brief DBus duplex connection implementation.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "src/lib/common/dbus_duplex.h"
#include <algorithm>

namespace Conference {

bool GioObject::gioIsInitialized = false;

std::mutex GioObject::mutex_;

GioObject::GioObject() {
  std::lock_guard<std::mutex> lock(mutex_);
  if (!gioIsInitialized) {
    Gio::init();
    gioIsInitialized = true;
  }
}

DBusDuplex::DBusDuplex(const DBusInterface &interface)
: EinaLogger("dbus_" + interface.name(),
             DBUSDUPLEX_LOG_COLOR)
, parameters_(interface, on_method_call)
, is_registered_(false)
, failed_to_register_(false)
, activeCalls_(0) {
  // Prepare the introspection data
  std::string ixml = parameters_.interface_.description();
  std::string path = parameters_.interface_.name();
  parameters_.path_ = path.c_str();
  GError *gerror = nullptr;
  parameters_.introspection_data_ = std::shared_ptr<GDBusNodeInfo>(
      g_dbus_node_info_new_for_xml(ixml.c_str(), &gerror),
      std::ptr_fun(g_dbus_node_info_unref));
  if (gerror != nullptr) {
    ERR("Caught an instance of the Glib::Error exception: %s",
        gerror->message);
    Glib::Error::throw_exception(gerror);
  }

  // Acquire the connection asynchronously
  g_bus_get(G_BUS_TYPE_SESSION, nullptr, on_bus_acquired, this);
}

DBusDuplex::~DBusDuplex() {
  if (is_registered_) {
    // Ensure that all D-Bus outgoing calls are dispatched
    DBG("g_dbus_connection_flush_sync()");
    GError *gerror = nullptr;
    g_dbus_connection_flush_sync(parameters_.connection_, nullptr, &gerror);
    if (gerror != nullptr) {
      ERR("Caught an instance of the Glib::Error exception: %s",
          gerror->message);
      Glib::Error::throw_exception(gerror);
    }
    // Unregister the interface
    DBG("g_dbus_connection_unregister_object(), id = %d",
        parameters_.registered_id_);
    g_dbus_connection_unregister_object(parameters_.connection_,
                                        parameters_.registered_id_);
    parameters_.registered_id_ = 0;
    // Ensure that all D-Bus async calls are completed
    Wait();
    // Poison this instance while destroying
    failed_to_register_ = true;
    is_registered_ = false;
    // Unregister the name
    DBG("g_bus_unown_name(\"%s\")", parameters_.interface_.name().c_str());
    g_bus_unown_name(parameters_.name_id_);
    parameters_.name_id_ = 0;
    // We should wait until on_name_lost is fired here...
    // But it never does. So just believe in the shiny future.
  }
}

bool DBusDuplex::WaitForRegistration() {
  if (!failed_to_register_ && !is_registered_) {
    blocker_.lock();
    if (!failed_to_register_ && !is_registered_) {
      assert(!g_main_context_is_owner(g_main_context_default()) &&
             "Shooting yourself in the foot");
      DBG("Blocked until the registration is complete");
      blocker_.lock();
      blocker_.unlock();
    }
    if (is_registered_) {
      INF("Registered in D-Bus");
    } else {
      assert(failed_to_register_);
      ERR("Failed to register in D-Bus");
    }
  }
  return is_registered_;
}

DBusDuplex &DBusDuplex::AddPeer(int id, const std::string &dbusPath) {
  Glib::RefPtr<Gio::DBus::Connection> connection =
    Gio::DBus::Connection::get_sync(Gio::DBus::BUS_TYPE_SESSION);
  assert(connection && "Failed to get the connection to "
         "Gio::DBus::BUS_TYPE_SESSION");
  DBG("name = \"%s\", object_path=\"%s\", "
      "interface_name=\"%s\"", dbusPath.c_str(),
      GetObjectPath(dbusPath).c_str(),
      dbusPath.c_str());
  assert(g_dbus_is_name(dbusPath.c_str()) &&
         "The specified D-Bus path is invalid");
  if (peers_.find(id) != peers_.end()) {
    DBG("Appending \"%s\" to peer ID %d", dbusPath.c_str(), id);
  }
  Glib::RefPtr<Gio::DBus::Proxy> proxy;
  if (proxyCache_.find(dbusPath) != proxyCache_.end()) {
    DBG("Cache hit");
    proxy = proxyCache_[dbusPath];
  } else {
    DBG("Cache miss, create_sync()");
    proxy = Gio::DBus::Proxy::create_sync(connection,
                                          dbusPath,
                                          GetObjectPath(dbusPath).c_str(),
                                          dbusPath);
    if (!proxy) {
      ERR("Failed to create_sync()");
      // TODO(v.markovtsev): handle this error
    }
    proxyCache_.insert(std::make_pair(dbusPath, proxy));
  }
  peers_[id].push_back(proxy);
  return *this;
}

DBusDuplex &DBusDuplex::AddPeer(int id,
                                std::initializer_list<const char *>dbusPaths) {
  assert(dbusPaths.size() > 0 &&"Need at least one D-Bus path");
  Glib::RefPtr<Gio::DBus::Connection> connection =
    Gio::DBus::Connection::get_sync(Gio::DBus::BUS_TYPE_SESSION);
  assert(connection && "Failed to get the connection to "
         "Gio::DBus::BUS_TYPE_SESSION");
  if (peers_.find(id) != peers_.end()) {
    DBG("Appending to peer ID %d", id);
  }
  for (auto dbusPath = dbusPaths.begin(); dbusPath != dbusPaths.end();
      ++dbusPath) {
    std::string objectPath(GetObjectPath(*dbusPath));
    DBG("name = \"%s\", object_path=\"%s\", "
        "interface_name=\"%s\"", *dbusPath, objectPath.c_str(),
        *dbusPath);
    assert(g_dbus_is_name(*dbusPath) && "The specified D-Bus path is invalid");
    Glib::RefPtr<Gio::DBus::Proxy> proxy;
    if (proxyCache_.find(*dbusPath) != proxyCache_.end()) {
      DBG("Cache hit");
      proxy = proxyCache_[*dbusPath];
    } else {
      DBG("Cache miss, create_sync()");
      proxy = Gio::DBus::Proxy::create_sync(connection,
                                            *dbusPath,
                                            objectPath.c_str(),
                                            *dbusPath);
      if (!proxy) {
        ERR("Failed to create_sync()");
        // TODO(v.markovtsev): handle this error
      }
      proxyCache_.insert(std::make_pair(*dbusPath, proxy));
    }
    peers_[id].push_back(proxy);
  }
  return *this;
}

void DBusDuplex::Wait() {
  assert(is_registered_ && "Not registered in D-Bus");
  if (activeCalls_ > 0) {
    blocker_.lock();
    if (activeCalls_ == 0) {
      blocker_.unlock();
    } else {
      DBG("Blocked (%i active calls)", activeCalls_.load());
      blocker_.lock();
      blocker_.unlock();
      DBG("Resumed");
    }
  }
}

void DBusDuplex::on_async_ready(GObject *source_object
                                __attribute__((unused)),
                                GAsyncResult *res,
                                gpointer user_data) {
  assert(user_data);
  auto acp = reinterpret_cast<AsyncCallParameters *>(user_data);
  auto self = acp->self;
  // Free the call parameters
  g_variant_unref(acp->callArgs);
  delete acp;

  GError *error = nullptr;
  auto resultVariant = g_dbus_proxy_call_finish(
      reinterpret_cast<GDBusProxy *>(source_object), res, &error);
  if (error != nullptr) {
    ERRI(self, "Caught an instance of the Glib::Error exception: %s",
        error->message);
    Glib::Error::throw_exception(error);
  }
  {
    std::lock_guard<std::mutex> lock(self->asyncResultMutex_);
    self->asyncResult_ = Glib::VariantContainerBase(resultVariant);
  }
  int localCalls = --self->activeCalls_;
  if (localCalls == 0) {
    self->blocker_.unlock();
  }
  DBGI(self, "%i pending active calls",
       localCalls);
}

void DBusDuplex::on_bus_acquired(GObject *source_object
                                 __attribute__((unused)),
                                 GAsyncResult *res,
                                 gpointer selfptr) {
  assert(selfptr);
  auto self = reinterpret_cast<DBusDuplex *>(selfptr);
  assert(!self->failed_to_register_ && "DbusDuplex has already been destroyed");

  // Get the connection
  GError *gerror = nullptr;
  self->parameters_.connection_ = g_bus_get_finish(res, &gerror);
  if (gerror != nullptr) {
    ERRI(self, "Caught an instance of the Glib::Error exception: %s.",
         gerror->message);
    self->failed_to_register_ = true;
    self->blocker_.unlock();
    Glib::Error::throw_exception(gerror);
  }

  auto objectPath = GetObjectPath(self->parameters_.path_);
  DBGI(self, "name = \"%s\", object_path = \"%s\", connection = %p",
       self->parameters_.interface_.name().c_str(), objectPath.c_str(),
       self->parameters_.connection_);

  gerror = nullptr;
  self->parameters_.registered_id_ =
      g_dbus_connection_register_object(self->parameters_.connection_,
          objectPath.c_str(),
          self->parameters_.introspection_data_->interfaces[0],
          &self->parameters_.interface_vtable_,
          self, nullptr, &gerror);
  if (gerror != nullptr) {
    ERRI(self, "Caught an instance of the Glib::Error exception: %s.",
         gerror->message);
    self->failed_to_register_ = true;
    self->blocker_.unlock();
    Glib::Error::throw_exception(gerror);
  }
  DBGI(self, "Registered object id = %d",
       self->parameters_.registered_id_);

  DBGI(self, "g_bus_own_name_on_connection(), path = \"%s\"",
       self->parameters_.path_);
  self->parameters_.name_id_ = g_bus_own_name_on_connection(
      self->parameters_.connection_,
      self->parameters_.path_,
      G_BUS_NAME_OWNER_FLAGS_NONE,
      on_name_acquired,
      on_name_lost,
      self, nullptr);
}

void DBusDuplex::on_name_acquired(GDBusConnection *connection
                                  __attribute__((unused)),
                                  const gchar *name,
                                  gpointer selfptr) {
  assert(selfptr);
  auto self = reinterpret_cast<DBusDuplex *>(selfptr);
  DBGI(self, "name = \"%s\"", name);
  self->is_registered_ = true;
  self->blocker_.unlock();
}

void DBusDuplex::on_name_lost(GDBusConnection *connection,
                              const gchar *name,
                              gpointer selfptr) {
  assert(selfptr);
  auto self = reinterpret_cast<DBusDuplex *>(selfptr);
  self->is_registered_ = false;
  self->parameters_.name_id_ = 0;
  if (self->parameters_.registered_id_ > 0) {
    DBGI(self, "unregister_object(), name = \"%s\", id = %d",
         name, self->parameters_.registered_id_);
    g_dbus_connection_unregister_object(connection,
                                        self->parameters_.registered_id_);
    self->parameters_.registered_id_ = 0;
  }
}

void DBusDuplex::on_method_call(GDBusConnection *connection
                                __attribute__((unused)),
                                const gchar *sender,
                                const gchar *object_path,
                                const gchar *interface_name,
                                const gchar *method_name,
                                GVariant *parameters,
                                GDBusMethodInvocation *invocation,
                                gpointer selfptr) {
  assert(selfptr);
  auto self = reinterpret_cast<DBusDuplex *>(selfptr);
  DBGI(self,
       "\033[45m\033[37;1m%s\033[0m enter\n"
       "(sender = \"%s\", object_path = \"%s\""
       ", interface_name = \"%s\", signature = %s)",
       method_name, sender, object_path, interface_name,
       g_variant_get_type_string(parameters));
  assert(self->is_registered_ && "Not registered in D-Bus");
  Glib::VariantContainerBase result;
  try {
    result = self->parameters_
        .interface_[method_name](Glib::VariantContainerBase(parameters, true));
  } catch(const UnknownMethodException  &e) {
    Glib::Error error(G_DBUS_ERROR, Gio::DBus::Error::UNKNOWN_METHOD,
                    "The requested method is not registered");
    g_dbus_method_invocation_return_gerror(invocation, error.gobj());
    return;
  }
  g_dbus_method_invocation_return_value(invocation, result.gobj());
  DBGI(self, "\033[45m\033[37;1m%s\033[0m return", method_name);
}

void DBusDuplex::CheckPeer(int id) {
  if (peers_.find(id) == peers_.end()) {
    ERR("Could not find the peer %d", id);
    // TODO(v.markovtsev): throw exception here
  }
}

}  // namespace Conference

perfect_programs/dbus_duplex/tests/0000775000175200017500000000000012044520323020653 5ustar  maximalovmaximalovperfect_programs/dbus_duplex/tests/dbus_duplex.cc0000664000175200017500000002422112044520274023506 0ustar  maximalovmaximalov/*! @file dbus_duplex.cc
 *  @brief Tests for DBusDuplex.
 *  @author Moiseenko Andrey <moiseenko.a@samsung.com>, Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include <thread>
#include <atomic>
#include <random>
#include <algorithm>
#include <functional>
#include "tests/google/gtest/gtest.h"
#include "src/lib/common/dbus_duplex.h"

using Conference::DBusDuplex;
using Conference::DBusInterface;
using Conference::Callback;
using Conference::GetResult;

enum StringTypes {
  kStringTypeBad,
  kStringTypeGood
};

class MyPeer1 {
 public:
  std::unique_ptr<DBusDuplex> duplex;
  int Step;
  bool Fail;
  int ChkSum;

  void IntMethod(int x) {
    Step += x;
  }

  void UnsignedMethod(void* /*ptr*/,
                      unsigned val) {
    ChkSum = val;
  }

  int ReturnMethod(std::string str, std::string *strptr, StringTypes type) {
    if (type == kStringTypeGood && str == *strptr) {
      return str.size();
    } else {
      return 0;
    }
  }

  void SerialMethod(int x) {
    if (Step == x - 1) {
      Step = x;
    } else {
      Fail = true;
    }
  }

  void CriticalMethod() {
    if (critical_) {
      Fail = true;
    }
    critical_ = true;
    auto myrand = std::bind(std::uniform_real_distribution<>(),
                          std::mt19937());
    Step = myrand();
    Step /= 7;
    Step += 5;
    if (Step > 1000) {
      Step = (std::sqrt(Step) * 3 + 101) / 1.5;
    } else {
      Step = (std::sqrt(Step) * 3.1 + 102) / 1.55;
    }
    critical_ = false;
  }

  void ComplexMethod(int flag, const void *buffer, guint bufferLength) {
    ChkSum = CalcChkSum(buffer, bufferLength) + flag;
  }

  static int CalcChkSum(const void *buffer, guint bufferLength) {
    int res = 0;
    auto chbuf = reinterpret_cast<const char *>(buffer);
    for (guint i = 0; i < bufferLength; i++) {
      res ^= chbuf[i];
    }
    return res;
  }

  MyPeer1()
  : Step(0)
  , Fail(false)
  , ChkSum(0)
  , critical_(false) {
    DBusInterface interface("com.samsung.MyPeer1");
    interface.AddHandler("IntMethod",
                         Callback<void, int>(
                           std::bind(&MyPeer1::IntMethod,
                                     this, std::placeholders::_1)))
             .AddHandler("UnsignedMethod",
                         Callback<void, void *, unsigned>(
                           std::bind(&MyPeer1::UnsignedMethod,
                                     this, std::placeholders::_1,
                                     std::placeholders::_2)))
             .AddHandler("ReturnMethod",
                         Callback<int, std::string, std::string *, StringTypes>(
                           std::bind(&MyPeer1::ReturnMethod,
                                     this, std::placeholders::_1,
                                     std::placeholders::_2,
                                     std::placeholders::_3)))
             .AddHandler("CriticalMethod",
                         Callback<void>(
                           std::bind(&MyPeer1::CriticalMethod,
                                     this)))
             .AddHandler("SerialMethod",
                         Callback<void, int>(
                           std::bind(&MyPeer1::SerialMethod,
                                     this, std::placeholders::_1)))
             .AddHandler("ComplexMethod",
                         Callback<void, int, const void *, guint>(
                           std::bind(&MyPeer1::ComplexMethod,
                                     this, std::placeholders::_1,
                                     std::placeholders::_2,
                                     std::placeholders::_3)));
    duplex = std::unique_ptr<DBusDuplex>(new DBusDuplex(interface));
  }

 private:
  std::atomic<bool> critical_;
};

class MyPeer2 {
 public:
  std::unique_ptr<DBusDuplex> duplex;
  int Step;

  void IntMethod(int x) {
    Step += x;
  }

  MyPeer2()
  : Step(0) {
    DBusInterface interface("com.samsung.MyPeer2");
    interface.AddHandler("IntMethod",
                         Callback<void, int>(
                           std::bind(&MyPeer2::IntMethod,
                                     this, std::placeholders::_1)));
    duplex = std::unique_ptr<DBusDuplex>(new DBusDuplex(interface));
  }
};

TEST(DBusDuplex, CallAndWait) {
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  {
    MyPeer1 peer1;
    MyPeer2 peer2;
    peer1.duplex->AddPeer(1, "com.samsung.MyPeer2");
    peer2.duplex->AddPeer(1, "com.samsung.MyPeer1");

    peer1.duplex->WaitForRegistration();
    peer2.duplex->WaitForRegistration();

    for (int i = 0; i < 10; ++i) {
       peer1.duplex->CallAndWait(1, "IntMethod", 1);
       ASSERT_EQ(i + 1, peer2.Step);
       peer2.duplex->CallAndWait(1, "IntMethod", 1);
       ASSERT_EQ(i + 1, peer1.Step);
    }

    std::string str("abcdefghijklmnopqrstuvwxyz");
    int chksum = MyPeer1::CalcChkSum(str.c_str(), str.size()) + 1;
    peer2.duplex->CallAndWait(1, "ComplexMethod", 1, str.c_str(), str.size());
    ASSERT_EQ(chksum, peer1.ChkSum);
  }

  loop->quit();
  main.join();
}

TEST(DBusDuplex, CallAndWaitExoticTypes) {
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  {
    MyPeer1 peer1;
    MyPeer2 peer2;
    peer1.duplex->AddPeer(1, "com.samsung.MyPeer2");
    peer2.duplex->AddPeer(1, "com.samsung.MyPeer1");

    peer1.duplex->WaitForRegistration();
    peer2.duplex->WaitForRegistration();

    peer2.duplex->CallAndWait(
        1,
        "UnsignedMethod",
        reinterpret_cast<void *>(0),
        static_cast<unsigned>(11));
    ASSERT_EQ(11, peer1.ChkSum);
    peer2.duplex->CallAndWait(
        1,
        "UnsignedMethod",
        reinterpret_cast<void *>(0),
        static_cast<unsigned>(29));
    ASSERT_EQ(29, peer1.ChkSum);
    peer2.duplex->Call(
        1,
        "UnsignedMethod",
        reinterpret_cast<void *>(0),
        static_cast<unsigned>(11));
    peer2.duplex->Call(
        1,
        "UnsignedMethod",
        reinterpret_cast<void *>(0),
        static_cast<unsigned>(29));
    peer2.duplex->Wait();
    ASSERT_EQ(29, peer1.ChkSum);
  }

  loop->quit();
  main.join();
}

TEST(DBusDuplex, Call) {
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  {
    MyPeer1 peer1;
    MyPeer2 peer2;
    peer1.duplex->AddPeer(1, "com.samsung.MyPeer2");
    peer2.duplex->AddPeer(1, "com.samsung.MyPeer1");

    peer1.duplex->WaitForRegistration();
    peer2.duplex->WaitForRegistration();

    for (int i = 0; i < 10; ++i) {
       peer1.duplex->Call(1, "IntMethod", 1);
       peer2.duplex->Call(1, "IntMethod", 1);
    }
    peer1.duplex->Wait();
    peer2.duplex->Wait();
    ASSERT_EQ(10, peer1.Step);
    ASSERT_EQ(10, peer2.Step);
  }

  loop->quit();
  main.join();
}

TEST(DBusDuplex, CallAndWaitValue) {
  MyPeer1 peer1;
  MyPeer2 peer2;
  peer1.duplex->AddPeer(1, "com.samsung.MyPeer2");
  peer2.duplex->AddPeer(1, "com.samsung.MyPeer1");

  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  peer1.duplex->WaitForRegistration();
  peer2.duplex->WaitForRegistration();

  std::string str("string");
  auto res = peer2.duplex-> CallAndWait(
      1, "ReturnMethod", str, &str, kStringTypeGood)[0];
  EXPECT_EQ(GetResult<int>(res), str.size());
  loop->quit();
  main.join();
}

TEST(DBusDuplex, CallValue) {
  MyPeer1 peer1;
  MyPeer2 peer2;
  peer1.duplex->AddPeer(1, "com.samsung.MyPeer2");
  peer2.duplex->AddPeer(1, "com.samsung.MyPeer1");

  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  peer1.duplex->WaitForRegistration();
  peer2.duplex->WaitForRegistration();

  std::string str("string");
  peer2.duplex->Call(1, "ReturnMethod", str, &str, kStringTypeGood);
  peer2.duplex->Wait();
  auto res = peer2.duplex->LastResult<int>();
  EXPECT_EQ(res, str.size());
  loop->quit();
  main.join();
}

TEST(DBusDuplex, DuplicatePeers) {
  MyPeer1 peer1;
  MyPeer2 peer2;
  peer1.duplex->AddPeer(1, { "com.samsung.MyPeer2", "com.samsung.MyPeer2" });

  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });

  peer1.duplex->WaitForRegistration();
  peer2.duplex->WaitForRegistration();

  peer1.duplex->CallAndWait(1, "IntMethod", 1);
  EXPECT_EQ(2, peer2.Step);
  loop->quit();
  main.join();
}

TEST(DBusDuplex, Inception) {
  MyPeer1 peer1;
  peer1.duplex->AddPeer(1, "com.samsung.MyPeer1");
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });
  peer1.duplex->WaitForRegistration();
  peer1.duplex->CallAndWait(1, "IntMethod", 10);
  ASSERT_EQ(10, peer1.Step);
  loop->quit();
  main.join();
}

TEST(DBusDuplex, Critical) {
  MyPeer1 peer1;
  peer1.duplex->AddPeer(1, "com.samsung.MyPeer1");
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });
  peer1.duplex->WaitForRegistration();

  std::thread t1([&]() {
    for (int i = 0; i < 100; i++) {
      peer1.duplex->Call(1, "CriticalMethod");
    }
  });
  std::thread t2([&]() {
    for (int i = 0; i < 100; i++) {
      peer1.duplex->Call(1, "CriticalMethod");
    }
  });
  std::thread t3([&]() {
    for (int i = 0; i < 100; i++) {
      peer1.duplex->Call(1, "CriticalMethod");
    }
  });
  t1.join();
  t2.join();
  t3.join();
  peer1.duplex->Wait();
  EXPECT_FALSE(peer1.Fail);
  loop->quit();
  main.join();
}

TEST(DBusDuplex, Serial) {
  MyPeer1 peer1;
  peer1.duplex->AddPeer(1, "com.samsung.MyPeer1");
  auto loop = Glib::MainLoop::create();
  std::thread main([&]() {
    loop->run();
  });
  peer1.duplex->WaitForRegistration();

  for (int i = 0; i < 100; i++) {
    peer1.duplex->Call(1, "SerialMethod", i + 1);
  }
  peer1.duplex->Wait();
  EXPECT_FALSE(peer1.Fail);
  loop->quit();
  main.join();
}

TEST(DBusDuplex, Duplicates) {
  MyPeer1 peer1;
  MyPeer1 peer2;
  auto loop = Glib::MainLoop::create();
  bool exception = false;
  std::thread main([&]() {
    try {
      loop->run();
    }
    catch(const Glib::Error &e) {
      exception = true;
    }
  });
  main.join();
  EXPECT_TRUE(exception);
}

#include "tests/google/src/gtest_main.cc"

perfect_programs/dbus_duplex/tests/dbus_interface.cc0000664000175200017500000000721612044520323024145 0ustar  maximalovmaximalov/*! @file dbus_interface.cc
 *  @brief Tests related to dbus_interface.cc.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */


#include "tests/google/gtest/gtest.h"
#include "src/lib/common/dbus_interface.h"

using namespace Conference;

TEST(IntrospectionBuilder, AddMethod) {
  IntrospectionBuilder builder("com.samsung.Tester");
  builder.AddMethod<gint64, gint16, gint32>("Method1");
  builder.AddMethod<const char *, IntrospectionBuilder *>("Method2");
  auto xml = builder.Build();

  std::string origin("<!DOCTYPE node PUBLIC "
"\"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
"\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
"<node name=\"/com/samsung/Tester\">\n"
"<interface name=\"com.samsung.Tester\">\n"
"<method name=\"Method1\">\n"
"<arg name=\"arg1\" type=\"x\" direction=\"out\" />\n"
"<arg name=\"arg2\" type=\"s\" />\n"
"<arg name=\"arg3\" type=\"i\" />\n"
"</method>\n"
"<method name=\"Method2\">\n"
"<arg name=\"arg1\" type=\"i\" direction=\"out\" />\n"
"<arg name=\"arg2\" type=\"i\" />\n"
"</method>\n"
"</interface>\n"
"</node>");

  ASSERT_STREQ(xml.c_str(), origin.c_str());
}

enum TestEnum {
  kFirst,
  kSecond
};

TEST(PackIntoVariantContainer, Self) {
  int p1 = 10;
  double p2 = 3.14159;
  const char *p3 = "string";
  std::string p4(p3);
  auto p5 = kSecond;
  auto container = PackIntoVariantContainer(p1, p2, p3, &p4, p4, p5);
  ASSERT_EQ(container.get_n_children(), 6);
  {
    Glib::Variant<int> vp1;
    container.get_child(vp1, 0);
    ASSERT_EQ(vp1.get(), 10);
  }
  {
    Glib::Variant<double> vp2;
    container.get_child(vp2, 1);
    ASSERT_EQ(vp2.get(), 3.14159);
  }
  {
#if __WORDSIZE == 64
    Glib::Variant<gint64> vp3;
#else
    Glib::Variant<gint32> vp3;
#endif
    container.get_child(vp3, 2);
    const char *str = reinterpret_cast<char *>(vp3.get());
    ASSERT_STREQ(str, "string");
  }
  {
#if __WORDSIZE == 64
    Glib::Variant<gint64> vp4;
#else
    Glib::Variant<gint32> vp4;
#endif
    container.get_child(vp4, 3);
    std::string *str = reinterpret_cast<std::string *>(vp4.get());
    ASSERT_STREQ(str->c_str(), "string");
  }
  {
    Glib::Variant<std::string> vp5;
    container.get_child(vp5, 4);
    ASSERT_STREQ(vp5.get().c_str(), "string");
  }
  {
    Glib::Variant<gint32> vp6;
    container.get_child(vp6, 5);
    ASSERT_EQ(static_cast<TestEnum>(vp6.get()), kSecond);
  }
}

bool UnpackerTestFunc(int p1, const char *p2, double p3, int *res) {
  *res = (p1 == 10 && !strcmp(p2, "string") && p3 == 3.14159)  * 10;
  return *res;
}

bool UnpackerTestFuncValue = false;

void UnpackerTrivialTestFunc() {
  UnpackerTestFuncValue = true;
}

void UnpackerEnumTestFunc(TestEnum value) {
  UnpackerTestFuncValue = (value == kSecond? true : false);
}

TEST(Unpacker, Call) {
  bool res = false;
  auto container = PackIntoVariantContainer(10, "string", 3.14159, &res);
  Unpacker<bool, int, const char *, double, int *> up(UnpackerTestFunc);
  bool res2 = up(container);
  ASSERT_EQ(res, 10);
  ASSERT_TRUE(res2);
}

TEST(Unpacker, TrivialCall) {
  auto container = PackIntoVariantContainer();
  Unpacker<void> up(UnpackerTrivialTestFunc);
  up(container);
  ASSERT_TRUE(UnpackerTestFuncValue);
}

TEST(Unpacker, EnumCall) {
  auto te = kSecond;
  auto container = PackIntoVariantContainer(te);
  Unpacker<void, TestEnum> up(UnpackerEnumTestFunc);
  up(container);
  ASSERT_TRUE(UnpackerTestFuncValue);
}

// TODO(v.markovtsev): more tests here

#include "tests/google/src/gtest_main.cc"

perfect_programs/dbus_duplex/dbus_interface.cc0000664000175200017500000000475112044517333023013 0ustar  maximalovmaximalov/*! @file interface.cc
 *  @brief Classes to provide DBus low-level API for DBusDuplex.
 *  @author Moiseenko Andrey <moiseenko.a@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */


#include "src/lib/common/dbus_interface.h"
#include <algorithm>

namespace Conference {

std::string GetObjectPath(const std::string &path) {
  std::string objectPath("/" + path);
  std::replace(objectPath.begin(), objectPath.end(), '.', '/');
  return objectPath;
}

IntrospectionBuilder::IntrospectionBuilder(const std::string &interfaceName)
: EinaLogger("IntrospectionBuilder", INTROSPECTION_BUILDER_COLOR, true)
, name_(interfaceName) {
  xml_ << "<!DOCTYPE node PUBLIC "
      "\"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"";
  xml_ << std::endl;
  xml_ << "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">";
  xml_ << std::endl;
  xml_ << "<node name=\"" << GetObjectPath(name_) << "\">" << std::endl;
  xml_ << "<interface name=\"" << name_ << "\">" << std::endl;
}

std::string IntrospectionBuilder::Build() const {
  std::string res(xml_.str());
  res.append("</interface>");
  res.append("\n");
  res.append("</node>");
  DBG("Interface name is \"%s\".\nThe resulting introspection XML is:\n%s",
      name().c_str(),
      res.c_str());
  return res;
}

DBusInterface::DBusInterface(const DBusInterface &other)
: IntrospectionBuilder(other.name()) {
  for (auto I = other.functions_.begin();
      I != other.functions_.end(); ++I) {
    AddHandlerInternal(I->first, *I->second);
  }
}

const BaseCallback &DBusInterface::operator[](std::string i_method) const {
  auto function = functions_.find(i_method);
  if (function == functions_.end()) {
     throw UnknownMethodException();
  }
  return *(function->second);
}

DBusInterface &DBusInterface::AddHandlerInternal(const std::string &i_name,
                                  const BaseCallback &i_fun) {
  SpBaseCallback p(i_fun.clone());
  p->add_description(this, i_name.c_str());
  functions_.insert(std::pair<std::string, SpBaseCallback&>(i_name, p));
  return *this;
}

DBusInterface &DBusInterface::AddHandler(const std::string &i_name,
                                         const BaseCallback &i_fun) {
  DBG("Added handler %s%s", i_name.c_str(), i_fun.signature().c_str());
  return AddHandlerInternal(i_name, i_fun);
}

}  // namespace conference

perfect_programs/dbus_duplex/dbus_interface.h0000664000175200017500000004435412044517302022654 0ustar  maximalovmaximalov/*! @file dbus_interface.h
 *  @brief Classes to provide DBus low-level API for DBusDuplex.
 *  @author Moiseenko Andrey <moiseenko.a@samsung.com>, Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef SRC_LIB_COMMON_DBUS_INTERFACE_H_
#define SRC_LIB_COMMON_DBUS_INTERFACE_H_


#include <string.h>
#include <assert.h>
#include <glibmm/variant.h>
#include <type_traits>
#include <unordered_map>
#include <memory>
#include <functional>
#include <vector>
#include <utility>
#include <string>
#include <sstream>
#include "extern_libs/Loki/TypeManip.h"
#include "include/eina_logger.h"

namespace Conference {

std::string GetObjectPath(const std::string &path);

/// @brief Unboxes the value pointer enclosed in a Glib::VariantContainerBase
/// instance.
/// @param vcb The Glib::VariantContainerBase instance containing the value.
/// @return The first child in the container casted to the passed pointer type.
template <class T>
T *GetPtrResult(const Glib::VariantContainerBase &vcb) {
#if __WORDSIZE == 64
  Glib::Variant<gint64> res;
#else
  Glib::Variant<gint32> res;
#endif
  vcb.get_child(res, 0);
  return reinterpret_cast<T *>(res.get());
}

/// @brief Unboxes the value enclosed in a Glib::VariantContainerBase instance.
/// @param vcb The Glib::VariantContainerBase instance containing the value.
/// @return The first child in the container casted to the passed type.
template <class T>
T GetResult(const Glib::VariantContainerBase &vcb) {
  Glib::Variant<T> res;
  vcb.get_child(res, 0);
  return res.get();
}

struct BaseCallback;

/// @class IntrospectionBuilder
/// @brief This class makes the D-Bus introspection XML\
/// interface description from the supplied function signatures.
class IntrospectionBuilder
: public EinaLogger {
  template <unsigned index, typename... TList> struct TypeIterator;

  // This is needed for empty args
  template <typename... Dummy>
  struct TypeIterator<-1, Dummy...> {
    TypeIterator(IntrospectionBuilder *builder __attribute__((unused)),
                 unsigned count __attribute__((unused))) {}

    void Iterate() {}
  };

  template <class Head>
  struct TypeIterator<0, Head> {
    IntrospectionBuilder *builder_;
    unsigned count_;

    TypeIterator(IntrospectionBuilder *builder, unsigned count)
    : builder_(builder), count_(count) {}

    void Iterate() {
      builder_->xml_ << "<arg name=\"arg" << count_ << "\" type=\"";
      builder_->xml_ << builder_->ArgToIntrospectionXml<Head>();
      builder_->xml_ << "\" />" << std::endl;
    }
  };

  template <unsigned i, class Head, typename... Tail>
  struct TypeIterator<i, Head, Tail...> {
    static_assert(i == sizeof...(Tail), "Type index is out of bounds");

    IntrospectionBuilder *builder_;
    unsigned count_;

    TypeIterator(IntrospectionBuilder *builder, unsigned count)
    : builder_(builder), count_(count) {}

    void Iterate() {
      builder_->xml_ << "<arg name=\"arg" << count_ - i << "\" type=\"";
      builder_->xml_ << builder_->ArgToIntrospectionXml<Head>();
      builder_->xml_ << "\" />" << std::endl;
      TypeIterator<i - 1, Tail...> res(builder_, count_);
      res.Iterate();
    }
  };
  template <typename... Tail>
  struct HeadIterator;
  template < class Head, typename... Tail>
  struct HeadIterator<Head, Tail...> {
    IntrospectionBuilder *builder_;
    unsigned count_;

    HeadIterator(IntrospectionBuilder *builder, unsigned count)
    : builder_(builder), count_(count) {}

    void Iterate() {
      const char *returnArg = builder_->ArgToIntrospectionXml<Head>();
      if (returnArg != nullptr) {
        builder_->xml_ << "<arg name=\"arg" << 1 << "\" type=\"";
        builder_->xml_ << *returnArg;
        builder_->xml_ << "\" direction=\"out\" />" << std::endl;
      }
      TypeIterator<sizeof...(Tail) - 1, Tail...> res(builder_, count_);
      res.Iterate();
    }
  };

  std::stringstream xml_;
  std::string name_;
 public:
  explicit IntrospectionBuilder(const std::string &interfaceName);

  std::string Build() const;

  std::string name() const {
    return name_;
  }

  operator std::string() const {
    return Build();
  }

  template<typename... Args>
  IntrospectionBuilder &AddMethod(const std::string &name) {
    xml_ << "<method name=\"" << name << "\">" << std::endl;
    HeadIterator<Args...> iterator(this, sizeof...(Args));
    iterator.Iterate();
    xml_ << "</method>" << std::endl;
    return *this;
  }

  template<class T>
  static const char *ArgToIntrospectionXml() {
    if (std::is_pointer<T>::value) {
      #if __WORDSIZE == 64
        return "x";
      #else
        return "i";
      #endif
    }
    if (std::is_same<T, void>::value) return nullptr;
    if (std::is_enum<T>::value) return "i";
    if (std::is_same<T, std::string>::value) return "ay";
    assert(std::is_arithmetic<T>::value &&
           "Only passing basic types by value is supported");
    if (std::is_same<T, uint8_t>::value ||
        std::is_same<T, int8_t>::value) return "y";
    if (std::is_same<T, uint16_t>::value) return "q";
    if (std::is_same<T, uint32_t>::value) return "u";
    if (std::is_same<T, uint64_t>::value) return "t";
    return typeid(T).name();
  }
};

template<typename... Args>
Glib::VariantContainerBase PackIntoVariantContainer(Args... i_data) {
  std::vector<Glib::VariantBase > v;
  typedef typename TypeAt<0, Args...>::Result ParamType;
  Loki::Int2Type<std::is_pointer<ParamType>::value? 1
      : std::is_enum<ParamType>::value? 2
        : 0> variantTypeNumber;
  v = vector_pack_into_variant_container(variantTypeNumber, v, i_data ...);
  return Glib::VariantContainerBase::create_tuple(v);
}

// vector_pack_into_variant_container

inline std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<0>&,
    std::vector<Glib::VariantBase >&v) {
  return v;
}

inline std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    std::vector<Glib::VariantBase >&v) {
  return v;
}

template<class T>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<0>&,
    std::vector<Glib::VariantBase >&v,
    T i_data) {
  v.push_back(Glib::Variant<T>::create(i_data));
  return vector_pack_into_variant_container(v);
}

template<class T>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<1>&,
    std::vector<Glib::VariantBase >&v,
    T i_data) {
  #if __WORDSIZE == 64
  v.push_back(Glib::Variant<gint64>::create(reinterpret_cast<gint64>(i_data)));
  #else
  v.push_back(Glib::Variant<gint32>::create(reinterpret_cast<gint32>(i_data)));
  #endif
  return vector_pack_into_variant_container(v);
}

template<class T>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<2>&,
    std::vector<Glib::VariantBase >&v,
    T i_data) {
  v.push_back(Glib::Variant<gint32>::create(static_cast<gint32>(i_data)));
  return vector_pack_into_variant_container(v);
}

// Forward declarations begin
template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<0>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other);

template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<1>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other);

template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<2>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other);
// Forward declarations end

template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<0>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other) {
  v.push_back(Glib::Variant<T>::create(i_data));
  typedef typename TypeAt<0, Args...>::Result ParamType;
  Loki::Int2Type<std::is_pointer<ParamType>::value? 1
      : std::is_enum<ParamType>::value? 2
        : 0> variantTypeNumber;
  return vector_pack_into_variant_container(variantTypeNumber, v, other...);
}

template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<1>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other) {
  #if __WORDSIZE == 64
  v.push_back(Glib::Variant<gint64>::create(reinterpret_cast<gint64>(i_data)));
  #else
  v.push_back(Glib::Variant<gint32>::create(reinterpret_cast<gint32>(i_data)));
  #endif
  typedef typename TypeAt<0, Args...>::Result ParamType;
  Loki::Int2Type<std::is_pointer<ParamType>::value? 1
      : std::is_enum<ParamType>::value? 2
        : 0> variantTypeNumber;
  return vector_pack_into_variant_container(variantTypeNumber, v, other...);
}

template<class T, typename... Args>
std::vector<Glib::VariantBase > &vector_pack_into_variant_container(
    const Loki::Int2Type<2>&,
    std::vector<Glib::VariantBase >&v,
    T i_data,
    Args... other) {
  v.push_back(Glib::Variant<gint32>::create(static_cast<gint32>(i_data)));

  typedef typename TypeAt<0, Args...>::Result ParamType;
  Loki::Int2Type<std::is_pointer<ParamType>::value? 1
      : std::is_enum<ParamType>::value? 2
        : 0> variantTypeNumber;
  return vector_pack_into_variant_container(variantTypeNumber, v, other...);
}

template<typename ReturnValue, typename... Args>
class Unpacker {
  ReturnValue callback_entry(const Glib::VariantContainerBase &i_data) const {
    int size = i_data.get_n_children();
    static const int S = sizeof...(Args);
    assert(S == size);
    Loki::Int2Type<S> index;

    typedef typename
    TypeAt<(S - 1) >= 0? (S - 1) : 0, Args...>::Result NextParamType;
    Loki::Int2Type<(S - 1) >= 0? std::is_pointer<NextParamType>::value? 1
                                 : std::is_enum<NextParamType>::value? 2
                                   : 0
                               : 0> variantTypeNumber;
    return callback_recursive(index, variantTypeNumber, i_data);
  }

  template<int N, typename... IArgs>
  ReturnValue callback_recursive(Loki::Int2Type<N>, const Loki::Int2Type<0> &,
                         const Glib::VariantContainerBase &i_data,
                         IArgs... data) const {
    static const int S = (sizeof...(Args) - sizeof...(IArgs)) - 1;
    typedef typename TypeAt<S, Args...>::Result ParamType;
    Glib::Variant<ParamType> p;
    i_data.get_child(p, S);
    ParamType ip = p.get();
    Loki::Int2Type<S> index;

    typedef typename
    TypeAt<(S - 1) >= 0? (S - 1) : 0, Args...>::Result NextParamType;
    Loki::Int2Type<(S - 1) >= 0? std::is_pointer<NextParamType>::value? 1
                                 : std::is_enum<NextParamType>::value? 2
                                   : 0
                               : 0> variantTypeNumber;
    return callback_recursive(index, variantTypeNumber, i_data, ip, data...);
  }

  template<int N, typename... IArgs>
  ReturnValue callback_recursive(Loki::Int2Type<N>, const Loki::Int2Type<1> &,
                         const Glib::VariantContainerBase &i_data,
                         IArgs... data) const {
    static const int S = (sizeof...(Args) - sizeof...(IArgs)) - 1;
    typedef typename TypeAt<S, Args...>::Result ParamType;
    #if __WORDSIZE == 64
    Glib::Variant<gint64> p;
    #else
    Glib::Variant<gint32> p;
    #endif
    i_data.get_child(p, S);
    ParamType ip = reinterpret_cast<ParamType>(p.get());
    Loki::Int2Type<S> index;

    typedef typename
    TypeAt<(S - 1) >= 0? (S - 1) : 0, Args...>::Result NextParamType;
    Loki::Int2Type<(S - 1) >= 0? std::is_pointer<NextParamType>::value? 1
                                 : std::is_enum<NextParamType>::value? 2
                                   : 0
                               : 0> variantTypeNumber;
    return callback_recursive(index, variantTypeNumber, i_data, ip, data...);
  }

  template<int N, typename... IArgs>
  ReturnValue callback_recursive(Loki::Int2Type<N>, const Loki::Int2Type<2> &,
                         const Glib::VariantContainerBase &i_data,
                         IArgs... data) const {
    static const int S = (sizeof...(Args) - sizeof...(IArgs)) - 1;
    typedef typename TypeAt<S, Args...>::Result ParamType;
    Glib::Variant<gint32> p;
    i_data.get_child(p, S);
    ParamType ip = static_cast<ParamType>(p.get());
    Loki::Int2Type<S> index;

    typedef typename
    TypeAt<(S - 1) >= 0? (S - 1) : 0, Args...>::Result NextParamType;
    Loki::Int2Type<(S - 1) >= 0? std::is_pointer<NextParamType>::value? 1
                                 : std::is_enum<NextParamType>::value? 2
                                   : 0
                               : 0> variantTypeNumber;
    return callback_recursive(index, variantTypeNumber, i_data, ip, data...);
  }

  template<typename... IArgs>
  ReturnValue callback_recursive(Loki::Int2Type<0>, const Loki::Int2Type<0> &,
                         const Glib::VariantContainerBase &i_data
                         __attribute__((unused)),
                         IArgs... data) const {
    return WrappedFunction(data...);
  }

  std::function<ReturnValue(Args...)> WrappedFunction;

 public:
  Unpacker(const std::function<ReturnValue(Args...)> &f)
  : WrappedFunction(f) {}
  Unpacker(const Unpacker &i_other)
  : WrappedFunction(i_other.WrappedFunction) {}
  virtual ~Unpacker() {}
  ReturnValue operator()(
      const Glib::VariantContainerBase &i_data) const {
    return callback_entry(i_data);
  }
  Unpacker &operator=(const Unpacker &i_other) {
    WrappedFunction = i_other.WrappedFunction;
    return *this;
  }
};

class BaseCallback {
 public:
  virtual Glib::VariantContainerBase operator()(
      const Glib::VariantContainerBase &i_data) const = 0;
  virtual BaseCallback* clone() const = 0;
  virtual void add_description(IntrospectionBuilder *io_description,
                               const char* name) = 0;
  virtual std::string signature() const = 0;
  virtual ~BaseCallback() {}

 protected:
  template <unsigned index, typename... TList> struct SignatureIterator;

  // This is needed for empty args
  template <typename... Dummy>
  struct SignatureIterator<-1, Dummy...> {
    SignatureIterator(std::stringstream *str
                      __attribute__((unused))) {}

    void Iterate() {}
  };

  template <class Head>
  struct SignatureIterator<0, Head> {
    std::stringstream *str_;

    explicit SignatureIterator(std::stringstream *str)
    : str_(str) {}

    void Iterate() {
      (*str_) << IntrospectionBuilder::ArgToIntrospectionXml<Head>();
    }
  };

  template <unsigned i, class Head, typename... Tail>
  struct SignatureIterator<i, Head, Tail...> {
    static_assert(i == sizeof...(Tail), "Type index is out of bounds");

    std::stringstream *str_;

    explicit SignatureIterator(std::stringstream *str)
    : str_(str) {}

    void Iterate() {
      (*str_) << IntrospectionBuilder::ArgToIntrospectionXml<Head>();
      SignatureIterator<i - 1, Tail...> res(str_);
      res.Iterate();
    }
  };
};

template<typename ReturnType, typename... Args>
class Callback: public BaseCallback, private Unpacker<ReturnType, Args...> {
 public:
  Callback(std::function<ReturnType(Args...)> &&f
           = std::function<ReturnType(Args...)>())
  : Unpacker<ReturnType, Args...>(f) {}
  Callback(const Callback &i_other): Unpacker<ReturnType, Args...>(i_other) {}
  Glib::VariantContainerBase operator()(
      const Glib::VariantContainerBase &i_data) const {
    return PackIntoVariantContainer(
        this->Unpacker<ReturnType, Args...>::operator()(i_data));
  }

  BaseCallback* clone() const {
    return new Callback(*this);
  }

  void add_description(IntrospectionBuilder *io_description,
                       const char* name) {
    io_description->AddMethod<ReturnType, Args...>(name);
  }

  std::string signature() const {
    std::stringstream ss;
    ss << "(";
    SignatureIterator<sizeof...(Args) - 1, Args...> res(&ss);
    res.Iterate();
    ss << ")";
    return ss.str();
  }
};

template<typename... Args>
class Callback<void, Args...>
: public BaseCallback, private Unpacker<void, Args...> {
 public:
  Callback(std::function<void(Args...)> &&f = std::function<void(Args...)>())
  : Unpacker<void, Args...>(f) {}
  Callback(const Callback &i_other): Unpacker<void, Args...>(i_other) {}
  Glib::VariantContainerBase operator()(
      const Glib::VariantContainerBase &i_data) const {
    this->Unpacker<void, Args...>::operator()(i_data);
    return Glib::VariantContainerBase();
  }

  BaseCallback* clone() const {
    return new Callback(*this);
  }

  void add_description(IntrospectionBuilder *io_description,
                       const char* name) {
    io_description->AddMethod<void, Args...>(name);
  }

  std::string signature() const {
    std::stringstream ss;
    ss << "(";
    SignatureIterator<sizeof...(Args) - 1, Args...> res(&ss);
    res.Iterate();
    ss << ")";
    return ss.str();
  }
};

class InterfaceException {};
class UnknownMethodException: public InterfaceException {};

/// @brief The description of a D-Bus interface which can be passed into
/// the DBusDuplex constructor.
class DBusInterface: protected IntrospectionBuilder {
 public:
  typedef std::shared_ptr<BaseCallback> SpBaseCallback;
  typedef std::unordered_map<std::string, SpBaseCallback> HandlerMethods;

 public:
    explicit DBusInterface(const std::string &interfaceName)
    : IntrospectionBuilder(interfaceName) {}

    explicit DBusInterface(const DBusInterface &other);

    virtual ~DBusInterface() {}
    const BaseCallback &operator[](std::string i_method) const;

    /// @brief Adds a handler of a function invocation under the specified name.
    /// @param i_name The function name.
    /// @param i_fun The functor which will be called.
    /// @return Reference to this class instance.
    DBusInterface &AddHandler(const std::string &i_name,
                              const BaseCallback &i_fun);

    std::string description() const {
      return this->Build();
    }

    std::string name() const {
      return this->IntrospectionBuilder::name();
    }

 private:
    HandlerMethods functions_;

    DBusInterface &AddHandlerInternal(const std::string &i_name,
                                      const BaseCallback &i_fun);
};
}  // namespace Conference

#endif  // SRC_LIB_COMMON_DBUS_INTERFACE_H_

perfect_programs/common.h0000664000175200017500000000313612044517042016643 0ustar  maximalovmaximalov/*! @file common.h
 *  @brief Common header included into all source files.
 *  @author Markovtsev Vadim <v.markovtsev.samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef INCLUDE_COMMON_H_
#define INCLUDE_COMMON_H_

#include <mutex>
#include <string>
#include "./config.h"

#if __GNUC__ == 4 && __GNUC_MINOR__ < 6
#define nullptr NULL
#endif

template <unsigned index, typename... TList> struct TypeAt;

template <>
struct TypeAt<0> {
    typedef void Result;
};

template <class Head, typename... Tail>
struct TypeAt<0, Head, Tail...> {
    typedef Head Result;
};

template <unsigned i, class Head, typename... Tail>
struct TypeAt<i, Head, Tail...> {
  static_assert(i <= sizeof...(Tail) , "Type index is out of bounds");

  typedef typename TypeAt<i - 1, Tail...>::Result Result;
};

template<class InstanceClass>
class Singleton {
 public:
  Singleton(const Singleton&) = delete;
  Singleton(Singleton&&) = delete;
  Singleton& operator = (const Singleton&) = delete;
  Singleton&& operator = (Singleton&&) = delete;
  static InstanceClass &instance() {
    static InstanceClass inst;
    return inst;
  }
  virtual ~Singleton() {}
 protected:
#if __GNUC__ == 4 && __GNUC_MINOR__ < 6
  Singleton() {}
#else
  Singleton() = default;
#endif
};

#if __WORDSIZE == 64
#define POINT2INT_CAST(a)\
    reinterpret_cast<int64>(a)
#else
#define POINT2INT_CAST(a)\
    reinterpret_cast<int>(a)
#endif

#endif  // INCLUDE_COMMON_H_

perfect_programs/eina_logger/0000775000175200017500000000000012044520346017453 5ustar  maximalovmaximalovperfect_programs/eina_logger/eina_logger.h0000664000175200017500000001011512044517077022104 0ustar  maximalovmaximalov/*! @file eina_logger.h
 *  @brief Logging with Eina.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 *
 *  @description Usage
 *  #include "include/eina_logger.h"
 *
 *  class Foo : public EinaLogger {
 *   public:
 *    Foo() : EinaLogger("foo job", EINA_COLOR_ORANGE) {
 *      DBG("entered");
 *      INF("almost");
 *      WRN("finished");
 *      ERR("failed");
 *    }
 *  };
 */



#ifndef INCLUDE_EINA_LOGGER_H_
#define INCLUDE_EINA_LOGGER_H_

#include <assert.h>
#include <Eina.h>
#include <string>
#include "include/common.h"

#define DBG(...) EINA_LOG_DOM_DBG(this->log_domain(), __VA_ARGS__)
#define INF(...) EINA_LOG_DOM_INFO(this->log_domain(), __VA_ARGS__)
#define WRN(...) EINA_LOG_DOM_WARN(this->log_domain(), __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(this->log_domain(), __VA_ARGS__)
#define CRT(...) EINA_LOG_DOM_CRIT(this->log_domain(), __VA_ARGS__)

#define DBGI(x, ...) EINA_LOG_DOM_DBG((x)->log_domain(), __VA_ARGS__)
#define INFI(x, ...) EINA_LOG_DOM_INFO((x)->log_domain(), __VA_ARGS__)
#define WRNI(x, ...) EINA_LOG_DOM_WARN((x)->log_domain(), __VA_ARGS__)
#define ERRI(x, ...) EINA_LOG_DOM_ERR((x)->log_domain(), __VA_ARGS__)
#define CRTI(x, ...) EINA_LOG_DOM_CRIT((x)->log_domain(), __VA_ARGS__)

#define DBGC(x, ...) EINA_LOG_DOM_DBG(x::log_domain(), __VA_ARGS__)
#define INFC(x, ...) EINA_LOG_DOM_INFO(x::log_domain(), __VA_ARGS__)
#define WRNC(x, ...) EINA_LOG_DOM_WARN(x::log_domain(), __VA_ARGS__)
#define ERRC(x, ...) EINA_LOG_DOM_ERR(x::log_domain(), __VA_ARGS__)
#define CRTC(x, ...) EINA_LOG_DOM_CRIT(x::log_domain(), __VA_ARGS__)
#define COMMON_DOMAIN "vconf-"

#define GSTELEMENT_LOG_COLOR EINA_COLOR_ORANGE
#define DBUSDUPLEX_LOG_COLOR EINA_COLOR_YELLOW
#define EINA_LOGGER_COLOR EINA_COLOR_WHITE
#define GST_CREATOR_COLOR EINA_COLOR_RED
#define INTROSPECTION_BUILDER_COLOR EINA_COLOR_CYAN
#define VCONFGUI_LOG_COLOR EINA_COLOR_GREEN
#define NICE_CONNECTION_COLOR EINA_COLOR_LIGHTBLUE
#define VCONFERENCE_COLOR EINA_COLOR_LIGHTRED
#define BASE_STREAM_COLOR EINA_COLOR_CYAN
#define MASTER_LOG_COLOR EINA_COLOR_RED
#define FARSTREAM_SESSION_LOG_COLOR EINA_COLOR_YELLOW
#define SEMAPHORE_LOG_COLOR EINA_COLOR_WHITE
#define ICONFERENCE_LOG_COLOR EINA_COLOR_LIGHTBLUE
#define TCP_THREAD_MANAGER_COLOR EINA_COLOR_GREEN
#define PROTOCOL_COLOR EINA_COLOR_ORANGE
#define PROTOCOL_CONN_COLOR EINA_COLOR_WHITE
#define NAME_SERVER_COLOR EINA_COLOR_WHITE


class EinaLogger {
 public:
  EinaLogger(const std::string &domain, const std::string &color,
             bool suppressLoggingInitialized = false)
  : log_domain_(unintialized_log_domain_)
  , domain_str_(domain)
  , color_(color)
  , suppressLoggingInitialized_(suppressLoggingInitialized) {
    Initialize();
  }

  explicit EinaLogger(const std::string &color)
  : log_domain_(unintialized_log_domain_)
  , domain_str_("log")
  , color_(color)
  , suppressLoggingInitialized_(false) {
    Initialize();
  }

  explicit EinaLogger(bool suppressLoggingInitialized = true)
  : log_domain_(unintialized_log_domain_)
  , domain_str_("log")
  , color_(EINA_LOGGER_COLOR)
  , suppressLoggingInitialized_(suppressLoggingInitialized) {
    Initialize();
  }

  explicit EinaLogger(const EinaLogger &other)
  : log_domain_(unintialized_log_domain_)
  , domain_str_(other.domain_str_)
  , color_(other.color_)
  , suppressLoggingInitialized_(other.suppressLoggingInitialized_) {
    Initialize();
  }

  virtual ~EinaLogger() {
    Deinitialize();
  }

  int log_domain() const;

  std::string domain_str() const;

  void set_domain_str(const std::string &value);

  std::string color() const;

  void set_color(const std::string &value);

  static std::string Demangle(const std::string &symbol);

 protected:
  static const int unintialized_log_domain_ = -1;

  int log_domain_;
  std::string domain_str_;
  std::string color_;
  bool suppressLoggingInitialized_;

  void Initialize();
  void Deinitialize();
};

#endif  // INCLUDE_EINA_LOGGER_H_

perfect_programs/eina_logger/tests/0000775000175200017500000000000012044520350020610 5ustar  maximalovmaximalovperfect_programs/eina_logger/tests/eina_logger.cc0000664000175200017500000000537012044520350023377 0ustar  maximalovmaximalov/*! @file eina_logger.cc
 *  @brief Tests for EinaLogger.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include <unistd.h>
#include <fstream>
#include "include/eina_logger.h"
#include "tests/google/gtest/gtest.h"

enum EinaLogLevels {
  kEinaLogLevelCrt,
  kEinaLogLevelErr,
  kEinaLogLevelWrn,
  kEinaLogLevelInf,
  kEinaLogLevelDbg
};

class LogTester
: public EinaLogger {
 public:
  LogTester() : EinaLogger("LogTester", EINA_COLOR_BLUE) {
  }

  LogTester(LogTester &other) : EinaLogger(other) {
  }

  void Log(const char *message, EinaLogLevels level) {
    switch (level) {
      case kEinaLogLevelCrt:
        CRT("%s", message);
        break;
      case kEinaLogLevelErr:
        ERR("%s", message);
        break;
      case kEinaLogLevelWrn:
        WRN("%s", message);
        break;
      case kEinaLogLevelInf:
        INF("%s", message);
        break;
      case kEinaLogLevelDbg:
        DBG("%s", message);
        break;
      default:
        break;
    }
  }
};

TEST(EinaLogger, SameClasses) {
  LogTester l1;
  LogTester l2;
  ASSERT_NE(l1.log_domain(), l2.log_domain());
}

TEST(EinaLogger, Copy) {
  LogTester l1;
  LogTester l2(l1);
  ASSERT_NE(l1.log_domain(), l2.log_domain());
}

TEST(EinaLogger, Logging) {
  eina_log_level_set(5);
  fpos_t pos;
  fgetpos(stderr, &pos);
  int fderr = dup(fileno(stderr));
  if (freopen("log", "w", stderr) == nullptr) assert(false);
  {
    LogTester lt;
    lt.Log("messageDBG", kEinaLogLevelDbg);
    lt.Log("messageINF", kEinaLogLevelInf);
    lt.Log("messageWRN", kEinaLogLevelWrn);
    lt.Log("messageERR", kEinaLogLevelErr);
    lt.Log("messageCRT", kEinaLogLevelCrt);
  }
  fflush(stderr);
  dup2(fderr, fileno(stderr));
  close(fderr);
  clearerr(stderr);
  fsetpos(stderr, &pos);
  std::ifstream fr("log", std::ifstream::in);
  std::string log((std::istreambuf_iterator<char>(fr)),
                   std::istreambuf_iterator<char>());
  ASSERT_NE(log.find(__FILE__), std::string::npos);
  ASSERT_NE(log.find("messageDBG"), std::string::npos);
  ASSERT_NE(log.find("messageINF"), std::string::npos);
  ASSERT_NE(log.find("messageWRN"), std::string::npos);
  ASSERT_NE(log.find("messageERR"), std::string::npos);
  ASSERT_NE(log.find("messageCRT"), std::string::npos);
  ASSERT_NE(log.find("Initialize()"), std::string::npos);
  ASSERT_NE(log.find("Deinitialize()"), std::string::npos);
  ASSERT_NE(log.find("LogTester"), std::string::npos);
  ASSERT_NE(log.find(COMMON_DOMAIN), std::string::npos);
  remove("log");
  eina_log_level_set(1);
}

#include "tests/google/src/gtest_main.cc"

perfect_programs/eina_logger/eina_logger.cc0000664000175200017500000000435212044517120022235 0ustar  maximalovmaximalov/*! @file eina_logger.cc
 *  @brief EinaLogger implementation.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "include/eina_logger.h"
#include <cxxabi.h>

void EinaLogger::Initialize() {
  Deinitialize();
  eina_init();
  eina_log_threads_enable();
  int len = strlen(COMMON_DOMAIN) + strlen(domain_str_.c_str()) + 1;
  char *fullDomain = new char[len];
  snprintf(fullDomain, len, "%s%s", COMMON_DOMAIN, domain_str_.c_str());
  log_domain_ = eina_log_domain_register(fullDomain, color_.c_str());
  if (log_domain_ < 0) {
    int message_len = len + 128;
    char *message = new char[message_len];
    snprintf(message, message_len, "%s%s%s",
            "could not register ", fullDomain, " log domain.");
    EINA_LOG_DOM_ERR(EINA_LOG_DOMAIN_GLOBAL, "%s", message);
    log_domain_ = EINA_LOG_DOMAIN_GLOBAL;
  } else {
    if (!suppressLoggingInitialized_) {
      DBG("Logging initialized with domain %i.",
          log_domain_);
    }
  }
  delete[] fullDomain;
}

void EinaLogger::Deinitialize() {
  if (log_domain_ != unintialized_log_domain_ &&
      log_domain_ != EINA_LOG_DOMAIN_GLOBAL) {
    if (!suppressLoggingInitialized_) {
      DBG("eina_log_domain_unregister(%i)", log_domain_);
    }
    eina_log_domain_unregister(log_domain_);
    log_domain_ = unintialized_log_domain_;
  }
}

int EinaLogger::log_domain() const {
  assert(log_domain_ != unintialized_log_domain_);
  return log_domain_;
}

std::string EinaLogger::domain_str() const {
  return domain_str_;
}

void EinaLogger::set_domain_str(const std::string &value) {
  domain_str_ = value;
  Initialize();
}

std::string EinaLogger::color() const {
  return color_;
}

void EinaLogger::set_color(const std::string &value) {
  color_ = value;
  Initialize();
}

std::string EinaLogger::Demangle(const std::string &symbol) {
  size_t size;
  int status;
  char *demangled;
  if ((demangled = abi::__cxa_demangle(symbol.c_str(), NULL, &size, &status))) {
    std::string result(demangled);
    free(demangled);
    return result;
  }

  return symbol;
}

perfect_programs/network_utils/0000775000175200017500000000000012044520371020107 5ustar  maximalovmaximalovperfect_programs/network_utils/tests/0000775000175200017500000000000012044520374021254 5ustar  maximalovmaximalovperfect_programs/network_utils/tests/network_utilities.cc0000664000175200017500000000474012044520374025354 0ustar  maximalovmaximalov/*! @file network_utilities.cc
 *  @brief Tests for lib/common/network_utilities.*
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "src/lib/common/network_utilities.h"
#include <net/if.h>
#include "include/common.h"
#include "tests/google/gtest/gtest.h"

std::string safe_default_iface() {
  auto realIfaceFd = popen(
      "ip route show default | grep default | cut -d\" \" -f5", "r");
  char *realIface = nullptr;
  size_t realIfaceLength;
  assert(getline(&realIface, &realIfaceLength, realIfaceFd) > -1);
  *strstr(realIface, "\n") = 0;
  std::string ret(realIface);
  free(realIface);
  pclose(realIfaceFd);
  return ret;
}

std::string safe_addr(const std::string &ifaceName) {
  std::string cmd("ifconfig | grep ");
  cmd += ifaceName;
  cmd += " -A1 | grep \"inet addr\" | cut -c 21- | cut -d\" \" -f1";
  auto realAddrFd = popen(cmd.c_str(), "r");
  char *realAddr = nullptr;
  size_t realAddrLength;
  assert(getline(&realAddr, &realAddrLength, realAddrFd) > 0);
  *strstr(realAddr, "\n") = 0;
  std::string ret(realAddr);
  free(realAddr);
  pclose(realAddrFd);
  return ret;
}

TEST(get_default_network_iface, get_default_network_iface) {
  IpResolver::instance().reset();
  ASSERT_STREQ(safe_default_iface().c_str(),
               IpResolver::instance().iface().c_str());
}

TEST(get_ip_addr, get_ip_addr) {
  auto ifaces = if_nameindex();
  for (int i = 0; ifaces[i].if_name != nullptr; i++) {
    IpResolver::instance().set_interface(ifaces[i].if_name);
    ASSERT_STREQ(safe_addr(ifaces[i].if_name).c_str(),
                 IpResolver::instance().ip().c_str());
  }
  if_freenameindex(ifaces);
}

TEST(get_ip_addr, usb) {
  auto ifaces = if_nameindex();
  for (int i = 0; ifaces[i].if_name != nullptr; i++) {
    if (!strcmp(ifaces[i].if_name, "samsung_device")) {
      // samsung_device interface found, assuming Tizen
      IpResolver::instance().set_interface(ifaces[i].if_name);
      ASSERT_STREQ("192.168.129.4",
                   IpResolver::instance().ip().c_str());
    }
  }
  if_freenameindex(ifaces);
}

TEST(get_ip_addr_default, get_ip_addr_default) {
  IpResolver::instance().reset();
  ASSERT_STREQ(safe_addr(safe_default_iface()).c_str(),
               IpResolver::instance().ip().c_str());
}

#include "tests/google/src/gtest_main.cc"

perfect_programs/network_utils/network_utilities.h0000664000175200017500000000152512044517550024054 0ustar  maximalovmaximalov/*! @file network_utilities.h
 *  @brief Various network utility functions.
 *  @author Moiseenko Andrey <moiseenko.a@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef SRC_LIB_COMMON_NETWORK_UTILITIES_H_
#define SRC_LIB_COMMON_NETWORK_UTILITIES_H_
#include <string>
#include "include/common.h"

class IpResolver : public Singleton<IpResolver> {
  friend class Singleton<IpResolver>;
 public:
  std::string ip();
  std::string set_interface(const std::string& i_iface);
  const std::string& iface();
  void reset();
 protected:
  IpResolver();
 private:
  std::string iface_;
  std::string ip_;
};

#endif  // SRC_LIB_COMMON_NETWORK_UTILITIES_H_

perfect_programs/network_utils/network_utilities.cc0000664000175200017500000000631712044517516024220 0ustar  maximalovmaximalov/*! @file network_utilities.cc
 *  @brief Various network utility functions.
 *  @author Moiseenko Andrey <moiseenko.a@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "src/lib/common/network_utilities.h"
#include <net/route.h>
#include <ifaddrs.h>
#include <arpa/inet.h>
#include <assert.h>
#include <Eina.h>
#include "include/common.h"

#define LOCAL_ADDR "127.0.0.1"
/*
/// @brief Returns the name of the network interface the default route
/// belongs to.
static std::string get_default_network_iface();

/// @brief Returns the network address of the specified interface.
static std::string get_ip_addr();

/// @brief Returns the network address of the default interface.
static std::string get_ip_addr_default();
*/
static std::string get_default_network_iface() {
  std::string ifaceRet;
  auto routeFd = fopen("/proc/net/route", "r");
  assert(routeFd != nullptr);
  char *line = nullptr;
  size_t lineLength;
  assert(getline(&line, &lineLength, routeFd) > -1);
  free(line);
  line = nullptr;

  while (getline(&line, &lineLength, routeFd) > -1) {
    unsigned flags, other;
    char ifaceName[128];
    if (sscanf(line, "%127s%X%X%X", ifaceName, &other, &other, &flags) != 4) {
      break;
    }
    free(line);
    line = nullptr;
    if ((flags & RTF_GATEWAY) && (flags & RTF_UP)) {
      ifaceRet = ifaceName;
      break;
    }
  }
  fclose(routeFd);
  EINA_LOG_INFO("Taking \"%s\" as the default network interface",
               ifaceRet.c_str());
  return ifaceRet;
}

static std::string get_ip_addr(const std::string &iface) {
  std::string ip(LOCAL_ADDR);

  if (iface == "") {
    EINA_LOG_WARN("Network interface was not defined, falling back to %s",
                  ip.c_str());
    return ip;
  }

  struct ifaddrs* ifAddrStruct = nullptr;
  getifaddrs(&ifAddrStruct);

  for (auto ifa = ifAddrStruct; ifa != nullptr; ifa = ifa->ifa_next) {
      if (ifa ->ifa_addr != nullptr &&
          ifa ->ifa_addr->sa_family == AF_INET) {  // check it to be IPv4
        auto tmpAddrPtr = &(reinterpret_cast<struct sockaddr_in *>(
            ifa->ifa_addr)->sin_addr);
        char addressBuffer[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
        if (iface == ifa->ifa_name) {
          ip = addressBuffer;
          EINA_LOG_INFO("Taking %s as the network address", ip.c_str());
          break;
        }
      }
  }
  if (ifAddrStruct != nullptr) {
    freeifaddrs(ifAddrStruct);
  }

  if (ip == LOCAL_ADDR) {
    EINA_LOG_WARN("Couldn't find the network address, falling back to %s",
                  ip.c_str());
  }
  return ip;
}

std::string IpResolver::ip() {
  return ip_;
}

std::string IpResolver::set_interface(const std::string &i_iface) {
  std::string tmp(iface_);
  iface_ = i_iface;
  ip_ = get_ip_addr(iface_);
  return tmp;
}

const std::string& IpResolver::iface() {
  return iface_;
}

void IpResolver::reset() {
  iface_ = get_default_network_iface();
  ip_ = get_ip_addr(iface_);
}
IpResolver::IpResolver()
: iface_(get_default_network_iface())
, ip_(get_ip_addr(iface_)) {}



perfect_programs/file_utils/0000775000175200017500000000000012044517427017345 5ustar  maximalovmaximalovperfect_programs/file_utils/file_utils.h~0000664000175200017500000000000012044517401022031 0ustar  maximalovmaximalovperfect_programs/file_utils/file_utils.h0000664000175200017500000000121012044517403021641 0ustar  maximalovmaximalov/*! @file file_utils.h
 *  @brief Utilities to work with file system.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include <vector>
#include <string>

#ifndef SRC_LIB_COMMON_FILE_UTILS_H_
#define SRC_LIB_COMMON_FILE_UTILS_H_


bool ListFiles(const std::string &dir,
               std::vector<std::string> *files);

bool FileExists(const std::string &file);

#endif  // SRC_LIB_COMMON_FILE_UTILS_H_

perfect_programs/file_utils/file_utils.cc0000664000175200017500000000174512044517427022022 0ustar  maximalovmaximalov/*! @file file_utils.cc
 *  @brief Implementation of utility functions to work with file system.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include <assert.h>
#include <dirent.h>
#include <sys/stat.h>
#include "include/common.h"
#include "src/lib/common/file_utils.h"

bool ListFiles(const std::string &dir,
               std::vector<std::string> *files) {
  assert(files !=static_cast<void *>(nullptr));
  DIR *dp;
  struct dirent *dirp;
  if ((dp  = opendir(dir.c_str())) == nullptr) {
    return false;
  }
  while ((dirp = readdir(dp)) != nullptr) {
      files->push_back(std::string(dirp->d_name));
  }
  closedir(dp);
  return true;
}

bool FileExists(const std::string &file) {
  struct stat ss;
  return stat(file.c_str(), &ss) == 0;
}

perfect_programs/death_handler/0000775000175200017500000000000012044517012017756 5ustar  maximalovmaximalovperfect_programs/death_handler/death_handler.h0000664000175200017500000000135712044516764022734 0ustar  maximalovmaximalov/*! @file death_handler.h
 *  @brief A handler for segfault backtrace.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef INCLUDE_DEATH_HANDLER_H_
#define INCLUDE_DEATH_HANDLER_H_

#include <string>

namespace Conference {

class DeathHandler {
 public:
  DeathHandler();
 private:
  static std::string Demangle(const std::string &symbol);
  static void SignalHandler(int sig, void *info,
                            void *secret);
};

} /* namespace Conference */
#endif  // INCLUDE_DEATH_HANDLER_H_

perfect_programs/death_handler/death_handler.cc0000664000175200017500000001115712044517012023054 0ustar  maximalovmaximalov/*! @file death_handler.cc
 *  @brief A handler for segfault backtrace.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "include/death_handler.h"
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <execinfo.h>
#include <cxxabi.h>
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <dlfcn.h>

namespace Conference {

DeathHandler::DeathHandler() {
  struct sigaction sa;
  sa.sa_handler = (__sighandler_t)SignalHandler;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = SA_RESTART | SA_SIGINFO;
  sigaction(SIGSEGV, &sa, NULL);
}

std::string DeathHandler::Demangle(const std::string &symbol) {
  size_t size;
  int status;
  char temp[256];
  char* demangled;
  // first, try to demangle a c++ name
  if (1 == sscanf(symbol.c_str(),  // NOLINT(runtime/printf)
                  "%*[^(]%*[^_]%127[^)+]", temp)) {
    if ((demangled = abi::__cxa_demangle(temp, NULL, &size, &status))) {
      std::string result(demangled);
      free(demangled);
      return result;
    }
  }
  // if that didn't work, try to get a regular c symbol
  if (1 == sscanf(symbol.c_str(), "%127s", temp)) {  // NOLINT(runtime/printf)
    std::string line(temp);
    auto left = line.find_last_of('(') + 1;
    auto right = line.find_last_of('+');
    if (right == std::string::npos) {
      right = line.find_last_of(')');
    }
    return line.substr(left, right - left);
  }

  // if all else fails, just return the symbol
  return symbol;
}

void DeathHandler::SignalHandler(int sig __attribute__((unused)),
                                    void *info __attribute__((unused)),
                                    void *secret) {
  void *trace[16];
  char **messages;
  ucontext_t *uc = reinterpret_cast<ucontext_t *>(secret);

  if (dup2(2, 1) == -1) {  // redirect stdout to stderr
    fprintf(stderr, "Failed to redirect stdout to stderr\n");
  }
  fprintf(stderr, "\033[31;1mSegmentation fault\033[0m \033[33;1m(%i)\033[0m\n",
          getpid());

  char name_buf[1024];
  name_buf[readlink("/proc/self/exe", name_buf, sizeof(name_buf) - 1)] = 0;

  auto trace_size = backtrace(trace, 16);
  // overwrite sigaction with caller's address
#if defined(TIZEN)
  trace[1] = reinterpret_cast<void *>(uc->uc_mcontext.arm_pc);
#else
  trace[1] = reinterpret_cast<void *>(uc->uc_mcontext.gregs[REG_EIP]);
#endif
  messages = backtrace_symbols(trace, trace_size);
  printf("\nStack trace:\n");

  // skip first stack frame (points here)
  for (auto i = 1; i < trace_size - 2; i++) {
    if (i == 2 && !strcmp(messages[1], messages[2])) continue;
    printf("\033[34;1m[%s]\033[0m \033[33;1m(%i)\033[0m\n",
           Demangle(messages[i]).c_str(), getpid());

    char syscmd[1280];
    Dl_info dlinf;
    if (dladdr(trace[i], &dlinf) == 0 || !strcmp(name_buf, dlinf.dli_fname)) {
      snprintf(syscmd, sizeof(syscmd), "addr2line %p -e %s",
               trace[i], name_buf);
    } else {
      snprintf(syscmd, sizeof(syscmd), "addr2line %p -e %s",
               reinterpret_cast<void *>(reinterpret_cast<char *>(trace[i]) -
                 reinterpret_cast<char *>(dlinf.dli_fbase)),
               dlinf.dli_fname);
    }
    auto lineFd = popen(syscmd, "r");
    if (lineFd == NULL) {
      exit(EXIT_FAILURE);
    }
    char *line = NULL;
    size_t lineSize;
    if (getline(&line, &lineSize, lineFd) == -1) {
      exit(EXIT_FAILURE);
    }
    // Remove relative path root
    auto pathCutPos = strstr(line, "../");
    if (pathCutPos != NULL) {
      pathCutPos += 3;
      while (!strncmp(pathCutPos, "../", 3)) {
        pathCutPos += 3;
      }
      lineSize = lineSize - (pathCutPos - line);
      memmove(line, pathCutPos, lineSize);
    }
    // Mark line number
    auto numberPos = strstr(line, ":");
    if (numberPos != NULL) {
      char lineNumber[lineSize - (numberPos - line)];  // NOLINT(runtime/arrays)
      memcpy(lineNumber, numberPos, sizeof(lineNumber));
      line = reinterpret_cast<char *>(
          realloc(line, lineSize + strlen("\033[32;1m\033[0m")));
      sprintf(line + lineSize - sizeof(lineNumber),  // NOLINT(runtime/printf)
              "\033[32;1m%s\033[0m", lineNumber);
      lineSize += strlen("\033[32;1m\033[0m");
    }
    auto newLinePos = strstr(line, "\n");
    if (newLinePos != NULL) {
      *newLinePos = ' ';
    }
    printf("%s\033[33;1m(%i)\033[0m\n", line, getpid());
    free(line);
    pclose(lineFd);
  }

  exit(EXIT_FAILURE);
}

} /* namespace Conference */

perfect_programs/dns_resolve/0000775000175200017500000000000012044520062017516 5ustar  maximalovmaximalovperfect_programs/dns_resolve/dns_resolve.h0000664000175200017500000000112412044520062022210 0ustar  maximalovmaximalov/*! @file dns_resolve.h
 *  @brief DNS resolver declaration.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */


#include <string>
#include "include/common.h"

#ifndef SRC_LIB_P2PPROTO_DNS_RESOLVE_H_
#define SRC_LIB_P2PPROTO_DNS_RESOLVE_H_

namespace Network {

std::string Resolve(const std::string &addr);
}

#endif  // SRC_LIB_P2PPROTO_DNS_RESOLVE_H_

perfect_programs/dns_resolve/dns_resolve.cc0000664000175200017500000000213112044520043022344 0ustar  maximalovmaximalov/*! @file dns_resolve.cc
 *  @brief DNS resolver implementation.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */


#include "src/lib/p2pproto/dns_resolve.h"
#include <netdb.h>
#include <arpa/inet.h>
#include "include/common.h"

namespace Network {

/// @brief Perform DNS lookup of the specified address.
/// @param addr The address to resolve.
/// @note addr can be either an IP address or a domain name.
/// @return The resolved IP address or "" if failed.
std::string Resolve(const std::string &addr) {
  addrinfo *resolvedAddresses;
  int resolvRes = getaddrinfo(addr.c_str(), nullptr, nullptr,
                              &resolvedAddresses);
  if (resolvRes != 0) {
    return "";
  }
  std::string resolvedAddress(inet_ntoa(
      ((struct sockaddr_in *)resolvedAddresses->ai_addr)->sin_addr));
  freeaddrinfo(resolvedAddresses);
  return resolvedAddress;
}
}

perfect_programs/thread_loop/0000775000175200017500000000000012044517625017506 5ustar  maximalovmaximalovperfect_programs/thread_loop/thread_loop.h0000664000175200017500000000210312044517625022153 0ustar  maximalovmaximalov/*! @file thread_loop.h
 *  @brief Loop in a separate thread.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef SRC_LIB_COMMON_THREAD_LOOP_H_
#define SRC_LIB_COMMON_THREAD_LOOP_H_

#include <thread>
#include <mutex>
#include <functional>

/// @class This is the implementation of a loop in separate thread.
/// @brief Loop starts to execute in constructor and finishes in destructor.
class ThreadLoop {
 public:
  ThreadLoop(const std::function<bool(void)> &loop,
             const std::chrono::microseconds &interval =
               std::chrono::microseconds::zero());
  ~ThreadLoop();

  std::chrono::microseconds timeout();
  void stop();
 private:
  bool cancel_;
  std::thread *thread_;
  std::function<bool(void)> loop_;
  std::timed_mutex mutex_;
  std::chrono::microseconds interval_;
};

#endif  // SRC_LIB_COMMON_THREAD_LOOP_H_

perfect_programs/thread_loop/thread_loop.cc0000664000175200017500000000220512044517606022313 0ustar  maximalovmaximalov/*! @file thread_loop.cc
 *  @brief Loop in a separate thread.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#include "src/lib/common/thread_loop.h"

ThreadLoop::ThreadLoop(const std::function<bool(void)> &loop,
                          const std::chrono::microseconds &interval)
: cancel_(false)
, loop_(loop)
, interval_(interval) {
  thread_ = new std::thread([&]() {
    if (interval_ != std::chrono::microseconds::zero()) {
      while (!cancel_) {
        mutex_.lock();
        mutex_.try_lock_for(interval_);
        mutex_.unlock();
        if (!loop_()) break;
      }
    } else {
      while (!cancel_) {
        if (!loop_()) break;
      }
    }
  });
}

ThreadLoop::~ThreadLoop() {
  if (!cancel_) {
    stop();
  }
  delete thread_;
}

std::chrono::microseconds ThreadLoop::timeout() {
  return interval_;
}

void ThreadLoop::stop() {
  cancel_ = true;
  mutex_.unlock();
  thread_->join();
}

perfect_programs/semaphore.inc0000664000175200017500000000360312044520610017652 0ustar  maximalovmaximalov/*! @file semaphore.inc
 *  @brief Implementation of a simple named semaphore used in tests which require interprocess communication.
 *  @author Markovtsev Vadim <v.markovtsev@samsung.com>
 *  @version 1.0
 *
 *  @section Notes
 *  This code conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>.
 *
 *  @section Copyright
 *  Copyright 2012 Samsung Electronics
 */

#ifndef TESTS_SEMAPHORE_INC_
#define TESTS_SEMAPHORE_INC_

#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <assert.h>
#include <include/eina_logger.h>

class Semaphore
: public EinaLogger {
 public:
  Semaphore(unsigned value, bool master)
  : EinaLogger("Semaphore", SEMAPHORE_LOG_COLOR)
  , master_(master) {
    sem_ = sem_open(NAME, O_CREAT, 0666, value);
    assert(sem_ != SEM_FAILED);
    if (!master) return;
    if (this->value() != static_cast<int>(value)) {
      EINA_LOG_WARN("Detected a stale semaphore, forcing to open");
      sem_unlink(NAME);
      sem_ = sem_open(NAME, O_CREAT, 0666, value);
      assert(sem_ != SEM_FAILED);
    }
    assert(this->value() == static_cast<int>(value)
           && "Can not destroy previously acquired semaphore");
  }

  ~Semaphore() {
    DBG("sem_close(sem_)");
    sem_close(sem_);
    if (master_) {
      sem_unlink(NAME);
    }
  }

  bool decrement() {
    DBG("sem_trywait(sem_)");
    int res = sem_trywait(sem_);
    return res == 0;
  }


  void increment() {
    DBG("increment()");
    int res = sem_post(sem_);
    assert(res == 0);
  }

  bool wait() {
    DBG("sem_wait(sem_)");
    int res = sem_wait(sem_);
    return res == 0;
  }

  int value() {
    int result;
    int vr = sem_getvalue(sem_, &result);
    assert(vr == 0);
    return result;
  }
 private:
  sem_t *sem_;
  bool master_;
  static const char* NAME;
};

const char* Semaphore::NAME = "/vconfsem";

#endif  // TESTS_SEMAPHORE_INC_