version and login handler

I implemented a version and a login handler for con_handler. I
additionally created a command handler which must still be implemented.

daemon/include/Server.h

@@ -20,6 +20,8 @@ private:
   tcp::socket sock;
   const std::string message = "Hello From Server!";
 
+  const std::string protocolVersion = "0.1";
+
   /**
    * max buffer length
    */
@@ -89,6 +91,39 @@ public:
   void handle_read(const boost::system::error_code &err,
                    size_t bytes_transferred);
 
+  /**
+   * Read handler
+   *
+   * Will be called if the server expected a version and received something.
+   *
+   * @param err error
+   * @param bytes_transferred amount of transferred bytes
+   */
+  void handle_read_version(const boost::system::error_code &err,
+                           size_t bytes_transferred);
+
+  /**
+   * Read handler
+   *
+   * Will be called after the version was verifyed. Checks login data.
+   *
+   * @param err error
+   * @param bytes_transferred amount of transferred bytes
+   */
+  void handle_read_login(const boost::system::error_code &err,
+                         size_t bytes_transferred);
+
+  /**
+   * Read handler
+   *
+   * Will be called after the version and login was verifyed. Executes commands.
+   *
+   * @param err error
+   * @param bytes_transferred amount of transferred bytes
+   */
+  void handle_read_command(const boost::system::error_code &err,
+                           size_t bytes_transferred);
+
   /**
    * Write handler
    *

daemon/src/Server.cpp

@@ -23,15 +23,11 @@ con_handler::create(basic_socket_acceptor<ip::tcp>::executor_type &io_service) {
 tcp::socket &con_handler::socket() { return sock; }
 
 void con_handler::start() {
+
   sock.async_read_some(buffer(data, max_length),
-                       boost::bind(&con_handler::handle_read,
+                       boost::bind(&con_handler::handle_read_version,
                                    shared_from_this(), placeholders::error,
                                    placeholders::bytes_transferred));
-
-  sock.async_write_some(buffer(message, max_length),
-                        boost::bind(&con_handler::handle_write,
-                                    shared_from_this(), placeholders::error,
-                                    placeholders::bytes_transferred));
 }
 
 void con_handler::handle_read(const boost::system::error_code &err,
@@ -44,6 +40,124 @@ void con_handler::handle_read(const boost::system::error_code &err,
   }
 }
 
+void con_handler::handle_read_version(const boost::system::error_code &err,
+                                      size_t bytes_transferred) {
+  if (!err) {
+    // set up json stuff
+    JSONCPP_STRING err;
+    Json::Value root;
+    Json::CharReaderBuilder builder;
+    const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+
+    // parse data
+    if (!reader->parse(this->data, this->data + bytes_transferred, &root,
+                       &err)) {
+      std::cerr << "Json error: " << err << std::endl << "data: " << this->data;
+      sock.close();
+    }
+
+    // create answer
+    Json::Value answer;
+    Json::StreamWriterBuilder stringBuilder;
+
+    answer["version"] = this->protocolVersion;
+
+    // check version string
+    if (root["version"].compare(this->protocolVersion) == 0) {
+      answer["accept"] = true;
+      const std::string answerString = Json::writeString(stringBuilder, answer);
+
+      // send answer
+      sock.async_write_some(buffer(answerString, max_length),
+                            boost::bind(&con_handler::handle_write,
+                                        shared_from_this(), placeholders::error,
+                                        placeholders::bytes_transferred));
+
+      // read next data
+      sock.async_read_some(buffer(data, max_length),
+                           boost::bind(&con_handler::handle_read_login,
+                                       shared_from_this(), placeholders::error,
+                                       placeholders::bytes_transferred));
+    } else {
+      answer["accept"] = false;
+      const std::string answerString = Json::writeString(stringBuilder, answer);
+
+      // send answer
+      sock.async_write_some(buffer(answerString, max_length),
+                            boost::bind(&con_handler::handle_write,
+                                        shared_from_this(), placeholders::error,
+                                        placeholders::bytes_transferred));
+      // close connection
+      sock.close();
+    }
+
+  } else {
+    std::cerr << "error: " << err.message() << std::endl;
+    sock.close();
+  }
+}
+
+void con_handler::handle_read_login(const boost::system::error_code &err,
+                                    size_t bytes_transferred) {
+  if (!err) {
+    // set up json stuff
+    JSONCPP_STRING err;
+    Json::Value root;
+    Json::CharReaderBuilder builder;
+    const std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+
+    // parse data
+    if (!reader->parse(this->data, this->data + bytes_transferred, &root,
+                       &err)) {
+      std::cerr << "Json error: " << err << std::endl << "data: " << this->data;
+      sock.close();
+    }
+
+    Json::Value answer;
+    Json::StreamWriterBuilder stringBuilder;
+
+    // user credentials
+    // TODO check user credentials!!!
+    if (root["user"].compare("user") == 0 &&
+        root["pass"].compare("pass") == 0) {
+      answer["accept"] = true;
+      const std::string answerString = Json::writeString(stringBuilder, answer);
+
+      // send answer
+      sock.async_write_some(buffer(answerString, max_length),
+                            boost::bind(&con_handler::handle_write,
+                                        shared_from_this(), placeholders::error,
+                                        placeholders::bytes_transferred));
+
+      // read next data
+      sock.async_read_some(buffer(data, max_length),
+                           boost::bind(&con_handler::handle_read_command,
+                                       shared_from_this(), placeholders::error,
+                                       placeholders::bytes_transferred));
+    } else {
+      answer["accept"] = false;
+      const std::string answerString = Json::writeString(stringBuilder, answer);
+
+      // send answer
+      sock.async_write_some(buffer(answerString, max_length),
+                            boost::bind(&con_handler::handle_write,
+                                        shared_from_this(), placeholders::error,
+                                        placeholders::bytes_transferred));
+      // close connection
+      sock.close();
+    }
+
+  } else {
+    std::cerr << "error: " << err.message() << std::endl;
+    sock.close();
+  }
+}
+
+void con_handler::handle_read_command(const boost::system::error_code &err,
+                                      size_t bytes_transferred) {
+  // TODO
+}
+
 void con_handler::handle_write(const boost::system::error_code &err,
                                size_t bytes_transferred) {
   if (!err) {