Merge ~morphis/aethercast/+git/aethercast:feature/cli-rework into aethercast:master

[Simon Fels]

Rework command line frontend and move everything into a single binary

Rework command line frontend and move everything into a single binary

Both shell and service are now covered by a single aethercast binary
which can be invoked via

 $ aethercast service

to start the service component or as

 $ aethercast shell

to get into the interactive shell. More utility things like
mirscreencast_to_stream will be converted into a subcommand as well.

856701f... by Simon Fels on 2017-02-01

Rework configuration to be interchangable

Unmerged commits

dce5ad2... by Simon Fels on 2017-01-24

Extend snapcraft configuration to cover changed cli

83e7725... by Simon Fels on 2017-01-24

Rework command line frontend and move everything into a single binary

Both shell and service are now covered by a single aethercast binary
which can be invoked via

 $ aethercast service

to start the service component or as

 $ aethercast shell

to get into the interactive shell. More utility things like
mirscreencast_to_stream will be converted into a subcommand as well.

856701f... by Simon Fels on 2017-02-01

Rework configuration to be interchangable

630a5da... by Simon Fels on 2017-01-24

Add snap build configuration

Currently builds aethercast without Mir and Android support. Those
things can be added back at a later point.

18c722d... by Simon Fels on 2017-01-24

Refactor necessary code bits to allow execute inside a snap

98f844b... by Simon Fels on 2017-01-24

Enable support for Mir and Android only optional

Both are not yet mutally exclusive and still depend on each other but
Mir support will become independent of the Android bits over time so
we put both decoupled already from the beginning.

294eee4... by Simon Fels on 2016-11-16

Add maintainer script to get rid of unwanted configuration file

5aa83f2... by Simon Fels on 2016-11-08

Allow dhcpd to write files which just include .lease in the name

dhcpd seems to write some temp files when its creating the lease file
and therefor needs wider access and just *.lease

cf472e7... by Simon Fels on 2016-11-07

Correctly install hook for dhclient

diff --git a/snapcraft.yaml b/snapcraft.yaml
index 4b4bea5..017bcdf 100644
--- a/snapcraft.yaml
+++ b/snapcraft.yaml
@@ -13,10 +13,19 @@ slots:
     interface: dbus
     bus: system
     name: org.aethercast
+plugs:
+  dbus-client:
+    interface: dbus
+    bus: system
+    name: org.aethercast
 
 apps:
   aethercast:
     command: sbin/aethercast
