run autoformatter

cli/src/commands.cpp

@@ -1,18 +1,19 @@
 #include "../include/commands.hpp"
 
-CMD commands[]{
-	{CMD_HELP	, "help", "show help"},
-        {CMD_STATUS	, "status", "query status of IP"},
-	{CMD_DISCONNECT	, "disconnect", "disconnect from IP"},
-	
-	/* TODO
+CMD
+    commands[]{
+        {CMD_HELP, "help", "show help"},
+        {CMD_STATUS, "status", "query status of IP"},
+        {CMD_DISCONNECT, "disconnect", "disconnect from IP"},
+
+        /* TODO
         {CMD_PUT	, "put", "upload file to IP and add to queue"},
-        {CMD_REMOVE	, "remove", "remove file from IP and queue (stops xfer if required)"},
-        {CMD_GET	, "get", "retrieve file from IP"},
+        {CMD_REMOVE	, "remove", "remove file from IP and queue (stops xfer
+        if required)"}, {CMD_GET	, "get", "retrieve file from IP"},
         {CMD_SETUP	, "setup", "configure server at IP"},
         {CMD_LOG	, "log", "show log from IP"}
-	*/
-};
+        */
+    };
 
 COMMANDID getCmdIdFromString(const char *str) {
   COMMANDID ret = CMD_UNKNOWN;
@@ -20,23 +21,24 @@ COMMANDID getCmdIdFromString(const char *str) {
   if (std::strlen(str) > COMMANDLEN)
     return ret;
   for (int i = 0; i < COMMANDLEN; i++)
-      temp[i] = std::tolower(str[i]);
+    temp[i] = std::tolower(str[i]);
 
   for (int i = 0; i < sizeofarr(commands); i++) {
     if (!std::strncmp(temp, commands[i].name, COMMANDLEN))
-        ret = commands[i].cmd;
+      ret = commands[i].cmd;
   }
   return ret;
 }
 
 const char *getCmdStringFromId(COMMANDID id) {
-	const char *ret = NULL;
-	for(int i = 0; i < sizeofarr(commands); i++) {
-		if(commands[i].cmd == id) ret = commands[i].name;
-	}
-	return ret;
+  const char *ret = NULL;
+  for (int i = 0; i < sizeofarr(commands); i++) {
+    if (commands[i].cmd == id)
+      ret = commands[i].name;
+  }
+  return ret;
 }
 
 void printCmds(void) {
-	// TODO
+  // TODO
 }

cli/src/iomanager.cpp

@@ -6,212 +6,219 @@
 using boost::asio::buffer;
 
 IoManager::IoManager(char *ipcstring) {
-	ipstring = new std::string(ipcstring);
-	port = 1234;
-	tcpsock = new tcp::socket(ios);
+  ipstring = new std::string(ipcstring);
+  port = 1234;
+  tcpsock = new tcp::socket(ios);
 }
 
 bool IoManager::connect() {
-	boost::asio::streambuf recvbuf;
-	tcp::endpoint *ep;
-	Json::Value root, checkok;
-	const char *recvjson;
-	std::string jsonerror;
-	bool bcheckok;
-	
-	Json::CharReaderBuilder rbuilder;
-	const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
-	Json::StreamWriterBuilder wbuilder;
-	// builder["indentation"] = ""; // If you want whitespace-less output
-	// const std::string output = Json::writeString(wbuilder, root);
-	
-	ep = new tcp::endpoint(boost::asio::ip::address::from_string(*ipstring), 1234);
-	
-	
-	// establish connection
-	std::cerr << "connecting to " << *ipstring << std::endl;
-	tcpsock->connect(*ep, errcode);
-	if(errcode) {
-		std::cerr << "couldnt connect to " << *ipstring << std::endl
-			  << errcode.message() << std::endl;
-		return false;
-	}
-	
-	printf("connect ok\n");
-	fflush(stdout);
-	
-	// send version check
-	root["version"] = VERSION;
-	
-	std::cout << root << std::endl;
-	
-	boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)), errcode);
-	if(errcode) {
-		std::cerr << "couldnt send version check" << std::endl
-			  << errcode.message() << std::endl;
-		return false;
-	}
-	
-	printf("send ok\n");
-	fflush(stdout);
-	
-	// recieve answer to version check
-	// using transfer_at_least(1) to avoid lockup with transfer_all()
-	boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1), errcode);
-	//~ boost::asio::read(*tcpsock, recvbuf, errcode);
-	if (errcode && errcode != boost::asio::error::eof) {
-		std::cerr << "couldnt recieve version check" << std::endl
-			  << errcode.message() << std::endl;
-		return false;
-	}
-	
-	printf("recieve ok\n");
-	fflush(stdout);
-	
-	// parse json
-	recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-	if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
-		std::cerr << "couldnt parse recieved json" << std::endl
-			  << jsonerror << std::endl;
-		return false;
-	}
-	
-	printf("parse ok\n");
-	fflush(stdout);
-	
-	// remove processed data from recvbuf
-	recvbuf.consume(recvbuf.size());
-	
-	std::cout << root << std::endl;
-	
-	// check if version check was ok
-	checkok = root["accept"];
-	
-	if(!checkok.asBool()) {
-		std::cerr << "version check failed. client version is " << VERSION << std::endl
-			  << "server reports version " << root["version"] << std::endl;
-		return false;
-	}
-	
-	printf("check ok\n\n\n");
-	fflush(stdout);
-	
-	/* */
-	// TODO remove hardcoded login
-	root = Json::Value();
-	// send version check
-	// TODO make client version global
-	root["user"] = "user";
-	root["pass"] = "pass";
-	
-	std::cout << root << std::endl;
-	
-	boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)), errcode);
-	if(errcode) {
-		std::cerr << "couldnt send login" << std::endl
-			  << errcode.message() << std::endl;
-		return false;
-	}
-	
-	printf("send ok\n");
-	fflush(stdout);
-	
-	// recieve answer to version check
-	// using transfer_at_least(1) to avoid lockup with transfer_all()
-	boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1), errcode);
-	//~ boost::asio::read(*tcpsock, recvbuf, errcode);
-	if (errcode && errcode != boost::asio::error::eof) {
-		std::cerr << "couldnt recieve login response" << std::endl
-			  << errcode.message() << std::endl;
-		return false;
-	}
-	
-	printf("recieve ok\n");
-	fflush(stdout);
-	
-	// parse json
-	recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-	if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
-		std::cerr << "couldnt parse recieved json" << std::endl
-			  << jsonerror << std::endl;
-		return false;
-	}
-	
-	printf("parse ok\n");
-	fflush(stdout);
-	
-	// remove processed data from recvbuf
-	recvbuf.consume(recvbuf.size());
-	
-	std::cout << root << std::endl;
-	/* */
-	
-	// clean up
-	delete ep;
-	
-	return true;
+  boost::asio::streambuf recvbuf;
+  tcp::endpoint *ep;
+  Json::Value root, checkok;
+  const char *recvjson;
+  std::string jsonerror;
+  bool bcheckok;
+
+  Json::CharReaderBuilder rbuilder;
+  const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
+  Json::StreamWriterBuilder wbuilder;
+  // builder["indentation"] = ""; // If you want whitespace-less output
+  // const std::string output = Json::writeString(wbuilder, root);
+
+  ep =
+      new tcp::endpoint(boost::asio::ip::address::from_string(*ipstring), 1234);
+
+  // establish connection
+  std::cerr << "connecting to " << *ipstring << std::endl;
+  tcpsock->connect(*ep, errcode);
+  if (errcode) {
+    std::cerr << "couldnt connect to " << *ipstring << std::endl
+              << errcode.message() << std::endl;
+    return false;
+  }
+
+  printf("connect ok\n");
+  fflush(stdout);
+
+  // send version check
+  root["version"] = VERSION;
+
+  std::cout << root << std::endl;
+
+  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
+                     errcode);
+  if (errcode) {
+    std::cerr << "couldnt send version check" << std::endl
+              << errcode.message() << std::endl;
+    return false;
+  }
+
+  printf("send ok\n");
+  fflush(stdout);
+
+  // recieve answer to version check
+  // using transfer_at_least(1) to avoid lockup with transfer_all()
+  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
+                    errcode);
+  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
+  if (errcode && errcode != boost::asio::error::eof) {
+    std::cerr << "couldnt recieve version check" << std::endl
+              << errcode.message() << std::endl;
+    return false;
+  }
+
+  printf("recieve ok\n");
+  fflush(stdout);
+
+  // parse json
+  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
+  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
+    std::cerr << "couldnt parse recieved json" << std::endl
+              << jsonerror << std::endl;
+    return false;
+  }
+
+  printf("parse ok\n");
+  fflush(stdout);
+
+  // remove processed data from recvbuf
+  recvbuf.consume(recvbuf.size());
+
+  std::cout << root << std::endl;
+
+  // check if version check was ok
+  checkok = root["accept"];
+
+  if (!checkok.asBool()) {
+    std::cerr << "version check failed. client version is " << VERSION
+              << std::endl
+              << "server reports version " << root["version"] << std::endl;
+    return false;
+  }
+
+  printf("check ok\n\n\n");
+  fflush(stdout);
+
+  /* */
+  // TODO remove hardcoded login
+  root = Json::Value();
+  // send version check
+  // TODO make client version global
+  root["user"] = "user";
+  root["pass"] = "pass";
+
+  std::cout << root << std::endl;
+
+  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
+                     errcode);
+  if (errcode) {
+    std::cerr << "couldnt send login" << std::endl
+              << errcode.message() << std::endl;
+    return false;
+  }
+
+  printf("send ok\n");
+  fflush(stdout);
+
+  // recieve answer to version check
+  // using transfer_at_least(1) to avoid lockup with transfer_all()
+  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
+                    errcode);
+  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
+  if (errcode && errcode != boost::asio::error::eof) {
+    std::cerr << "couldnt recieve login response" << std::endl
+              << errcode.message() << std::endl;
+    return false;
+  }
+
+  printf("recieve ok\n");
+  fflush(stdout);
+
+  // parse json
+  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
+  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
+    std::cerr << "couldnt parse recieved json" << std::endl
+              << jsonerror << std::endl;
+    return false;
+  }
+
+  printf("parse ok\n");
+  fflush(stdout);
+
+  // remove processed data from recvbuf
+  recvbuf.consume(recvbuf.size());
+
+  std::cout << root << std::endl;
+  /* */
+
+  // clean up
+  delete ep;
+
+  return true;
 }
 
 IoManager::~IoManager() {
-	
-	/* */
-	
-	boost::asio::streambuf recvbuf;
-	Json::Value root, checkok;
-	const char *recvjson;
-	std::string jsonerror;
-	
-	Json::CharReaderBuilder rbuilder;
-	const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
-	Json::StreamWriterBuilder wbuilder;
-	
-	// TODO remove hardcoded login
-	root = Json::Value();
-	// send version check
-	// TODO make client version global
-	root["command"] = "close";
-	
-	std::cout << root << std::endl;
-	
-	boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)), errcode);
-	if(errcode) {
-		std::cerr << "couldnt send close" << std::endl
-			  << errcode.message() << std::endl;
-	}
-	
-	printf("send ok\n");
-	fflush(stdout);
-	
-	// recieve answer to version check
-	// using transfer_at_least(1) to avoid lockup with transfer_all()
-	boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1), errcode);
-	//~ boost::asio::read(*tcpsock, recvbuf, errcode);
-	if (errcode && errcode != boost::asio::error::eof) {
-		std::cerr << "couldnt recieve close response" << std::endl
-			  << errcode.message() << std::endl;
-	}
-	
-	printf("recieve ok\n");
-	fflush(stdout);
-	
-	// parse json
-	recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-	if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
-		std::cerr << "couldnt parse recieved json" << std::endl
-			  << jsonerror << std::endl;
-	}
-	
-	printf("parse ok\n");
-	fflush(stdout);
-	
-	// remove processed data from recvbuf
-	recvbuf.consume(recvbuf.size());
-	
-	std::cout << root << std::endl;
-	/* */
-	
-	tcpsock->close();
-	
-	delete ipstring;
-	delete tcpsock;
+
+  /* */
+
+  boost::asio::streambuf recvbuf;
+  Json::Value root, checkok;
+  const char *recvjson;
+  std::string jsonerror;
+
+  Json::CharReaderBuilder rbuilder;
+  const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
+  Json::StreamWriterBuilder wbuilder;
+
+  // TODO remove hardcoded login
+  root = Json::Value();
+  // send version check
+  // TODO make client version global
+  root["command"] = "close";
+
+  std::cout << root << std::endl;
+
+  boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
+                     errcode);
+  if (errcode) {
+    std::cerr << "couldnt send close" << std::endl
+              << errcode.message() << std::endl;
+  }
+
+  printf("send ok\n");
+  fflush(stdout);
+
+  // recieve answer to version check
+  // using transfer_at_least(1) to avoid lockup with transfer_all()
+  boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
+                    errcode);
+  //~ boost::asio::read(*tcpsock, recvbuf, errcode);
+  if (errcode && errcode != boost::asio::error::eof) {
+    std::cerr << "couldnt recieve close response" << std::endl
+              << errcode.message() << std::endl;
+  }
+
+  printf("recieve ok\n");
+  fflush(stdout);
+
+  // parse json
+  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
+  if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
+    std::cerr << "couldnt parse recieved json" << std::endl
+              << jsonerror << std::endl;
+  }
+
+  printf("parse ok\n");
+  fflush(stdout);
+
+  // remove processed data from recvbuf
+  recvbuf.consume(recvbuf.size());
+
+  std::cout << root << std::endl;
+  /* */
+
+  tcpsock->close();
+
+  delete ipstring;
+  delete tcpsock;
 }

