use sendJson method to send json on daemon

daemon/include/Server.h

@@ -7,6 +7,8 @@
 #include <boost/bind.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
+#include <json/json.h>
+
 using namespace boost::asio;
 using ip::tcp;
 
@@ -52,6 +54,11 @@ private:
    */
   std::string putFileName;
 
+  /**
+   * string builder for json
+   */
+  Json::StreamWriterBuilder jsonStringBuilder;
+
   /**
    * Reads data and binds it to a handler.
    *
@@ -60,6 +67,13 @@ private:
   void read(void (con_handler::*handler)(const boost::system::error_code &err,
                                          size_t bytes_transferred));
 
+  /**
+   * Sends json data over the network.
+   *
+   * @param json json object
+   */
+  void sendJson(const Json::Value &json);
+
 public:
   /**
    * Pointer to a con_handler.

daemon/src/Server.cpp

@@ -2,7 +2,6 @@
 #include "../include/base64.h"
 
 #include <iostream>
-#include <json/json.h>
 
 using namespace boost::asio;
 using ip::tcp;
@@ -13,7 +12,10 @@ using ip::tcp;
 
 con_handler::con_handler(
     basic_socket_acceptor<ip::tcp>::executor_type &io_service)
-    : sock(io_service) {}
+    : sock(io_service) {
+  // disable indentation for json
+  this->jsonStringBuilder.settings_["indentation"] = "";
+}
 
 con_handler::~con_handler() {}
 
@@ -44,31 +46,23 @@ void con_handler::handle_read_version(const boost::system::error_code &err,
 
     // 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);
 
       read(&con_handler::handle_read_login);
 
       // send answer
-      sock.async_write_some(buffer(answerString, max_length),
-                            boost::bind(&con_handler::handle_write,
-                                        shared_from_this(), placeholders::error,
-                                        placeholders::bytes_transferred));
+      sendJson(answer);
     } 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));
+      sendJson(answer);
+      ;
       // close connection
       sock.close();
     }
@@ -96,32 +90,23 @@ void con_handler::handle_read_login(const boost::system::error_code &err,
     }
 
     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);
 
       // read next data
       read(&con_handler::handle_read_command);
 
       // send answer
-      sock.async_write_some(buffer(answerString, max_length),
-                            boost::bind(&con_handler::handle_write,
-                                        shared_from_this(), placeholders::error,
-                                        placeholders::bytes_transferred));
+      sendJson(answer);
     } 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));
+      sendJson(answer);
       // close connection
       sock.close();
     }
@@ -149,7 +134,6 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
     }
 
     Json::Value answer;
-    Json::StreamWriterBuilder stringBuilder;
 
     // check command
     if (root["command"].compare("status") == 0) {
@@ -171,13 +155,9 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
       }
 
       answer["response"] = response;
-      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));
+      sendJson(answer);
     } else if (root["command"].compare("list") == 0) {
       // read next data
       read(&con_handler::handle_read_command);
@@ -192,12 +172,8 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
       answer["names"] = array;
       answer["remaining"] = 0;
 
-      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));
+      sendJson(answer);
 
     } else if (root["command"].compare("put") == 0) {
       // read next data
@@ -233,14 +209,8 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
           // slashes in file names are illegal
           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));
+          sendJson(answer);
         } else {
           // build file path
           this->putFileName = this->fileDirectory;
@@ -254,26 +224,14 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
             this->putFile.close();
             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));
+            sendJson(answer);
           } else {
             // accept file
             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));
+            sendJson(answer);
           }
         }
       }
@@ -287,13 +245,8 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
       if (this->getFile.is_open()) {
         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));
+        sendJson(answer);
       } else {
         // open file
         const std::string filename = root["file"].asString();
@@ -301,14 +254,8 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
           // slashes in file names are illegal
           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));
+          sendJson(answer);
         } else {
           std::string file = this->fileDirectory;
           file.append(filename);
@@ -319,25 +266,12 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
             // file does not exist or cannot be opened
             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));
+            sendJson(answer);
           } else {
             answer["accept"] = true;
 
-            const std::string answerString =
-                Json::writeString(stringBuilder, answer);
-
-            sock.async_write_some(buffer(answerString, max_length),
-                                  boost::bind(&con_handler::handle_write,
-                                              shared_from_this(),
-                                              placeholders::error,
-                                              placeholders::bytes_transferred));
+            sendJson(answer);
 
             answer = Json::Value();
             answer["command"] = "get";
@@ -363,14 +297,7 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
               answer["cancel"] = false;
               answer["data"] = base64::encodeVector(data);
 
-              const std::string answerString =
-                  Json::writeString(stringBuilder, answer);
-
-              sock.async_write_some(
-                  buffer(answerString, max_length),
-                  boost::bind(&con_handler::handle_write, shared_from_this(),
-                              placeholders::error,
-                              placeholders::bytes_transferred));
+              sendJson(answer);
             }
 
             this->getFile.close();
@@ -380,13 +307,9 @@ void con_handler::handle_read_command(const boost::system::error_code &err,
     } else if (root["command"].compare("close") == 0) {
       answer["command"] = "close";
       answer["response"] = "bye";
-      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));
+      sendJson(answer);
 
       // close connection
       sock.close();
@@ -421,6 +344,16 @@ void con_handler::read(void (con_handler::*handler)(
                                    placeholders::bytes_transferred));
 }
 
+void con_handler::sendJson(const Json::Value &json) {
+  std::string jsonString = Json::writeString(jsonStringBuilder, json);
+  jsonString.append("\n");
+
+  sock.async_write_some(buffer(jsonString, max_length),
+                        boost::bind(&con_handler::handle_write,
+                                    shared_from_this(), placeholders::error,
+                                    placeholders::bytes_transferred));
+}
+
 /**********
  * Server *
  **********/