+    plugs:
+      - dbus-client
+  service:
+    command: sbin/aethercast service
     daemon: simple
     slots:
       - dbus-service
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 8522a89..c55d44c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -21,6 +21,9 @@ set(HEADERS
   ac/config.cpp
   ac/config.h
 
+  ac/optional.h
+  ac/do_not_copy_or_move.h
+
   ac/common/executable.h
   ac/common/executor.h
   ac/common/executorfactory.h
@@ -53,6 +56,7 @@ set(ANDROID_SOURCES
     ac/android/h264encoder.cpp)
 
 set(SOURCES
+  ac/cli.cpp
   ac/types.cpp
   ac/utils.cpp
   ac/networkutils.cpp
@@ -69,6 +73,11 @@ set(SOURCES
   ac/networkmanagerfactory.cpp
   ac/networkdevice.cpp
 
+  ac/cmds/shell.cpp
+  ac/cmds/service.cpp
+
+  ac/client/application.cpp
+
   ac/dbus/helpers.cpp
   ac/dbus/errors.cpp
   ac/dbus/controllerskeleton.cpp
@@ -189,6 +198,8 @@ target_link_libraries(aethercast-core
   ${EGL_LIBRARIES}
   ${GLESV2_LDFLAGS}
   ${GLESV2_LIBRARIES}
+  ${READLINE_LDFLAGS}
+  ${READLINE_LIBRARIES}
   -ldl
 )
 
@@ -210,5 +221,3 @@ install(
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib/static
 )
-
-add_subdirectory(client)
diff --git a/src/ac/cli.cpp b/src/ac/cli.cpp
new file mode 100644
index 0000000..1129244
--- /dev/null
+++ b/src/ac/cli.cpp
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *
+ */
+
+#include <boost/format.hpp>
+#include <boost/program_options.hpp>
+
+#include "ac/cli.h"
+
+namespace cli = ac::cli;
+namespace po = boost::program_options;
+
+namespace {
+namespace pattern {
+static constexpr const char* help_for_command_with_subcommands =
+    "NAME:\n"
+    "    %1% - %2%\n"
+    "\n"
+    "USAGE:\n"
+    "    %3% [command options] [arguments...]";
+
+static constexpr const char* commands = "COMMANDS:";
+static constexpr const char* command = "    %1% %2%";
+
+static constexpr const char* options = "OPTIONS:";
+static constexpr const char* option = "    --%1% %2%";
+}
+
+void add_to_desc_for_flags(po::options_description& desc,
+                           const std::set<cli::Flag::Ptr>& flags) {
+  for (auto flag : flags) {
+    auto v = po::value<std::string>()->notifier(
+        [flag](const std::string& s) { flag->notify(s); });
+    desc.add_options()(flag->name().as_string().c_str(), v,
+                       flag->description().as_string().c_str());
+  }
+}
+}
+
+std::vector<std::string> cli::args(int argc, char** argv) {
+  std::vector<std::string> result;
+  for (int i = 1; i < argc; i++) result.push_back(argv[i]);
+  return result;
+}
+
+const cli::Name& cli::Flag::name() const { return name_; }
+
+const cli::Description& cli::Flag::description() const { return description_; }
+
+cli::Flag::Flag(const Name& name, const Description& description)
+    : name_{name}, description_{description} {}
+
+cli::Command::FlagsWithInvalidValue::FlagsWithInvalidValue()
+    : std::runtime_error{"Flags with invalid value"} {}
+
+cli::Command::FlagsMissing::FlagsMissing()
+    : std::runtime_error{"Flags are missing in command invocation"} {}
+
+cli::Name cli::Command::name() const { return name_; }
+
+cli::Usage cli::Command::usage() const { return usage_; }
+
+cli::Description cli::Command::description() const { return description_; }
+
+cli::Command::Command(const cli::Name& name, const cli::Usage& usage,
+                      const cli::Description& description)
+    : name_(name), usage_(usage), description_(description) {}
+
+cli::CommandWithSubcommands::CommandWithSubcommands(
+    const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description} {
+  command(std::make_shared<cmd::Help>(*this));
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::command(
+    const Command::Ptr& command) {
+  commands_[command->name().as_string()] = command;
+  return *this;
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::flag(
+    const Flag::Ptr& flag) {
+  flags_.insert(flag);
+  return *this;
+}
+
+void cli::CommandWithSubcommands::help(std::ostream& out) {
+  out << boost::format(pattern::help_for_command_with_subcommands) %
+             name().as_string() % usage().as_string() % name().as_string()
+      << std::endl;
+
+  if (flags_.size() > 0) {
+    out << std::endl
+        << pattern::options << std::endl;
+    for (const auto& flag : flags_)
+      out << boost::format(pattern::option) % flag->name() % flag->description()
+          << std::endl;
+  }
+
+  if (commands_.size() > 0) {
+    out << std::endl
+        << pattern::commands << std::endl;
+    for (const auto& cmd : commands_) {
+      if (cmd.second)
+        out << boost::format(pattern::command) % cmd.second->name() %
+                   cmd.second->description()
+            << std::endl;
+    }
+  }
+}
+
+int cli::CommandWithSubcommands::run(const cli::Command::Context& ctxt) {
+  po::positional_options_description pdesc;
+  pdesc.add("command", 1);
+
+  po::options_description desc("Options");
+  desc.add_options()("command", po::value<std::string>()->required(),
+                     "the command to be executed");
+
+  add_to_desc_for_flags(desc, flags_);
+
+  try {
+    po::variables_map vm;
+    auto parsed = po::command_line_parser(ctxt.args)
+                      .options(desc)
+                      .positional(pdesc)
+                      .style(po::command_line_style::unix_style)
+                      .allow_unregistered()
+                      .run();
+
+    po::store(parsed, vm);
+    po::notify(vm);
+
+    auto cmd = commands_[vm["command"].as<std::string>()];
+    if (!cmd) {
+      ctxt.cout << "Unknown command '" << vm["command"].as<std::string>() << "'"
+                << std::endl;
+      help(ctxt.cout);
+      return EXIT_FAILURE;
+    }
+
+    return cmd->run(cli::Command::Context{
+        ctxt.cin, ctxt.cout,
+        po::collect_unrecognized(parsed.options, po::include_positional)});
+  } catch (const po::error& e) {
+    ctxt.cout << e.what() << std::endl;
+    help(ctxt.cout);
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_FAILURE;
+}
+
+cli::CommandWithFlagsAndAction::CommandWithFlagsAndAction(
+    const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description} {}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::flag(
+    const Flag::Ptr& flag) {
+  flags_.insert(flag);
+  return *this;
+}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::action(
+    const Action& action) {
+  action_ = action;
+  return *this;
+}
+
+int cli::CommandWithFlagsAndAction::run(const Context& ctxt) {
+  po::options_description cd(name().as_string());
+
+  bool help_requested{false};
+  cd.add_options()("help", po::bool_switch(&help_requested),
+                   "produces a help message");
+
+  add_to_desc_for_flags(cd, flags_);
+
+  try {
+    po::variables_map vm;
+    auto parsed = po::command_line_parser(ctxt.args)
+                      .options(cd)
+                      .style(po::command_line_style::unix_style)
+                      .allow_unregistered()
+                      .run();
+    po::store(parsed, vm);
+    po::notify(vm);
+
+    if (help_requested) {
+      help(ctxt.cout);
+      return EXIT_SUCCESS;
+    }
+
+    return action_(cli::Command::Context{
+        ctxt.cin, ctxt.cout,
+        po::collect_unrecognized(parsed.options, po::include_positional)});
+  } catch (const po::error& e) {
+    ctxt.cout << e.what() << std::endl;
+    help(ctxt.cout);
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_FAILURE;
+}
+
+void cli::CommandWithFlagsAndAction::help(std::ostream& out) {
+  out << boost::format(pattern::help_for_command_with_subcommands) %
+             name().as_string() % description().as_string() % name().as_string()
+      << std::endl;
+
+  if (flags_.size() > 0) {
+    out << std::endl
+        << boost::format(pattern::options) << std::endl;
+    for (const auto& flag : flags_)
+      out << boost::format(pattern::option) % flag->name() % flag->description()
+          << std::endl;
+  }
+}
+
+cli::cmd::Help::Help(Command& cmd)
+    : Command{cli::Name{"help"}, cli::Usage{"prints a short help message"},
+              cli::Description{"prints a short help message"}},
+      command{cmd} {}
+
+// From Command
+int cli::cmd::Help::run(const Context& context) {
+  command.help(context.cout);
+  return EXIT_FAILURE;
+}
+
+void cli::cmd::Help::help(std::ostream& out) { command.help(out); }
diff --git a/src/ac/cli.h b/src/ac/cli.h
new file mode 100644
index 0000000..131965f
--- /dev/null
+++ b/src/ac/cli.h
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *
+ */
+#ifndef AETHERCAST_CLI_H_
+#define AETHERCAST_CLI_H_
+
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+
+#include "ac/do_not_copy_or_move.h"
+#include "ac/optional.h"
+
+namespace ac {
+namespace cli {
+
+template <std::size_t max>
+class SizeConstrainedString {
+ public:
+  SizeConstrainedString(const std::string& s) : s{s} {
+    if (s.size() > max)
+      throw std::logic_error{"Max size exceeded " + std::to_string(max)};
+  }
+
+  const std::string& as_string() const { return s; }
+
+  operator std::string() const { return s; }
+
+ private:
+  std::string s;
+};
+
+template <std::size_t max>
+bool operator<(const SizeConstrainedString<max>& lhs,
+               const SizeConstrainedString<max>& rhs) {
+  return lhs.as_string() < rhs.as_string();
+}
+
+template <std::size_t max>
+bool operator==(const SizeConstrainedString<max>& lhs,
+                const SizeConstrainedString<max>& rhs) {
+  return lhs.as_string() == rhs.as_string();
+}
+
+template <std::size_t max>
+std::ostream& operator<<(std::ostream& out,
+                         const SizeConstrainedString<max>& scs) {
+  return out << std::setw(max) << std::left << scs.as_string();
+}
+
+// We are imposing size constraints to ensure a consistent CLI layout.
+typedef SizeConstrainedString<20> Name;
+typedef SizeConstrainedString<60> Usage;
+typedef SizeConstrainedString<60> Description;
+
+/// @brief Flag models an input parameter to a command.
+class Flag : public DoNotCopyOrMove {
+ public:
+  // Safe us some typing.
+  typedef std::shared_ptr<Flag> Ptr;
+
+  /// @brief notify announces a new value to the flag.
+  virtual void notify(const std::string& value) = 0;
+  /// @brief name returns the name of the Flag.
+  const Name& name() const;
+  /// @brief description returns a human-readable description of the flag.
+  const Description& description() const;
+
+ protected:
+  /// @brief Flag creates a new instance, initializing name and description
+  /// from the given values.
+  Flag(const Name& name, const Description& description);
+
+ private:
+  Name name_;
+  Description description_;
+};
+
+/// @brief TypedFlag implements Flag relying on operator<< and operator>> to
+/// read/write values to/from strings.
+template <typename T>
+class TypedFlag : public Flag {
+ public:
+  typedef std::shared_ptr<TypedFlag<T>> Ptr;
+
+  TypedFlag(const Name& name, const Description& description)
+      : Flag{name, description} {}
+
+  /// @brief value installs the given value in the flag.
+  TypedFlag& value(const T& value) {
+    value_ = value;
+    return *this;
+  }
+
+  /// @brief value returns the optional value associated with the flag.
+  const Optional<T>& value() const { return value_; }
+
+  /// @brief notify tries to unwrap a value of type T from value.
+  void notify(const std::string& s) override {
+    std::stringstream ss{s};
+    T value;
+    ss >> value;
+    value_ = value;
+  }
+
+ private:
+  Optional<T> value_;
+};
+
+/// @brief TypedReferenceFlag implements Flag, relying on operator<</>> to
+/// convert to/from string representations,
+/// updating the given mutable reference to a value of type T.
+template <typename T>
+class TypedReferenceFlag : public Flag {
+ public:
+  // Safe us some typing.
+  typedef std::shared_ptr<TypedReferenceFlag<T>> Ptr;
+
+  /// @brief TypedReferenceFlag initializes a new instance with name,
+  /// description and value.
+  TypedReferenceFlag(const Name& name, const Description& description, T& value)
+      : Flag{name, description}, value_{value} {}
+
+  /// @brief notify tries to unwrap a value of type T from value,
+  /// relying on operator>> to read from given string s.
+  void notify(const std::string& s) override {
+    std::stringstream ss{s};
+    ss >> value_.get();
+  }
+
+ private:
+  std::reference_wrapper<T> value_;
+};
+
+/// @brief OptionalTypedReferenceFlag handles Optional<T> references, making
+/// sure that
+/// a value is always read on notify, even if the Optional<T> wasn't initialized
+/// previously.
+template <typename T>
+class OptionalTypedReferenceFlag : public Flag {
+ public:
+  typedef std::shared_ptr<OptionalTypedReferenceFlag<T>> Ptr;
+
+  OptionalTypedReferenceFlag(const Name& name, const Description& description,
+                             Optional<T>& value)
+      : Flag{name, description}, value_{value} {}
+
+  /// @brief notify tries to unwrap a value of type T from value.
+  void notify(const std::string& s) override {
+    std::stringstream ss{s};
+    T value;
+    ss >> value;
+    value_.get() = value;
+  }
+
+ private:
+  std::reference_wrapper<Optional<T>> value_;
+};
+
+/// @brief Command abstracts an individual command available from the daemon.
+class Command : public DoNotCopyOrMove {
+ public:
+  // Safe us some typing
+  typedef std::shared_ptr<Command> Ptr;
+
+  /// @brief FlagsMissing is thrown if at least one required flag is missing.
+  struct FlagsMissing : public std::runtime_error {
+    /// @brief FlagsMissing initializes a new instance.
+    FlagsMissing();
+  };
+
+  /// @brief FlagsWithWrongValue is thrown if a value passed on the command line
+  /// is invalid.
+  struct FlagsWithInvalidValue : public std::runtime_error {
+    /// @brief FlagsWithInvalidValue initializes a new instance.
+    FlagsWithInvalidValue();
+  };
+
+  /// @brief Context bundles information passed to Command::run invocations.
+  struct Context {
+    std::istream& cin;              ///< The std::istream that should be used for reading.
+    std::ostream& cout;             ///< The std::ostream that should be used for writing.
+    std::vector<std::string> args;  ///< The command line args.
+  };
+
+  /// @brief name returns the Name of the command.
+  virtual Name name() const;
+
+  /// @brief usage returns a short usage string for the command.
+  virtual Usage usage() const;
+
+  /// @brief description returns a longer string explaining the command.
+  virtual Description description() const;
+
+  /// @brief run puts the command to execution.
+  virtual int run(const Context& context) = 0;
+
+  /// @brief help prints information about a command to out.
+  virtual void help(std::ostream& out) = 0;
+
+ protected:
+  /// @brief Command initializes a new instance with the given name, usage and
+  /// description.
+  Command(const Name& name, const Usage& usage, const Description& description);
+
+  /// @brief name adjusts the name of the command to n.
+  // virtual void name(const Name& n);
+  /// @brief usage adjusts the usage string of the comand to u.
+  // virtual void usage(const Usage& u);
+  /// @brief description adjusts the description string of the command to d.
+  // virtual void description(const Description& d);
+
+ private:
+  Name name_;
+  Usage usage_;
+  Description description_;
+};
+
+/// @brief CommandWithSubcommands implements Command, selecting one of a set of
+/// actions.
+class CommandWithSubcommands : public Command {
+ public:
+  typedef std::shared_ptr<CommandWithSubcommands> Ptr;
+  typedef std::function<int(const Context&)> Action;
+
+  /// @brief CommandWithSubcommands initializes a new instance with the given
+  /// name, usage and description
+  CommandWithSubcommands(const Name& name, const Usage& usage,
+                         const Description& description);
+
+  /// @brief command adds the given command to the set of known commands.
+  CommandWithSubcommands& command(const Command::Ptr& command);
+
+  /// @brief flag adds the given flag to the set of known flags.
+  CommandWithSubcommands& flag(const Flag::Ptr& flag);
+
+  // From Command
+  int run(const Context& context) override;
+  void help(std::ostream& out) override;
+
+ private:
+  std::unordered_map<std::string, Command::Ptr> commands_;
+  std::set<Flag::Ptr> flags_;
+};
+
+/// @brief CommandWithFlagsAction implements Command, executing an Action after
+/// handling
+class CommandWithFlagsAndAction : public Command {
+ public:
+  typedef std::shared_ptr<CommandWithFlagsAndAction> Ptr;
+  typedef std::function<int(const Context&)> Action;
+
+  /// @brief CommandWithFlagsAndAction initializes a new instance with the given
+  /// name, usage and description
+  CommandWithFlagsAndAction(const Name& name, const Usage& usage,
+                            const Description& description);
+
+  /// @brief flag adds the given flag to the set of known flags.
+  CommandWithFlagsAndAction& flag(const Flag::Ptr& flag);
+
+  /// @brief action installs the given action.
+  CommandWithFlagsAndAction& action(const Action& action);
+
+  // From Command
+  int run(const Context& context) override;
+  void help(std::ostream& out) override;
+
+ private:
+  std::set<Flag::Ptr> flags_;
+  Action action_;
+};
+
+namespace cmd {
+/// @brief HelpFor prints a help message for the given command on execution.
+class Help : public Command {
+ public:
+  /// @brief HelpFor initializes a new instance with the given reference to a
+  /// cmd.
+  explicit Help(Command& cmd);
+
+  // From Command
+  int run(const Context& context) override;
+  void help(std::ostream& out) override;
+
+ private:
+  /// @cond
+  Command& command;
+  /// @endcond
+};
+}
+
+/// @brief args returns a vector of strings assembled from argc and argv.
+std::vector<std::string> args(int argc, char** argv);
+
+/// @brief make_flag returns a flag with the given name and description.
+template <typename T>
+typename TypedFlag<T>::Ptr make_flag(const Name& name,
+                                     const Description& description) {
+  return std::make_shared<TypedFlag<T>>(name, description);
+}
+
+/// @brief make_flag returns a flag with the given name and description,
+/// notifying updates to value.
+template <typename T>
+typename TypedReferenceFlag<T>::Ptr make_flag(const Name& name,
+                                              const Description& desc,
+                                              T& value) {
+  return std::make_shared<TypedReferenceFlag<T>>(name, desc, value);
+}
+
+/// @brief make_flag returns a flag with the given name and description,
+/// updating the given optional value.
+template <typename T>
+typename OptionalTypedReferenceFlag<T>::Ptr make_flag(const Name& name,
+                                                      const Description& desc,
+                                                      Optional<T>& value) {
+  return std::make_shared<OptionalTypedReferenceFlag<T>>(name, desc, value);
+}
+
+}  // namespace cli
+}  // namespace ac
+
+#endif
diff --git a/src/ac/client/application.cpp b/src/ac/client/application.cpp
new file mode 100644
index 0000000..9fef06b
--- /dev/null
+++ b/src/ac/client/application.cpp
@@ -0,0 +1,541 @@
+/*
+ *  Copyright (C) 2015 Canonical, Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <memory>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <sstream>
+
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include "ac/glib_wrapper.h"
+
+#include "application.h"
+
+using namespace std::placeholders;
+
+namespace {
+const unsigned int kDBusTimeout = 120;
+
+class PromptSaver {
+public:
+    PromptSaver() {
+        save_input_ = !RL_ISSTATE(RL_STATE_DONE);
+        if (save_input_) {
+            saved_point_ = rl_point;
+            saved_line_ = rl_copy_text(0, rl_end);
+            rl_save_prompt();
+            rl_replace_line("", 0);
+            rl_redisplay();
+        }
+    }
+
+    ~PromptSaver() {
+        if (save_input_) {
+            rl_restore_prompt();
+            rl_replace_line(saved_line_, 0);
+            rl_point = saved_point_;
+            rl_redisplay();
+            g_free(saved_line_);
+        }
+    }
+
+private:
+    bool save_input_;
+    int saved_point_;
+    char *saved_line_;
+};
+}
+
+namespace ac {
+namespace client {
+
+GMainLoop *Application::main_loop_ = nullptr;
+std::map<std::string,Application::Command> Application::available_commands_ = { };
+
+int Application::Main(const MainOptions &options) {
+    Application app;
+    return app.Run();
+}
+
+Application::Application() :
+    bus_connection_(nullptr),
+    manager_(nullptr),
+    input_source_(0),
+    object_manager_(nullptr) {
+
+    rl_callback_handler_install("aethercastctl> ", &Application::OnReadlineMessage);
+
+    main_loop_ = g_main_loop_new(nullptr, FALSE);
+
+    GError *error = nullptr;
+    bus_connection_ = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+    if (!bus_connection_) {
+        std::cerr << "Failed to connect to system bus: " << error->message << std::endl;
+        g_error_free(error);
+        return;
+    }
+
+    g_bus_watch_name_on_connection(bus_connection_, "org.aethercast",
+                                   G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                   &Application::OnServiceFound,
+                                   &Application::OnServiceLost,
+                                   this, nullptr);
+
+    g_dbus_connection_signal_subscribe(bus_connection_, "org.aethercast", "org.freedesktop.DBus.Properties", "PropertiesChanged", "/org/aethercast", nullptr,
+                                       G_DBUS_SIGNAL_FLAGS_NONE, &Application::OnManagerPropertiesChanged, this, nullptr);
+
+    RegisterCommand(Command { "enable", "", "Enable manager", std::bind(&Application::HandleEnableCommand, this, _1) });
+    RegisterCommand(Command { "disable", "", "Disable manager", std::bind(&Application::HandleDisableCommand, this, _1) });
+    RegisterCommand(Command { "show", "", "Show manager properties", std::bind(&Application::HandleShowCommand, this, _1) });
+    RegisterCommand(Command { "scan", "", "Scan for devices", std::bind(&Application::HandleScanCommand, this, _1) });
+    RegisterCommand(Command { "devices", "", "List available devices", std::bind(&Application::HandleDevicesCommand, this, _1) });
+    RegisterCommand(Command { "info", "<address>", "Show device information", std::bind(&Application::HandleInfoCommand, this, _1) });
+    RegisterCommand(Command { "connect", "<address>", "Connect a device", std::bind(&Application::HandleConnectCommand, this, _1) });
+    RegisterCommand(Command { "disconnect", "<address>", "Disconnect a device", std::bind(&Application::HandleDisconnectCommand, this, _1) });
+}
+
+Application::~Application() {
+    rl_message();
+    rl_callback_handler_remove();
+
+    g_object_unref(bus_connection_);
+    g_main_loop_unref(main_loop_);
+
+    if (manager_)
+        g_object_unref(manager_);
+
+    if (input_source_ > 0)
+        g_source_remove(input_source_);
+}
+
+int Application::Run() {
+    g_main_loop_run(main_loop_);
+    return 0;
+}
+
+void Application::RegisterCommand(const Command &command) {
+    available_commands_[command.name] = command;
+}
+
+void Application::HandleEnableCommand(const std::string &arguments) {
+    if (!manager_)
+        return;
+
+    aethercast_interface_manager_set_enabled(manager_, true);
+}
+
+void Application::HandleDisableCommand(const std::string &arguments) {
+    if (!manager_)
+        return;
+
+    aethercast_interface_manager_set_enabled(manager_, false);
+}
+
+void Application::HandleShowCommand(const std::string &arguments) {
+    if (!manager_)
+        return;
+
+    auto enabled = aethercast_interface_manager_get_enabled(manager_);
+    std::cout << "Enabled: " << std::boolalpha << (bool) enabled << std::endl;
+
+    auto state = aethercast_interface_manager_get_state(manager_);
+    std::cout << "State: " << state << std::endl;
+
+    auto scanning = aethercast_interface_manager_get_scanning(manager_);
+    std::cout << "Scanning: " << std::boolalpha << (bool) scanning << std::endl;
+
+    auto capabilities = aethercast_interface_manager_get_capabilities(manager_);
+    std::cout << "Capabilities:" << std::endl;
+    for (int n = 0; capabilities[n] != nullptr; n++)
+        std::cout << "  " << capabilities[n] << std::endl;
+}
+
+void Application::OnScanDone(GObject *object, GAsyncResult *res, gpointer user_data) {
+    auto inst = static_cast<Application*>(user_data);
+
+    GError *error = nullptr;
+    if (!aethercast_interface_manager_call_scan_finish(inst->manager_, res, &error)) {
+        std::cerr << "Failed to scan:" << error->message << std::endl;
+        g_error_free(error);
+        return;
+    }
+}
+
+void Application::HandleScanCommand(const std::string &arguments) {
+    if (!manager_)
+        return;
+
+    aethercast_interface_manager_call_scan(manager_, nullptr, &Application::OnScanDone, this);
+}
+
+void Application::ForeachDevice(std::function<void(AethercastInterfaceDevice*)> callback, const std::string &address_filter) {
+    if (!callback)
+        return;
+
+    auto objects = g_dbus_object_manager_get_objects(object_manager_);
+
+    for (auto obj = objects; obj != nullptr; obj = obj->next) {
+        auto device = AETHERCAST_INTERFACE_OBJECT_PROXY(obj->data);
+        if (!device)
+            continue;
+
+        auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(device), "org.aethercast.Device");
+        if (!iface)
+            continue;
+
+        auto device_obj = AETHERCAST_INTERFACE_DEVICE(iface);
+
+        if (address_filter.length() > 0) {
+            auto device_address = aethercast_interface_device_get_address(device_obj);
+            if (address_filter != device_address)
+                continue;
+        }
+
+        callback(device_obj);
+    }
+}
+
+void Application::HandleDevicesCommand(const std::string &arguments) {
+    ForeachDevice([=](AethercastInterfaceDevice *device) {
+        auto address = aethercast_interface_device_get_address(device);
+        auto name = aethercast_interface_device_get_name(device);
+        std::cout << "Device " << address << " " << name << std::endl;
+    });
+}
+
+void Application::HandleInfoCommand(const std::string &arguments) {
+    if (arguments.length() == 0) {
+        std::cerr << "No device address supplied" << std::endl;
+        return;
+    }
+
+    bool found = false;
+
+    ForeachDevice([&](AethercastInterfaceDevice *device) {
+        auto address = aethercast_interface_device_get_address(device);
+        std::cout << "Address: " << address << std::endl;
+
+        auto name = aethercast_interface_device_get_name(device);
+        std::cout << "Name: " << name << std::endl;
+
+        auto state = aethercast_interface_device_get_state(device);
+        std::cout << "State: " << state << std::endl;
+
+        auto capabilities = aethercast_interface_device_get_capabilities(device);
+        std::cout << "Capabilities: " << std::endl;
+        for (int n = 0; capabilities[n] != nullptr; n++)
+            std::cout << "  " << capabilities[n] << std::endl;
+
+        found = true;
+    }, arguments);
+
+    if (!found)
+        std::cerr << "Unknown or invalid device address" << std::endl;
+}
+
+void Application::OnDeviceConnected(GObject *object, GAsyncResult *res, gpointer user_data) {
+    PromptSaver ps;
+
+    GError *error = nullptr;
+    if (!aethercast_interface_device_call_connect_finish(AETHERCAST_INTERFACE_DEVICE(object), res, &error)) {
+        std::cerr << "Failed to connect with device: " << error->message << std::endl;
+        g_error_free(error);
+        return;
+    }
+}
+
+void Application::HandleConnectCommand(const std::string &arguments) {
+    PromptSaver ps;
+
+    if (arguments.length() == 0) {
+        std::cerr << "No device address supplied" << std::endl;
+        return;
+    }
+
+    bool found = false;
+
+    ForeachDevice([&](AethercastInterfaceDevice *device) {
+
+        aethercast_interface_device_call_connect(device, "sink", nullptr,
+                                               &Application::OnDeviceConnected, nullptr);
+
+        found = true;
+    }, arguments);
+
+    if (!found)
+        std::cerr << "Unknown or invalid device address" << std::endl;
+}
+
+void Application::OnDeviceDisconnected(GObject *object, GAsyncResult *res, gpointer user_data) {
+    PromptSaver ps;
+
+    GError *error = nullptr;
+    if (!aethercast_interface_device_call_disconnect_finish(AETHERCAST_INTERFACE_DEVICE(object), res, &error)) {
+        std::cerr << "Failed to disconnect from device: " << error->message << std::endl;
+        g_error_free(error);
+        return;
+    }
+}
+
+void Application::HandleDisconnectCommand(const std::string &arguments) {
+    PromptSaver ps;
+
+    if (arguments.length() == 0) {
+        std::cerr << "No device address supplied" << std::endl;
+        return;
+    }
+
+    bool found = false;
+
+    ForeachDevice([&](AethercastInterfaceDevice *device) {
+
+        aethercast_interface_device_call_disconnect(device, nullptr,
+                                               &Application::OnDeviceDisconnected, nullptr);
+
+        found = true;
+    }, arguments);
+
+    if (!found)
+        std::cerr << "Unknown or invalid device address" << std::endl;
+}
+
+void Application::SetupStandardInput() {
+    GIOChannel *channel;
+
+    channel = g_io_channel_unix_new(fileno(stdin));
+
+    input_source_ = g_io_add_watch(channel,
+                            (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL),
+                            &Application::OnUserInput, this);
+
+    g_io_channel_unref(channel);
+
+}
+
+gboolean Application::OnUserInput(GIOChannel *channel, GIOCondition condition, gpointer user_data) {
+    auto inst = static_cast<Application*>(user_data);
+
+    if (condition & G_IO_IN) {
+        rl_callback_read_char();
+        return TRUE;
+    }
+
+    if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+        g_main_loop_quit(inst->main_loop_);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+void Application::OnReadlineMessage(char *input) {
+    PromptSaver ps;
+
+    char *arg;
+    int i;
+
+    if (!input) {
+        rl_newline(1, '\n');
+        g_main_loop_quit(main_loop_);
+        return;
+    }
+
+    std::string cmd = strtok_r(input, " ", &arg) ? : "";
+    if (cmd.size() == 0)
+        return;
+
+    if (arg) {
+        int len = strlen(arg);
+        if (len > 0 && arg[len - 1] == ' ')
+            arg[len - 1] = '\0';
+    }
+
+    auto iter = available_commands_.find(cmd);
+    if (iter != available_commands_.end()) {
+        if (iter->second.func)
+            iter->second.func(arg);
+    }
+    else if (cmd == "help") {
+        std::cout << "Available commands:" << std::endl;
+
+        for (auto cmd : available_commands_) {
+            if (cmd.second.description.size() == 0)
+                continue;
+
+            fprintf(stdout, " %s %-*s %s\n", cmd.second.name.c_str(),
+                   (int)(25 - cmd.second.name.length()),
+                   cmd.second.arguments.c_str(),
+                   cmd.second.description.c_str());
+        }
+    }
+    else {
+        std::cerr << "Invalid command" << std::endl;
+    }
+
+    g_free(input);
+}
+
+void Application::OnServiceLost(GDBusConnection *connection, const gchar *name, gpointer user_data) {
+    auto inst = static_cast<Application*>(user_data);
+
+    if (inst->input_source_ > 0) {
+        g_source_remove(inst->input_source_);
+        inst->input_source_ = 0;
+    }
+
+    if (inst->manager_) {
+        g_object_unref(inst->manager_);
+        inst->manager_ = nullptr;
+    }
+
+    if (inst->object_manager_) {
+        g_object_unref(inst->object_manager_);
+        inst->object_manager_ = nullptr;
+    }
+}
+
+void Application::OnServiceFound(GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data) {
+    auto inst = static_cast<Application*>(user_data);
+
+    aethercast_interface_manager_proxy_new(inst->bus_connection_, G_DBUS_PROXY_FLAGS_NONE,
+                                         "org.aethercast", "/org/aethercast", nullptr,
+                                         &Application::OnManagerConnected, inst);
+}
+
+void Application::OnManagerConnected(GObject *object, GAsyncResult *res, gpointer user_data) {
+    PromptSaver ps;
+
+    auto inst = static_cast<Application*>(user_data);
+
+    GError *error = nullptr;
+    inst->manager_ = aethercast_interface_manager_proxy_new_finish(res, &error);
+    if (!inst->manager_) {
+        std::cerr << "Could not connect with manager: " << error->message << std::endl;
+        g_error_free(error);
+        g_main_loop_quit(inst->main_loop_);
+        return;
+    }
+
+    // Use a high enough timeout to make sure we wait enough for the service to
+    // respond as the connection process can take some time depending on different
+    // factors.
+    g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(inst->manager_), kDBusTimeout * 1000);
+
+    aethercast_interface_object_manager_client_new(inst->bus_connection_,
+                             G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
+                             "org.aethercast", "/org/aethercast",
+                             nullptr, &Application::OnObjectManagerCreated, inst);
+}
+
+void Application::OnManagerPropertiesChanged(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
+                                             const gchar *interface_name, const gchar *signal_name, GVariant *parameters,
+                                             gpointer user_data) {
+    PromptSaver ps;
+
+    if (g_variant_n_children(parameters) != 3)
+        return;
+
+    GVariant *changed_props = g_variant_get_child_value(parameters, 1);
+    for (int n = 0; n < g_variant_n_children(changed_props); n++) {
+        auto element = g_variant_get_child_value(changed_props, n);
+        auto key_v = g_variant_get_child_value(element, 0);
+        auto value_v = g_variant_get_child_value(element, 1);
+
+        auto key = std::string(g_variant_get_string(key_v, nullptr));
+
+        std::cout << "[CHG] Manager " << key << " changed: ";
+
+        if (key == "Enabled")
+            std::cout << std::boolalpha << (bool) g_variant_get_boolean(g_variant_get_variant(value_v)) << std::endl;
+        else if (key == "State")
+            std::cout << g_variant_get_string(g_variant_get_variant(value_v), nullptr) << std::endl;
+        else if (key == "Scanning")
+            std::cout << std::boolalpha << (bool) g_variant_get_boolean(g_variant_get_variant(value_v)) << std::endl;
+        else if (key == "Capabilities") {
+            std::stringstream capabilities;
+
+            for (int m = 0; m < g_variant_n_children(value_v); m++) {
+                auto capability = g_variant_get_child_value(value_v, m);
+                if (!g_variant_is_of_type(capability, G_VARIANT_TYPE_STRING))
+                    continue;
+
+                capabilities << g_variant_get_string(capability, nullptr) << " ";
+            }
+
+            std::cout << capabilities.str() << std::endl;
+        }
+        else
+            std::cout << "unknown" << std::endl;
+
+        g_variant_unref(key_v);
+        g_variant_unref(value_v);
+    }
+}
+
+void Application::OnDeviceAdded(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data) {
+    PromptSaver ps;
+
+    auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(object), "org.aethercast.Device");
+    if (!iface)
+        return;
+
+    auto device = AETHERCAST_INTERFACE_DEVICE(iface);
+
+    auto address = aethercast_interface_device_get_address(device);
+    auto name = aethercast_interface_device_get_name(device);
+
+    std::cout << "Device " << address << " " << name << " added" << std::endl;
+}
+
+void Application::OnDeviceRemoved(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data) {
+    PromptSaver ps;
+
+    auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(object), "org.aethercast.Device");
+    if (!iface)
+        return;
+
+    auto device = AETHERCAST_INTERFACE_DEVICE(iface);
+
+    auto address = aethercast_interface_device_get_address(device);
+    auto name = aethercast_interface_device_get_name(device);
+
+    std::cout << "Device " << address << " " << name <<" removed" << std::endl;
+}
+
+void Application::OnObjectManagerCreated(GObject *object, GAsyncResult *res, gpointer user_data) {
+    auto inst = static_cast<Application*>(user_data);
+
+    GError *error = nullptr;
+    inst->object_manager_ = aethercast_interface_object_manager_client_new_finish(res, &error);
+    if (!inst->object_manager_) {
+        g_error_free(error);
+        return;
+    }
+
+    g_signal_connect(inst->object_manager_, "object-added", G_CALLBACK(&Application::OnDeviceAdded), inst);
+    g_signal_connect(inst->object_manager_, "object-removed", G_CALLBACK(&Application::OnDeviceRemoved), inst);
+
+    inst->SetupStandardInput();
+}
+
+} // namespace client
+} // namespace ac
diff --git a/src/ac/client/application.h b/src/ac/client/application.h
new file mode 100644
index 0000000..a7b3d5a
--- /dev/null
+++ b/src/ac/client/application.h
@@ -0,0 +1,112 @@
+/*
+ *  Copyright (C) 2015 Canonical, Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef APPLICATION_H_
+#define APPLICATION_H_
+
+#include <map>
+#include <functional>
+
+#include "ac/glib_wrapper.h"
+
+extern "C" {
+// Ignore all warnings coming from the external headers as we don't
+// control them and also don't want to get any warnings from them
+// which will only pollute our build output.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic warning "-w"
+#include "aethercastinterface.h"
+#pragma GCC diagnostic pop
+}
+
+namespace ac {
+namespace client {
+
+class Application {
+public:
+    struct MainOptions {};
+
+    static int Main(const MainOptions &options);
+
+    Application();
+    ~Application();
+
+    int Run();
+
+private:
+    struct Command {
+        std::string name;
+        std::string arguments;
+        std::string description;
+        std::function<void(std::string)> func;
+    };
+
+    void HandleEnableCommand(const std::string &arguments);
+    void HandleDisableCommand(const std::string &arguments);
+    void HandleShowCommand(const std::string &arguments);
+    void HandleScanCommand(const std::string &arguments);
+    void HandleDevicesCommand(const std::string &arguments);
+    void HandleInfoCommand(const std::string &arguments);
+    void HandleConnectCommand(const std::string &arguments);
+    void HandleDisconnectCommand(const std::string &arguments);
+
+    void RegisterCommand(const Command &command);
+
+private:
+    static gboolean OnUserInput(GIOChannel *channel, GIOCondition condition, gpointer user_data);
+    static void OnReadlineMessage(char *input);
+    static void OnServiceLost(GDBusConnection *connection, const gchar *name, gpointer user_data);
+    static void OnServiceFound(GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data);
+    static void OnManagerConnected(GObject *object, GAsyncResult *res, gpointer user_data);
+    static void OnDeviceAdded(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data);
+    static void OnDeviceRemoved(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data);
+    static void OnObjectManagerCreated(GObject *object, GAsyncResult *res, gpointer user_data);
+
+    static void OnManagerPropertiesChanged(GDBusConnection *connection,
+                                           const gchar *sender_name,
+                                           const gchar *object_path,
+                                           const gchar *interface_name,
+                                           const gchar *signal_name,
+                                           GVariant *parameters,
+                                           gpointer user_data);
+
+    static void OnScanDone(GObject *object, GAsyncResult *res, gpointer user_data);
+    static void OnDeviceConnected(GObject *object, GAsyncResult *res, gpointer user_data);
+    static void OnDeviceDisconnected(GObject *object, GAsyncResult *res, gpointer user_data);
+private:
+    void SetupStandardInput();
+    void ForeachDevice(std::function<void(AethercastInterfaceDevice*)> callback, const std::string &address_filter = "");
+
+private:
+    GDBusConnection *bus_connection_;
+    AethercastInterfaceManager *manager_;
+    guint input_source_;
+    GDBusObjectManager *object_manager_;
+
+private:
+    // Needs to be static otherwise we can't access it from the readline
+    // callback function (which sadly doesn't allow passing any user data)
+    static GMainLoop *main_loop_;
+    static std::map<std::string,Command> available_commands_;
+};
+
+} // namespace client
+} // namespace ac
+
+#endif
diff --git a/src/ac/cmds/service.cpp b/src/ac/cmds/service.cpp
new file mode 100644
index 0000000..36c146e
--- /dev/null
+++ b/src/ac/cmds/service.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2017 Simon Fels <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ac/cmds/service.h"
+#include "ac/service.h"
+
+ac::cmds::Service::Service()
+    : CommandWithFlagsAndAction{
+          cli::Name{"service"}, cli::Usage{"service"},
+          cli::Description{"Start the background service"}} {
+    action([](const cli::Command::Context&) {
+        return ac::Service::Main(ac::Service::MainOptions{});
+    });
+}
diff --git a/src/ac/cmds/service.h b/src/ac/cmds/service.h
new file mode 100644
index 0000000..541a868
--- /dev/null
+++ b/src/ac/cmds/service.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef AETHERCAST_CMDS_SERVICE_H_
+#define AETHERCAST_CMDS_SERVICE_H_
+
+#include "ac/cli.h"
+
+namespace ac {
+namespace cmds {
+class Service : public cli::CommandWithFlagsAndAction {
+public:
+    Service();
+};
+}  // namespace cmds
+}  // namespace ac
+
+#endif
diff --git a/src/ac/cmds/shell.cpp b/src/ac/cmds/shell.cpp
new file mode 100644
index 0000000..b3e1127
--- /dev/null
+++ b/src/ac/cmds/shell.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "ac/cmds/shell.h"
+#include "ac/client/application.h"
+
+ac::cmds::Shell::Shell()
+    : CommandWithFlagsAndAction{
+          cli::Name{"shell"}, cli::Usage{"shell"},
+          cli::Description{"Start the interactive shell"}} {
+    action([](const cli::Command::Context&) {
+        return ac::client::Application::Main(ac::client::Application::MainOptions{});
+    });
+}
diff --git a/src/ac/cmds/shell.h b/src/ac/cmds/shell.h
new file mode 100644
index 0000000..a4d905b
--- /dev/null
+++ b/src/ac/cmds/shell.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef AETHERCAST_CMDS_SHELL_H_
+#define AETHERCAST_CMDS_SHELL_H_
+
+#include "ac/cli.h"
+
+namespace ac {
+namespace cmds {
+class Shell : public cli::CommandWithFlagsAndAction {
+public:
+    Shell();
+};
+}  // namespace cmds
+}  // namespace ac
+
+#endif
diff --git a/src/ac/do_not_copy_or_move.h b/src/ac/do_not_copy_or_move.h
new file mode 100644
index 0000000..944c649
--- /dev/null
+++ b/src/ac/do_not_copy_or_move.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef AETHERCAST_DO_NOT_COPY_OR_MOVE_H_
+#define AETHERCAST_DO_NOT_COPY_OR_MOVE_H_
+
+namespace ac {
+
+class DoNotCopyOrMove {
+ public:
+  DoNotCopyOrMove(const DoNotCopyOrMove&) = delete;
+  DoNotCopyOrMove(DoNotCopyOrMove&&) = delete;
+  virtual ~DoNotCopyOrMove() = default;
+  DoNotCopyOrMove& operator=(const DoNotCopyOrMove&) = delete;
+  DoNotCopyOrMove& operator=(DoNotCopyOrMove&&) = delete;
+
+ protected:
+  DoNotCopyOrMove() = default;
+};
+}
+
+#endif
diff --git a/src/ac/main.cpp b/src/ac/main.cpp
index 8fa7842..7fa1990 100644
--- a/src/ac/main.cpp
+++ b/src/ac/main.cpp
@@ -15,8 +15,21 @@
  *
  */
 
-#include "service.h"
+#include "ac/cli.h"
+#include "ac/utils.h"
+#include "ac/cmds/shell.h"
+#include "ac/cmds/service.h"
 
 int main(int argc, char **argv) {
-    return ac::Service::Main(ac::Service::MainOptions::FromCommandLine(argc, argv));
+    ac::cli::CommandWithSubcommands cmd{ac::cli::Name{"aethercast"},
+                                        ac::cli::Usage{"aethercast"},
+                                        ac::cli::Description{"The Display Casting Service"}};
+    cmd.command(std::make_shared<ac::cmds::Shell>());
+    cmd.command(std::make_shared<ac::cmds::Service>());
+
+    auto arguments = ac::Utils::CollectArguments(argc, argv);
+    if (arguments.size() == 0)
+        arguments = {"shell"};
+
+    return cmd.run({std::cin, std::cout, arguments});
 }
diff --git a/src/ac/optional.h b/src/ac/optional.h
new file mode 100644
index 0000000..56b0e55
--- /dev/null
+++ b/src/ac/optional.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *
+ */
+
+#ifndef AETHERCAST_OPTIONAL_H_
+#define AETHERCAST_OPTIONAL_H_
+
+#include <boost/optional.hpp>
+#include <boost/optional/optional_io.hpp>
+
+namespace ac {
+template <typename T>
+using Optional = boost::optional<T>;
+}
+
+#endif
diff --git a/src/ac/service.cpp b/src/ac/service.cpp
index 2293560..76b5494 100644
--- a/src/ac/service.cpp
+++ b/src/ac/service.cpp
@@ -62,33 +62,6 @@ void SafeLog (const char *format, ...)
 }
 }
 namespace ac {
-Service::MainOptions Service::MainOptions::FromCommandLine(int argc, char** argv) {
-    static gboolean option_debug{FALSE};
-    static gboolean option_version{FALSE};
-
-    static GOptionEntry options[] = {
-        { "debug", 'd', 0, G_OPTION_ARG_NONE, &option_debug, "Enable debugging mode", nullptr },
-        { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version, "Show version information and exit", nullptr },
-        { NULL },
-    };
-
-    std::shared_ptr<GOptionContext> context{g_option_context_new(nullptr), [](GOptionContext *ctxt) { g_option_context_free(ctxt); }};
-    GError *error = nullptr;
-
-    g_option_context_add_main_entries(context.get(), options, NULL);
-
-    if (!g_option_context_parse(context.get(), &argc, &argv, &error)) {
-        if (error) {
-            g_printerr("%s\n", error->message);
-            g_error_free(error);
-        } else
-            g_printerr("An unknown error occurred\n");
-        exit(1);
-    }
-
-    return MainOptions{option_debug == TRUE, option_version == TRUE};
-}
-
 int Service::Main(const Service::MainOptions &options) {
     if (options.print_version) {
         std::printf("%d.%d\n", Service::kVersionMajor, Service::kVersionMinor);
diff --git a/src/ac/service.h b/src/ac/service.h
index 94ecb4c..fd23d16 100644
--- a/src/ac/service.h
+++ b/src/ac/service.h
@@ -46,8 +46,6 @@ public:
     typedef std::shared_ptr<Service> Ptr;
 
     struct MainOptions {
-        static MainOptions FromCommandLine(int argc, char** argv);
-
         bool debug;
         bool print_version;
     };
diff --git a/src/ac/utils.cpp b/src/ac/utils.cpp
index c89c3a9..0bf497c 100644
--- a/src/ac/utils.cpp
+++ b/src/ac/utils.cpp
@@ -30,6 +30,12 @@
 #include "utils.h"
 
 namespace ac {
+std::vector<std::string> Utils::CollectArguments(int argc, char **argv) {
+  std::vector<std::string> result;
+  for (int i = 1; i < argc; i++) result.push_back(argv[i]);
+  return result;
+}
+
 bool Utils::StringStartsWith(const std::string &text, const std::string &prefix) {
     return text.compare(0, prefix.size(), prefix) == 0;
 }
diff --git a/src/ac/utils.h b/src/ac/utils.h
index 847d7d2..d649e8f 100644
--- a/src/ac/utils.h
+++ b/src/ac/utils.h
@@ -33,6 +33,8 @@ struct Utils
     // Merely used as a namespace.
     Utils() = delete;
 
+    // Convert plain array into std::vector with strings
+    static std::vector<std::string> CollectArguments(int argc, char **argv);
     // StringStartsWith returns true iff text[0:prefix.size()-1] == prefix.
     static bool StringStartsWith(const std::string &text, const std::string &prefix);
     // ParseHex parses an integer with base 16 from str.
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
deleted file mode 100644
index 2d8588e..0000000
--- a/src/client/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-set(SOURCES
-    main.cpp
-    application.cpp
-)
-
-link_directories(
-  ${GLIB_LIBRARY_DIRS}
-  ${GIO_LIBRARY_DIRS}
-  ${GIO-UNIX_LIBRARY_DIRS}
-)
-
-include_directories(
-  ${Boost_INCLUDE_DIRS}
-  ${GLIB_INCLUDE_DIRS}
-  ${GIO_INCLUDE_DIRS}
-  ${GIO-UNIX_INCLUDE_DIRS}
-  ${READLINE_INCLUDE_DIRS}
-  ${CMAKE_CURRENT_SOURCE_DIR}/../
-  ${CMAKE_CURRENT_BINARY_DIR}/src
-)
-
-add_executable(aethercastctl ${SOURCES})
-target_link_libraries(aethercastctl
-  aethercast-gdbus-wrapper
-  ${Boost_LIBRARIES}
-  ${GLIB_LIBRARIES}
-  ${GIO_LIBRARIES}
-  ${GIO-UNIX_LIBRARIES}
-  ${READLINE_LIBRARIES}
-  -ldl
-)
-
-install(
-  TARGETS aethercastctl
-  RUNTIME DESTINATION bin
-)
diff --git a/src/client/application.cpp b/src/client/application.cpp
deleted file mode 100644
index 5471586..0000000
--- a/src/client/application.cpp
+++ /dev/null
@@ -1,564 +0,0 @@
-/*
- *  Copyright (C) 2015 Canonical, Ltd.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <memory>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <sstream>
-
-#include <readline/readline.h>
-#include <readline/history.h>
-
-#include "ac/glib_wrapper.h"
-
-#include "application.h"
-
-using namespace std::placeholders;
-
-namespace {
-const unsigned int kDBusTimeout = 120;
-
-class PromptSaver {
-public:
-    PromptSaver() {
-        save_input_ = !RL_ISSTATE(RL_STATE_DONE);
-        if (save_input_) {
-            saved_point_ = rl_point;
-            saved_line_ = rl_copy_text(0, rl_end);
-            rl_save_prompt();
-            rl_replace_line("", 0);
-            rl_redisplay();
-        }
-    }
-
-    ~PromptSaver() {
-        if (save_input_) {
-            rl_restore_prompt();
-            rl_replace_line(saved_line_, 0);
-            rl_point = saved_point_;
-            rl_redisplay();
-            g_free(saved_line_);
-        }
-    }
-
-private:
-    bool save_input_;
-    int saved_point_;
-    char *saved_line_;
-};
-}
-
-namespace ac {
-namespace client {
-
-GMainLoop *Application::main_loop_ = nullptr;
-std::map<std::string,Application::Command> Application::available_commands_ = { };
-
-Application::MainOptions Application::MainOptions::FromCommandLine(int argc, char** argv) {
-
-    static GOptionEntry options[] = {
-        { NULL },
-    };
-
-    std::shared_ptr<GOptionContext> context{g_option_context_new(nullptr), [](GOptionContext *ctxt) { g_option_context_free(ctxt); }};
-    GError *error = nullptr;
-
-    g_option_context_add_main_entries(context.get(), options, NULL);
-
-    if (!g_option_context_parse(context.get(), &argc, &argv, &error)) {
-        if (error) {
-            std::cerr << error->message << std::endl;
-            g_error_free(error);
-        } else
-            std::cerr << "An unknown error occured" << std::endl;
-        exit(1);
-    }
-
-    return MainOptions{};
-}
-
-int Application::Main(const MainOptions &options) {
-    Application app;
-    return app.Run();
-}
-
-Application::Application() :
-    bus_connection_(nullptr),
-    manager_(nullptr),
-    input_source_(0),
-    object_manager_(nullptr) {
-
-    rl_callback_handler_install("aethercastctl> ", &Application::OnReadlineMessage);
-
-    main_loop_ = g_main_loop_new(nullptr, FALSE);
-
-    GError *error = nullptr;
-    bus_connection_ = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
-    if (!bus_connection_) {
-        std::cerr << "Failed to connect to system bus: " << error->message << std::endl;
-        g_error_free(error);
-        return;
-    }
-
-    g_bus_watch_name_on_connection(bus_connection_, "org.aethercast",
-                                   G_BUS_NAME_WATCHER_FLAGS_NONE,
-                                   &Application::OnServiceFound,
-                                   &Application::OnServiceLost,
-                                   this, nullptr);
-
-    g_dbus_connection_signal_subscribe(bus_connection_, "org.aethercast", "org.freedesktop.DBus.Properties", "PropertiesChanged", "/org/aethercast", nullptr,
-                                       G_DBUS_SIGNAL_FLAGS_NONE, &Application::OnManagerPropertiesChanged, this, nullptr);
-
-    RegisterCommand(Command { "enable", "", "Enable manager", std::bind(&Application::HandleEnableCommand, this, _1) });
-    RegisterCommand(Command { "disable", "", "Disable manager", std::bind(&Application::HandleDisableCommand, this, _1) });
-    RegisterCommand(Command { "show", "", "Show manager properties", std::bind(&Application::HandleShowCommand, this, _1) });
-    RegisterCommand(Command { "scan", "", "Scan for devices", std::bind(&Application::HandleScanCommand, this, _1) });
-    RegisterCommand(Command { "devices", "", "List available devices", std::bind(&Application::HandleDevicesCommand, this, _1) });
-    RegisterCommand(Command { "info", "<address>", "Show device information", std::bind(&Application::HandleInfoCommand, this, _1) });
-    RegisterCommand(Command { "connect", "<address>", "Connect a device", std::bind(&Application::HandleConnectCommand, this, _1) });
-    RegisterCommand(Command { "disconnect", "<address>", "Disconnect a device", std::bind(&Application::HandleDisconnectCommand, this, _1) });
-}
-
-Application::~Application() {
-    rl_message();
-    rl_callback_handler_remove();
-
-    g_object_unref(bus_connection_);
-    g_main_loop_unref(main_loop_);
-
-    if (manager_)
-        g_object_unref(manager_);
-
-    if (input_source_ > 0)
-        g_source_remove(input_source_);
-}
-
-int Application::Run() {
-    g_main_loop_run(main_loop_);
-    return 0;
-}
-
-void Application::RegisterCommand(const Command &command) {
-    available_commands_[command.name] = command;
-}
-
-void Application::HandleEnableCommand(const std::string &arguments) {
-    if (!manager_)
-        return;
-
-    aethercast_interface_manager_set_enabled(manager_, true);
-}
-
-void Application::HandleDisableCommand(const std::string &arguments) {
-    if (!manager_)
-        return;
-
-    aethercast_interface_manager_set_enabled(manager_, false);
-}
-
-void Application::HandleShowCommand(const std::string &arguments) {
-    if (!manager_)
-        return;
-
-    auto enabled = aethercast_interface_manager_get_enabled(manager_);
-    std::cout << "Enabled: " << std::boolalpha << (bool) enabled << std::endl;
-
-    auto state = aethercast_interface_manager_get_state(manager_);
-    std::cout << "State: " << state << std::endl;
-
-    auto scanning = aethercast_interface_manager_get_scanning(manager_);
-    std::cout << "Scanning: " << std::boolalpha << (bool) scanning << std::endl;
-
-    auto capabilities = aethercast_interface_manager_get_capabilities(manager_);
-    std::cout << "Capabilities:" << std::endl;
-    for (int n = 0; capabilities[n] != nullptr; n++)
-        std::cout << "  " << capabilities[n] << std::endl;
-}
-
-void Application::OnScanDone(GObject *object, GAsyncResult *res, gpointer user_data) {
-    auto inst = static_cast<Application*>(user_data);
-
-    GError *error = nullptr;
-    if (!aethercast_interface_manager_call_scan_finish(inst->manager_, res, &error)) {
-        std::cerr << "Failed to scan:" << error->message << std::endl;
-        g_error_free(error);
-        return;
-    }
-}
-
-void Application::HandleScanCommand(const std::string &arguments) {
-    if (!manager_)
-        return;
-
-    aethercast_interface_manager_call_scan(manager_, nullptr, &Application::OnScanDone, this);
-}
-
-void Application::ForeachDevice(std::function<void(AethercastInterfaceDevice*)> callback, const std::string &address_filter) {
-    if (!callback)
-        return;
-
-    auto objects = g_dbus_object_manager_get_objects(object_manager_);
-
-    for (auto obj = objects; obj != nullptr; obj = obj->next) {
-        auto device = AETHERCAST_INTERFACE_OBJECT_PROXY(obj->data);
-        if (!device)
-            continue;
-
-        auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(device), "org.aethercast.Device");
-        if (!iface)
-            continue;
-
-        auto device_obj = AETHERCAST_INTERFACE_DEVICE(iface);
-
-        if (address_filter.length() > 0) {
-            auto device_address = aethercast_interface_device_get_address(device_obj);
-            if (address_filter != device_address)
-                continue;
-        }
-
-        callback(device_obj);
-    }
-}
-
-void Application::HandleDevicesCommand(const std::string &arguments) {
-    ForeachDevice([=](AethercastInterfaceDevice *device) {
-        auto address = aethercast_interface_device_get_address(device);
-        auto name = aethercast_interface_device_get_name(device);
-        std::cout << "Device " << address << " " << name << std::endl;
-    });
-}
-
-void Application::HandleInfoCommand(const std::string &arguments) {
-    if (arguments.length() == 0) {
-        std::cerr << "No device address supplied" << std::endl;
-        return;
-    }
-
-    bool found = false;
-
-    ForeachDevice([&](AethercastInterfaceDevice *device) {
-        auto address = aethercast_interface_device_get_address(device);
-        std::cout << "Address: " << address << std::endl;
-
-        auto name = aethercast_interface_device_get_name(device);
-        std::cout << "Name: " << name << std::endl;
-
-        auto state = aethercast_interface_device_get_state(device);
-        std::cout << "State: " << state << std::endl;
-
-        auto capabilities = aethercast_interface_device_get_capabilities(device);
-        std::cout << "Capabilities: " << std::endl;
-        for (int n = 0; capabilities[n] != nullptr; n++)
-            std::cout << "  " << capabilities[n] << std::endl;
-
-        found = true;
-    }, arguments);
-
-    if (!found)
-        std::cerr << "Unknown or invalid device address" << std::endl;
-}
-
-void Application::OnDeviceConnected(GObject *object, GAsyncResult *res, gpointer user_data) {
-    PromptSaver ps;
-
-    GError *error = nullptr;
-    if (!aethercast_interface_device_call_connect_finish(AETHERCAST_INTERFACE_DEVICE(object), res, &error)) {
-        std::cerr << "Failed to connect with device: " << error->message << std::endl;
-        g_error_free(error);
-        return;
-    }
-}
-
-void Application::HandleConnectCommand(const std::string &arguments) {
-    PromptSaver ps;
-
-    if (arguments.length() == 0) {
-        std::cerr << "No device address supplied" << std::endl;
-        return;
-    }
-
-    bool found = false;
-
-    ForeachDevice([&](AethercastInterfaceDevice *device) {
-
-        aethercast_interface_device_call_connect(device, "sink", nullptr,
-                                               &Application::OnDeviceConnected, nullptr);
-
-        found = true;
-    }, arguments);
-
-    if (!found)
-        std::cerr << "Unknown or invalid device address" << std::endl;
-}
-
-void Application::OnDeviceDisconnected(GObject *object, GAsyncResult *res, gpointer user_data) {
-    PromptSaver ps;
-
-    GError *error = nullptr;
-    if (!aethercast_interface_device_call_disconnect_finish(AETHERCAST_INTERFACE_DEVICE(object), res, &error)) {
-        std::cerr << "Failed to disconnect from device: " << error->message << std::endl;
-        g_error_free(error);
-        return;
-    }
-}
-
-void Application::HandleDisconnectCommand(const std::string &arguments) {
-    PromptSaver ps;
-
-    if (arguments.length() == 0) {
-        std::cerr << "No device address supplied" << std::endl;
-        return;
-    }
-
-    bool found = false;
-
-    ForeachDevice([&](AethercastInterfaceDevice *device) {
-
-        aethercast_interface_device_call_disconnect(device, nullptr,
-                                               &Application::OnDeviceDisconnected, nullptr);
-
-        found = true;
-    }, arguments);
-
-    if (!found)
-        std::cerr << "Unknown or invalid device address" << std::endl;
-}
-
-void Application::SetupStandardInput() {
-    GIOChannel *channel;
-
-    channel = g_io_channel_unix_new(fileno(stdin));
-
-    input_source_ = g_io_add_watch(channel,
-                            (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL),
-                            &Application::OnUserInput, this);
-
-    g_io_channel_unref(channel);
-
-}
-
-gboolean Application::OnUserInput(GIOChannel *channel, GIOCondition condition, gpointer user_data) {
-    auto inst = static_cast<Application*>(user_data);
-
-    if (condition & G_IO_IN) {
-        rl_callback_read_char();
-        return TRUE;
-    }
-
-    if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
-        g_main_loop_quit(inst->main_loop_);
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-void Application::OnReadlineMessage(char *input) {
-    PromptSaver ps;
-
-    char *arg;
-    int i;
-
-    if (!input) {
-        rl_newline(1, '\n');
-        g_main_loop_quit(main_loop_);
-        return;
-    }
-
-    std::string cmd = strtok_r(input, " ", &arg) ? : "";
-    if (cmd.size() == 0)
-        return;
-
-    if (arg) {
-        int len = strlen(arg);
-        if (len > 0 && arg[len - 1] == ' ')
-            arg[len - 1] = '\0';
-    }
-
-    auto iter = available_commands_.find(cmd);
-    if (iter != available_commands_.end()) {
-        if (iter->second.func)
-            iter->second.func(arg);
-    }
-    else if (cmd == "help") {
-        std::cout << "Available commands:" << std::endl;
-
-        for (auto cmd : available_commands_) {
-            if (cmd.second.description.size() == 0)
-                continue;
-
-            fprintf(stdout, " %s %-*s %s\n", cmd.second.name.c_str(),
-                   (int)(25 - cmd.second.name.length()),
-                   cmd.second.arguments.c_str(),
-                   cmd.second.description.c_str());
-        }
-    }
-    else {
-        std::cerr << "Invalid command" << std::endl;
-    }
-
-    g_free(input);
-}
-
-void Application::OnServiceLost(GDBusConnection *connection, const gchar *name, gpointer user_data) {
-    auto inst = static_cast<Application*>(user_data);
-
-    if (inst->input_source_ > 0) {
-        g_source_remove(inst->input_source_);
-        inst->input_source_ = 0;
-    }
-
-    if (inst->manager_) {
-        g_object_unref(inst->manager_);
-        inst->manager_ = nullptr;
-    }
-
-    if (inst->object_manager_) {
-        g_object_unref(inst->object_manager_);
-        inst->object_manager_ = nullptr;
-    }
-}
-
-void Application::OnServiceFound(GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data) {
-    auto inst = static_cast<Application*>(user_data);
-
-    aethercast_interface_manager_proxy_new(inst->bus_connection_, G_DBUS_PROXY_FLAGS_NONE,
-                                         "org.aethercast", "/org/aethercast", nullptr,
-                                         &Application::OnManagerConnected, inst);
-}
-
-void Application::OnManagerConnected(GObject *object, GAsyncResult *res, gpointer user_data) {
-    PromptSaver ps;
-
-    auto inst = static_cast<Application*>(user_data);
-
-    GError *error = nullptr;
-    inst->manager_ = aethercast_interface_manager_proxy_new_finish(res, &error);
-    if (!inst->manager_) {
-        std::cerr << "Could not connect with manager: " << error->message << std::endl;
-        g_error_free(error);
-        g_main_loop_quit(inst->main_loop_);
-        return;
-    }
-
-    // Use a high enough timeout to make sure we wait enough for the service to
-    // respond as the connection process can take some time depending on different
-    // factors.
-    g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(inst->manager_), kDBusTimeout * 1000);
-
-    aethercast_interface_object_manager_client_new(inst->bus_connection_,
-                             G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
-                             "org.aethercast", "/org/aethercast",
-                             nullptr, &Application::OnObjectManagerCreated, inst);
-}
-
-void Application::OnManagerPropertiesChanged(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
-                                             const gchar *interface_name, const gchar *signal_name, GVariant *parameters,
-                                             gpointer user_data) {
-    PromptSaver ps;
-
-    if (g_variant_n_children(parameters) != 3)
-        return;
-
-    GVariant *changed_props = g_variant_get_child_value(parameters, 1);
-    for (int n = 0; n < g_variant_n_children(changed_props); n++) {
-        auto element = g_variant_get_child_value(changed_props, n);
-        auto key_v = g_variant_get_child_value(element, 0);
-        auto value_v = g_variant_get_child_value(element, 1);
-
-        auto key = std::string(g_variant_get_string(key_v, nullptr));
-
-        std::cout << "[CHG] Manager " << key << " changed: ";
-
-        if (key == "Enabled")
-            std::cout << std::boolalpha << (bool) g_variant_get_boolean(g_variant_get_variant(value_v)) << std::endl;
-        else if (key == "State")
-            std::cout << g_variant_get_string(g_variant_get_variant(value_v), nullptr) << std::endl;
-        else if (key == "Scanning")
-            std::cout << std::boolalpha << (bool) g_variant_get_boolean(g_variant_get_variant(value_v)) << std::endl;
-        else if (key == "Capabilities") {
-            std::stringstream capabilities;
-
-            for (int m = 0; m < g_variant_n_children(value_v); m++) {
-                auto capability = g_variant_get_child_value(value_v, m);
-                if (!g_variant_is_of_type(capability, G_VARIANT_TYPE_STRING))
-                    continue;
-
-                capabilities << g_variant_get_string(capability, nullptr) << " ";
-            }
-
-            std::cout << capabilities.str() << std::endl;
-        }
-        else
-            std::cout << "unknown" << std::endl;
-
-        g_variant_unref(key_v);
-        g_variant_unref(value_v);
-    }
-}
-
-void Application::OnDeviceAdded(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data) {
-    PromptSaver ps;
-
-    auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(object), "org.aethercast.Device");
-    if (!iface)
-        return;
-
-    auto device = AETHERCAST_INTERFACE_DEVICE(iface);
-
-    auto address = aethercast_interface_device_get_address(device);
-    auto name = aethercast_interface_device_get_name(device);
-
-    std::cout << "Device " << address << " " << name << " added" << std::endl;
-}
-
-void Application::OnDeviceRemoved(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data) {
-    PromptSaver ps;
-
-    auto iface = g_dbus_object_get_interface(G_DBUS_OBJECT(object), "org.aethercast.Device");
-    if (!iface)
-        return;
-
-    auto device = AETHERCAST_INTERFACE_DEVICE(iface);
-
-    auto address = aethercast_interface_device_get_address(device);
-    auto name = aethercast_interface_device_get_name(device);
-
-    std::cout << "Device " << address << " " << name <<" removed" << std::endl;
-}
-
-void Application::OnObjectManagerCreated(GObject *object, GAsyncResult *res, gpointer user_data) {
-    auto inst = static_cast<Application*>(user_data);
-
-    GError *error = nullptr;
-    inst->object_manager_ = aethercast_interface_object_manager_client_new_finish(res, &error);
-    if (!inst->object_manager_) {
-        g_error_free(error);
-        return;
-    }
-
-    g_signal_connect(inst->object_manager_, "object-added", G_CALLBACK(&Application::OnDeviceAdded), inst);
-    g_signal_connect(inst->object_manager_, "object-removed", G_CALLBACK(&Application::OnDeviceRemoved), inst);
-
-    inst->SetupStandardInput();
-}
-
-} // namespace client
-} // namespace ac
diff --git a/src/client/application.h b/src/client/application.h
deleted file mode 100644
index 9596110..0000000
--- a/src/client/application.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- *  Copyright (C) 2015 Canonical, Ltd.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#ifndef APPLICATION_H_
-#define APPLICATION_H_
-
-#include <map>
-#include <functional>
-
-#include "ac/glib_wrapper.h"
-
-extern "C" {
-// Ignore all warnings coming from the external headers as we don't
-// control them and also don't want to get any warnings from them
-// which will only pollute our build output.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-w"
-#include "aethercastinterface.h"
-#pragma GCC diagnostic pop
-}
-
-namespace ac {
-namespace client {
-
-class Application {
-public:
-    struct MainOptions {
-        static MainOptions FromCommandLine(int argc, char** argv);
-    };
-
-    static int Main(const MainOptions &options);
-
-    Application();
-    ~Application();
-
-    int Run();
-
-private:
-    struct Command {
-        std::string name;
-        std::string arguments;
-        std::string description;
-        std::function<void(std::string)> func;
-    };
-
-    void HandleEnableCommand(const std::string &arguments);
-    void HandleDisableCommand(const std::string &arguments);
-    void HandleShowCommand(const std::string &arguments);
-    void HandleScanCommand(const std::string &arguments);
-    void HandleDevicesCommand(const std::string &arguments);
-    void HandleInfoCommand(const std::string &arguments);
-    void HandleConnectCommand(const std::string &arguments);
-    void HandleDisconnectCommand(const std::string &arguments);
-
-    void RegisterCommand(const Command &command);
-
-private:
-    static gboolean OnUserInput(GIOChannel *channel, GIOCondition condition, gpointer user_data);
-    static void OnReadlineMessage(char *input);
-    static void OnServiceLost(GDBusConnection *connection, const gchar *name, gpointer user_data);
-    static void OnServiceFound(GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data);
-    static void OnManagerConnected(GObject *object, GAsyncResult *res, gpointer user_data);
-    static void OnDeviceAdded(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data);
-    static void OnDeviceRemoved(GDBusObjectManager *manager, GDBusObject *object, gpointer user_data);
-    static void OnObjectManagerCreated(GObject *object, GAsyncResult *res, gpointer user_data);
-
-    static void OnManagerPropertiesChanged(GDBusConnection *connection,
-                                           const gchar *sender_name,
-                                           const gchar *object_path,
-                                           const gchar *interface_name,
-                                           const gchar *signal_name,
-                                           GVariant *parameters,
-                                           gpointer user_data);
-
-    static void OnScanDone(GObject *object, GAsyncResult *res, gpointer user_data);
-    static void OnDeviceConnected(GObject *object, GAsyncResult *res, gpointer user_data);
-    static void OnDeviceDisconnected(GObject *object, GAsyncResult *res, gpointer user_data);
-private:
-    void SetupStandardInput();
-    void ForeachDevice(std::function<void(AethercastInterfaceDevice*)> callback, const std::string &address_filter = "");
-
-private:
-    GDBusConnection *bus_connection_;
-    AethercastInterfaceManager *manager_;
-    guint input_source_;
-    GDBusObjectManager *object_manager_;
-
-private:
-    // Needs to be static otherwise we can't access it from the readline
-    // callback function (which sadly doesn't allow passing any user data)
-    static GMainLoop *main_loop_;
-    static std::map<std::string,Command> available_commands_;
-};
-
-} // namespace client
-} // namespace ac
-
-#endif
diff --git a/src/client/main.cpp b/src/client/main.cpp
deleted file mode 100644
index 0663e9f..0000000
--- a/src/client/main.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- *  Copyright (C) 2012  Intel Corporation. All rights reserved.
- *                2015 Canonical, Ltd.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include "application.h"
-
-int main(int argc, char **argv) {
-    return ac::client::Application::Main(ac::client::Application::MainOptions::FromCommandLine(argc, argv));
-}