cli/src/machineiomanager.cpp

@@ -9,73 +9,75 @@
 using boost::asio::buffer;
 
 void MachineIoManager::run() {
-	std::cout << "MachineIoManager::run() says hello!" << std::endl;
-
-	boost::asio::streambuf recvbuf;
-	boost::system::error_code errcode;
-	
-	Json::Value root;
-	const char *recvjson;
-	
-	Json::StreamWriterBuilder wbuilder;
-	
-	bool keep_reading = true;
-	COMMANDID cmd;
-	char *line = NULL;
-	while(keep_reading){
-		free(line);
-		root = Json::Value();
-		
-		// read an input line
-		line = readline ("");
-        
-		// if no input continue
-		if (strlen(line) == 0) {
-			continue;
-		}
-		
-		cmd = getCmdIdFromString(line);
-		
-		switch(cmd) {
-			case CMD_DISCONNECT: {
-				std::cerr << "disconnecting\n";
-				keep_reading = false;
-				break;
-			}
-			case CMD_STATUS: {
-				root["command"] = "status";
-				
-				// send request
-				boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)), errcode);
-				if(errcode) {
-					std::cerr << "couldnt send version check" << std::endl
-						  << errcode.message() << std::endl;
-					break;
-				}
-				
-				// receive answer
-				// using transfer_at_least(1) to avoid lockup with transfer_all()
-				boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1), errcode);
-				if (errcode && errcode != boost::asio::error::eof) {
-					std::cerr << "couldnt recieve version check" << std::endl
-						  << errcode.message() << std::endl;
-					break;
-				}
-				
-				// dump received data to stdout for gui to handle
-				recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-				std::cout << recvjson;
-				
-				break;
-			}
-			default: {
-				std::cerr << "unknown command " << line << "\n";
-				break;
-			}
-		}
-		std::printf("\n");
-	}
-	free(line);
-	
-	return;
+  std::cout << "MachineIoManager::run() says hello!" << std::endl;
+
+  boost::asio::streambuf recvbuf;
+  boost::system::error_code errcode;
+
+  Json::Value root;
+  const char *recvjson;
+
+  Json::StreamWriterBuilder wbuilder;
+
+  bool keep_reading = true;
+  COMMANDID cmd;
+  char *line = NULL;
+  while (keep_reading) {
+    free(line);
+    root = Json::Value();
+
+    // read an input line
+    line = readline("");
+
+    // if no input continue
+    if (strlen(line) == 0) {
+      continue;
+    }
+
+    cmd = getCmdIdFromString(line);
+
+    switch (cmd) {
+    case CMD_DISCONNECT: {
+      std::cerr << "disconnecting\n";
+      keep_reading = false;
+      break;
+    }
+    case CMD_STATUS: {
+      root["command"] = "status";
+
+      // send request
+      boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
+                         errcode);
+      if (errcode) {
+        std::cerr << "couldnt send version check" << std::endl
+                  << errcode.message() << std::endl;
+        break;
+      }
+
+      // receive answer
+      // using transfer_at_least(1) to avoid lockup with transfer_all()
+      boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
+                        errcode);
+      if (errcode && errcode != boost::asio::error::eof) {
+        std::cerr << "couldnt recieve version check" << std::endl
+                  << errcode.message() << std::endl;
+        break;
+      }
+
+      // dump received data to stdout for gui to handle
+      recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
+      std::cout << recvjson;
+
+      break;
+    }
+    default: {
+      std::cerr << "unknown command " << line << "\n";
+      break;
+    }
+    }
+    std::printf("\n");
+  }
+  free(line);
+
+  return;
 }

cli/src/main.cpp

@@ -1,9 +1,9 @@
+#include "../include/commands.hpp"
 #include "../include/machineiomanager.hpp"
 #include "../include/useriomanager.hpp"
-#include "../include/commands.hpp"
 
-#include <boost/program_options.hpp>
 #include <boost/asio.hpp>
+#include <boost/program_options.hpp>
 #include <iostream>
 #include <string>
 
@@ -17,26 +17,28 @@ void show_help(char *exec) {
 
 int main(int argc, char **argv) {
   bpo::options_description desc{"Options"};
-  desc.add_options()("help", "show this help")
-                    ("machine", "switch to machine mode for I/O (not designed for user interaction)")
-		    ("batch", bpo::value<std::string>(), "run operations from arg as batch file");
-  
+  desc.add_options()("help", "show this help")(
+      "machine",
+      "switch to machine mode for I/O (not designed for user interaction)")(
+      "batch", bpo::value<std::string>(),
+      "run operations from arg as batch file");
+
   bpo::variables_map vm;
   unsigned int machine = 0;
   const char *file = NULL;
   IoManager *ioman;
-  
-  if(argc < 2 || !std::strncmp(argv[1], "--help", 6)) {
-	show_help(argv[0]);
-	  std::cout << desc;
-	  return 1;
+
+  if (argc < 2 || !std::strncmp(argv[1], "--help", 6)) {
+    show_help(argv[0]);
+    std::cout << desc;
+    return 1;
   }
-  
-  if(!isdigit(argv[1][0])) {
-	  std::printf("invalid ip\n");
-	  show_help(argv[0]);
-	  std::cout << desc;
-	  return 1;
+
+  if (!isdigit(argv[1][0])) {
+    std::printf("invalid ip\n");
+    show_help(argv[0]);
+    std::cout << desc;
+    return 1;
   }
 
   try {
@@ -44,33 +46,33 @@ int main(int argc, char **argv) {
     notify(vm);
 
     if (vm.count("help")) {
-	    show_help(argv[0]);
+      show_help(argv[0]);
       std::cout << desc;
       return 1;
-    } 
+    }
     if (vm.count("machine")) {
-	    // enable machine/gui mode
-	    machine = 1;
+      // enable machine/gui mode
+      machine = 1;
     }
     if (vm.count("batch")) {
-	    // handle batch file mode
-	    file = vm["batch"].as<std::string>().c_str();
+      // handle batch file mode
+      file = vm["batch"].as<std::string>().c_str();
     }
   } catch (const bpo::error &ex) {
     std::fprintf(stderr, "%s\n", ex.what());
   }
-  std::printf("ip %s machine mode is %d file is %s\n", argv[1], machine, file?file:"");
-  
-  if(machine) {
-	  ioman = new MachineIoManager(argv[1]);
-  }
-  else {
-	  ioman = new UserIoManager(argv[1]);
+  std::printf("ip %s machine mode is %d file is %s\n", argv[1], machine,
+              file ? file : "");
+
+  if (machine) {
+    ioman = new MachineIoManager(argv[1]);
+  } else {
+    ioman = new UserIoManager(argv[1]);
   }
-  
+
   // ‘MachineIoManager::MachineIoManager(char*&)’
-  if(ioman->connect()) {
-	  ioman->run();
+  if (ioman->connect()) {
+    ioman->run();
   }
   delete ioman;
   std::printf("done\n");

cli/src/useriomanager.cpp

@@ -4,113 +4,118 @@
 #include <iostream>
 #include <jsoncpp/json/json.h>
 
-#include <readline/readline.h>
 #include <readline/history.h>
+#include <readline/readline.h>
 
 using boost::asio::buffer;
 
-
 void UserIoManager::run() {
-	std::cout << "UserIoManager::run() says hello!" << std::endl;
-
-	bool keep_reading = true;
-	COMMANDID cmd;
-	char *line = NULL;
-	while(keep_reading){
-		free(line);
-		
-		// read an input line
-		line = readline ("ccats> ");
-        
-		// if no input, do not add to history, and go to reading next line
-		if (strlen(line) == 0) {
-			continue;
-		}
-		
-		// add the line to history
-		add_history(line);
-		
-		cmd = getCmdIdFromString(line);
-		
-		switch(cmd) {
-			case CMD_STATUS: {
-			        
-			        boost::asio::streambuf recvbuf;
-	                        Json::Value root, checkok;
-	                        const char *recvjson;
-                        	std::string jsonerror;
-                        	
-                        	Json::CharReaderBuilder rbuilder;
-                        	const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
-                        	Json::StreamWriterBuilder wbuilder;
-			        
-			        // ask for status
-			        root["command"] = "status";
-			        boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)), errcode);
-			        if(errcode) {
-	                        	std::cerr << "couldnt send status query to server " << ipstring << std::endl
-			                          << errcode.message() << std::endl;
-		                        keep_reading = false;
-		                        continue;
-	                        }
-			        
-			        // recieve answer to status query
-			        boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1), errcode);
-			        if (errcode && errcode != boost::asio::error::eof) {
-                        		std::cerr << "couldnt recieve status from " << ipstring << std::endl
-			                          << errcode.message() << std::endl;
-		                        keep_reading = false;
-		                        continue;
-	                        }
-	                        
-	                        // parse json
-	                        recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-	                        if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root, &jsonerror)) {
-                        		std::cerr << "couldnt parse recieved json" << std::endl
-	                        		  << jsonerror << std::endl;
-	                        	keep_reading = false;
-		                        continue;
-	                        }
-	                        
-	                        // remove processed data from recvbuf
-	                        recvbuf.consume(recvbuf.size());
-	                        
-	                        // check if received answer to right query
-                        	checkok = root["command"];
-	
-                        	if(checkok.asString().compare("status") != 0) {
-                        		std::cerr << "command check failed. client sent command \"status\"" << std::endl
-                        			  << "server replied to command \"" << checkok << "\"" << std::endl;
-                        		keep_reading = false;
-		                        continue;
-                        	} else {
-                        	        std::cout << "server replied with status: " << root["response"] << std::endl;
-                        	}
-                        	
-                        	break;
-                        	
-			}
-			case CMD_DISCONNECT: {
-				std::printf("disconnecting\n");
-				keep_reading = false;
-				break;
-			}
-			default: {
-				std::printf("unknown command %s\n", line);
-			}
-			case CMD_HELP: {
-				std::printf("\n");
-				std::printf("AVAILABLE COMMANDS are:\n");
-				// printCmds();
-				std::printf("help        - shows this help\n");
-				std::printf("status      - asks the server for status\n");
-				std::printf("disconnect  - closes the connection to the server\n");
-				break;
-			}
-		}
-		std::printf("\n");
-	}
-	free(line);
-	
-	return;
+  std::cout << "UserIoManager::run() says hello!" << std::endl;
+
+  bool keep_reading = true;
+  COMMANDID cmd;
+  char *line = NULL;
+  while (keep_reading) {
+    free(line);
+
+    // read an input line
+    line = readline("ccats> ");
+
+    // if no input, do not add to history, and go to reading next line
+    if (strlen(line) == 0) {
+      continue;
+    }
+
+    // add the line to history
+    add_history(line);
+
+    cmd = getCmdIdFromString(line);
+
+    switch (cmd) {
+    case CMD_STATUS: {
+
+      boost::asio::streambuf recvbuf;
+      Json::Value root, checkok;
+      const char *recvjson;
+      std::string jsonerror;
+
+      Json::CharReaderBuilder rbuilder;
+      const std::unique_ptr<Json::CharReader> reader(rbuilder.newCharReader());
+      Json::StreamWriterBuilder wbuilder;
+
+      // ask for status
+      root["command"] = "status";
+      boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
+                         errcode);
+      if (errcode) {
+        std::cerr << "couldnt send status query to server " << ipstring
+                  << std::endl
+                  << errcode.message() << std::endl;
+        keep_reading = false;
+        continue;
+      }
+
+      // recieve answer to status query
+      boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
+                        errcode);
+      if (errcode && errcode != boost::asio::error::eof) {
+        std::cerr << "couldnt recieve status from " << ipstring << std::endl
+                  << errcode.message() << std::endl;
+        keep_reading = false;
+        continue;
+      }
+
+      // parse json
+      recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
+      if (!reader->parse(recvjson, recvjson + recvbuf.size(), &root,
+                         &jsonerror)) {
+        std::cerr << "couldnt parse recieved json" << std::endl
+                  << jsonerror << std::endl;
+        keep_reading = false;
+        continue;
+      }
+
+      // remove processed data from recvbuf
+      recvbuf.consume(recvbuf.size());
+
+      // check if received answer to right query
+      checkok = root["command"];
+
+      if (checkok.asString().compare("status") != 0) {
+        std::cerr << "command check failed. client sent command \"status\""
+                  << std::endl
+                  << "server replied to command \"" << checkok << "\""
+                  << std::endl;
+        keep_reading = false;
+        continue;
+      } else {
+        std::cout << "server replied with status: " << root["response"]
+                  << std::endl;
+      }
+
+      break;
+    }
+    case CMD_DISCONNECT: {
+      std::printf("disconnecting\n");
+      keep_reading = false;
+      break;
+    }
+    default: {
+      std::printf("unknown command %s\n", line);
+    }
+    case CMD_HELP: {
+      std::printf("\n");
+      std::printf("AVAILABLE COMMANDS are:\n");
+      // printCmds();
+      std::printf("help        - shows this help\n");
+      std::printf("status      - asks the server for status\n");
+      std::printf("disconnect  - closes the connection to the server\n");
+      break;
+    }
+    }
+    std::printf("\n");
+  }
+  free(line);
+
+  return;
 }