begin rework

cli/CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8)
 
 project(ccats-cli)
 
-add_executable(ccats-cli src/main.cpp src/iomanager.cpp src/machineiomanager.cpp src/useriomanager.cpp src/commands.cpp src/base64.cpp)
+add_executable(ccats-cli src/main.cpp src/ioman.cpp src/machineioman.cpp src/userioman.cpp src/base64.cpp src/netman.cpp src/cmdman.cpp src/fileman.cpp)
 
 # use pkg-config to find readline as it doesnt provide cmake files
 find_package(PkgConfig REQUIRED)

cli/include/cmdman.h

@@ -0,0 +1,77 @@
+#ifndef CMDMAN_H
+#define CMDMAN_H
+
+#include "fileman.h"
+
+#include <json/json.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+using std::string;
+using std::vector;
+using std::map;
+
+class CmdMan {
+public:
+	enum rettype { json, error, text };
+	struct CmdRet {
+		rettype type;
+		string msg;
+	};
+	
+	CmdMan(FileMan &fm);
+	~CmdMan();
+
+	// execute cmd with optional argument args, returns answer string
+	// if cmd unknown, returns error string
+	CmdRet execute(string cmd, vector<string> args);
+	CmdRet handle(Json::Value root);
+
+	//~ bool sendJson(Json::Value root);
+	//~ bool receiveJson(boost::asio::streambuf &recvbuf);
+	//~ bool parseJson(Json::Value *root, boost::asio::streambuf &recvbuf);
+	
+	
+	/* internal commands */
+	CmdRet cmdVersion(string);
+	CmdRet cmdLogin(string, string);
+	CmdRet cmdPutdata();
+	CmdRet cmdGetdata();
+	
+private:
+	
+	Json::CharReader* reader;
+	Json::StreamWriterBuilder wbuilder;
+
+	string jsonerror;
+
+	FileMan &fileman;
+
+	map<string,CmdRet(CmdMan::*)(vector<string>)> execmap;
+	map<string,string> helpmap;
+	map<string,CmdRet(CmdMan::*)(Json::Value)> handlemap;
+	
+
+	/* execute command descriptions and methods go here */
+	const string descHelp = "print available commands";
+	CmdRet cmdHelp(vector<string> args);
+	const string descStatus = "request status from server";
+	CmdRet cmdStatus(vector<string> args);
+	const string descDisconnect = "disconnect from server";
+	CmdRet cmdDisconnect(vector<string> args);
+	const string descPut = "upload file to server and add to queue";
+	CmdRet cmdPut(vector<string> args);
+	const string descGet = "retrieve file from server";
+	CmdRet cmdGet(vector<string> args);
+	const string descList = "list files available on server";
+	CmdRet cmdList(vector<string> args);
+	
+	/* handle commands go here */
+	CmdRet handleDefault(Json::Value);
+	CmdRet handlePut(Json::Value);
+	CmdRet handleGet(Json::Value);
+};
+
+#endif

cli/include/commands.h

@@ -1,5 +1,5 @@
-#ifndef COMMANDS_HPP
-#define COMMANDS_HPP
+#ifndef COMMANDS_H
+#define COMMANDS_H
 
 #include <cstring>
 #include <cctype>

cli/include/fileman.h

@@ -0,0 +1,39 @@
+#ifndef FILEMAN_H
+#define FILEMAN_H
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#define BLOCKSIZE 8
+
+class FileMan {
+private:
+	std::ifstream putfile;
+	std::ofstream getfile;
+	std::string getname, putname;
+	const unsigned int max_read_len = 8;
+	unsigned int putchunks;
+public:
+	FileMan();
+	~FileMan();
+	
+	bool isGetting();
+	bool isPutting();
+
+	bool openPut(const std::string &name);
+	bool openGet(const std::string &name);
+	void closePut();
+	void closeGet();
+	std::string getPutName();
+	std::string getGetName();
+	// closes and deletes getfile
+	void cancelGet();
+
+	void writeGet(std::vector<char> data);
+
+	std::vector<char> readPut();
+	int getPutChunks();
+};
+
+#endif

cli/include/global.h

@@ -1,5 +1,5 @@
-#ifndef GLOBAL_HPP
-#define GLOBAL_HPP
+#ifndef GLOBAL_H
+#define GLOBAL_H
 
 #define VERSION "0.1"
 

cli/include/ioman.h

@@ -0,0 +1,42 @@
+#ifndef IOMAN_H
+#define IOMAN_H
+
+#include "netman.h"
+#include "cmdman.h"
+#include "fileman.h"
+
+#include <string>
+
+#define BLOCKSIZE 8
+
+
+class IoMan {
+private:
+	const std::string protoVersion = "0.2";
+
+protected:
+	NetMan netman;
+	CmdMan cmdman;
+	FileMan fileman;
+	bool loggedin;
+	std::string promptcmd = "";
+	std::string promptuser = "";
+	std::string promptpass = "";
+	
+	virtual bool parseJson(Json::Value *root, string jsonstring) = 0;
+	virtual bool handleJson(Json::Value root) = 0;
+	virtual void printErrorMessage(std::string msg) = 0;
+	virtual void printWelcomeMessage() = 0;
+
+public:
+	// Basic constructor
+	IoMan(char *ipcstring);
+	// destructor to clean up all generic stuff
+	~IoMan();
+	// enters loop to handle further interaction based on derived class
+	void run();
+	// setup stuff
+	bool init();
+};
+
+#endif

cli/include/iomanager.h

@@ -1,42 +0,0 @@
-#ifndef IOMANAGER_HPP
-#define IOMANAGER_HPP
-
-#include "global.h"
-
-#include <string>
-#include <boost/asio.hpp>
-#include <json/json.h>
-
-#define BLOCKSIZE 8
-
-using boost::asio::ip::tcp;
-
-class IoManager {
-protected:
-	boost::asio::io_service ios;
-	tcp::socket *tcpsock;
-	boost::system::error_code errcode;
-	std::string ipstring;
-	int port;
-
-	std::string jsonerror;
-
-	Json::CharReaderBuilder rbuilder;
-	Json::CharReader* reader;
-	Json::StreamWriterBuilder wbuilder;
-
-	bool sendJson(Json::Value root);
-	bool receiveJson(boost::asio::streambuf &recvbuf);
-	bool parseJson(Json::Value *root, boost::asio::streambuf &recvbuf);
-public:
-	// Basic constructor
-	IoManager(char *ipcstring);
-	// destructor to clean up all generic stuff
-	~IoManager();
-	// enters loop to handle further interaction based on derived class
-	virtual void run() = 0;
-	// tries to establish connection, returns false on error
-	bool connect();
-};
-
-#endif

cli/include/machineioman.h

@@ -0,0 +1,17 @@
+#ifndef MACHINEIOMAN_H
+#define MACHINEIOMAN_H
+
+#include "ioman.h"
+
+class MachineIoMan : public IoMan {
+
+public:
+	using IoMan::IoMan;
+
+	bool parseJson(Json::Value *root, string jsonstring);
+	bool handleJson(Json::Value root);
+	void printErrorMessage(std::string msg);
+	void printWelcomeMessage();
+};
+
+#endif

cli/include/machineiomanager.h

@@ -1,15 +0,0 @@
-#ifndef MACHINEIOMANAGER_HPP
-#define MACHINEIOMANAGER_HPP
-
-#include "iomanager.h"
-
-class MachineIoManager : public IoManager {
-
-public:
-	// MachineIoManager(char *ipstring) : IoManager(ipstring) {};
-	using IoManager::IoManager;
-	// enters loop to handle machine based interaction (other frontends)
-	void run();
-};
-
-#endif

cli/include/netman.h

@@ -0,0 +1,38 @@
+#ifndef NETMAN_H
+#define NETMAN_H
+
+#include <boost/asio.hpp>
+#include <string>
+
+using boost::asio::ip::tcp;
+
+class NetMan {
+private:
+	boost::asio::io_service ios;
+	boost::asio::streambuf sendbuf;
+	boost::asio::streambuf recvbuf;
+	boost::system::error_code errcode;
+	tcp::socket *tcpsock;
+	std::string ipstring;
+	int port;
+	bool connected;
+	
+public:
+	// basic constructor
+	NetMan(char *ipcstring);
+	// basic destructor
+	~NetMan();
+	// tries to establish connection, returns error string if applicable
+	void connect();
+	// sends a string
+	void sendJsonString(std::string msg);
+	// returns a single json object as string
+	std::string receiveJsonString();
+	// disconnect from server
+	void disconnect();
+
+	// returns connected;
+	bool isConnected();
+};
+
+#endif

cli/include/userioman.h

@@ -0,0 +1,22 @@
+#ifndef USERIOMAN_H
+#define USERIOMAN_H
+
+#include "ioman.h"
+
+class UserIoMan : public IoMan {
+protected:
+
+	std::string promptcmd = "ccats";
+	std::string promptuser = "username";
+	std::string promptpass = "password";
+
+public:
+	using IoMan::IoMan;
+
+	bool parseJson(Json::Value *root, string jsonstring);
+	bool handleJson(Json::Value root);
+	void printErrorMessage(std::string msg);
+	void printWelcomeMessage();
+};
+
+#endif

cli/include/useriomanager.h

@@ -1,15 +0,0 @@
-#ifndef USERIOMANAGER_HPP
-#define USERIOMANAGER_HPP
-
-#include "iomanager.h"
-
-class UserIoManager : public IoManager {
-
-public:
-	// UserIoManager(char *ipstring) : IoManager(ipstring) {};
-	using IoManager::IoManager;
-	// enters loop to handle user based interaction (from the terminal)
-	void run();
-};
-
-#endif

cli/src/cmdman.cpp

@@ -0,0 +1,179 @@
+#include "../include/cmdman.h"
+
+CmdMan::CmdMan(FileMan &fm) : fileman(fileman) {
+	
+	/* setup json stuff */
+  Json::CharReaderBuilder rbuilder;
+  wbuilder.settings_["indentation"] = "";
+  reader = rbuilder.newCharReader();
+	
+	/* initialize execute command map */
+	execmap["help"] = &CmdMan::cmdHelp;
+	execmap["status"] = &CmdMan::cmdStatus;
+	execmap["disconnect"] = &CmdMan::cmdDisconnect;
+	execmap["put"] = &CmdMan::cmdPut;
+	execmap["get"] = &CmdMan::cmdGet;
+	execmap["list"] = &CmdMan::cmdList;
+	
+	/* initialize description map */
+	helpmap["help"] = descHelp;
+	helpmap["status"] = descStatus;
+	helpmap["disconnect"] = descDisconnect;
+	helpmap["put"] = descPut;
+	helpmap["get"] = descGet;
+	helpmap["list"] = descList;
+	
+	/* initialize handle command map */
+	handlemap["status"] = &CmdMan::handleDefault;
+	handlemap["disconnect"] = &CmdMan::handleDefault;
+	handlemap["put"] = &CmdMan::handleDefault;
+	handlemap["get"] = &CmdMan::handleDefault;
+	handlemap["list"] = NULL;
+}
+
+CmdMan::~CmdMan() {
+	delete reader;
+}
+
+CmdMan::CmdRet CmdMan::cmdHelp(vector<string> args) {
+	CmdRet retval;
+	map<string,string>::iterator it;
+	for(it = helpmap.begin(); it != helpmap.end(); it++) {
+		retval.msg.append(it->first);
+		retval.msg.append(" - ");
+		retval.msg.append(it->second);
+		retval.msg.append("\n");
+	}
+	retval.type = text;
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdStatus(vector<string> args) {
+	CmdRet retval;
+	Json::Value root;
+	root["command"] = "status";
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdDisconnect(vector<string> args) {
+	CmdRet retval;
+	Json::Value root;
+	root["command"] = "close";
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdPut(vector<string> args) {
+	CmdRet retval;
+	Json::Value root;
+	
+	bool opened = fileman.openPut(args[0]);
+	if(opened) {
+		root["command"] = "put";
+		root["file"] = fileman.getPutName();
+		root["size"] = fileman.getPutChunks();
+		retval.type = json;
+		retval.msg = Json::writeString(wbuilder, root);
+	}
+	else {
+		retval.type = error;
+		retval.msg = "couldnt open local file \"" + args[0] + "\"";
+	}
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdGet(vector<string> args) {
+	CmdRet retval;
+	Json::Value root;
+	
+	bool opened = fileman.openGet(args[0]);
+	if(opened) {
+		root["command"] = "get";
+		root["file"] = fileman.getGetName();
+		retval.type = json;
+		retval.msg = Json::writeString(wbuilder, root);
+	}
+	else {
+		retval.type = error;
+		retval.msg = "local file \"" + args[0] + "\" already exists";
+	}
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdList(vector<string> args) {
+	CmdRet retval;
+	Json::Value root;
+	root["command"] = "list";
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+
+CmdMan::CmdRet CmdMan::execute(string cmd, vector<string> args) {
+	map<string,CmdRet(CmdMan::*)(vector<string>)>::iterator it = execmap.find(cmd);
+	string retmsg;
+	if(it == execmap.end()) {
+		return { error, "unknown command \"" + cmd + "\".\ntype help to list available commands." };
+	}
+	return (this->*(execmap[cmd]))(args);
+}
+
+/* internal commands */
+CmdMan::CmdRet CmdMan::cmdVersion(string version) {
+	CmdRet retval;
+	Json::Value root;
+	root["version"] = version;
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::cmdLogin(string user, string pass) {
+	CmdRet retval;
+	Json::Value root;
+	root["user"] = user;
+	root["pass"] = pass;
+	root["login"] = true;
+	root["cancel"] = false;
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::handleDefault(Json::Value root) {
+	CmdRet retval;
+	
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::handlePut(Json::Value root) {
+	CmdRet retval;
+	
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}
+
+CmdMan::CmdRet CmdMan::handleGet(Json::Value root) {
+	CmdRet retval;
+	
+	retval.type = json;
+	retval.msg = Json::writeString(wbuilder, root);
+	
+	return retval;
+}

cli/src/fileman.cpp

@@ -0,0 +1,83 @@
+#include "../include/fileman.h"
+
+FileMan::FileMan() {
+	
+}
+
+FileMan::~FileMan() {
+	cancelGet();
+	closePut();
+}
+
+bool FileMan::isGetting() {
+	return getfile.is_open();
+}
+
+bool FileMan::isPutting() {
+	return putfile.is_open();
+}
+
+
+bool FileMan::openPut(const std::string &name) {
+	putname = name;
+	putfile.open(name, std::ios::ate | std::ios::binary);
+	if(putfile.is_open()) {
+		size_t size = putfile.tellg();
+		putchunks = size / max_read_len + ((size % max_read_len) ? 1 : 0);
+		putfile.seekg(std::ios::beg);
+		return true;
+	}
+	return false;
+}
+
+bool FileMan::openGet(const std::string &name) {
+	getname = name;
+	getfile.open(name, std::ios::app | std::ios::binary);
+	if(getfile.tellp() != std::ios::beg) {
+		closeGet();
+		return false;
+	}
+	return true;
+}
+
+void FileMan::closePut() {
+	putfile.close();
+}
+
+void FileMan::closeGet() {
+	getfile.close();
+}
+
+
+void FileMan::cancelGet() {
+	if(isGetting()) {
+		closeGet();
+		std::remove(getname.c_str());
+	}
+}
+
+
+void FileMan::writeGet(const std::vector<char> data) {
+	getfile.write(data.data(), data.size());
+}
+
+
+std::vector<char> FileMan::readPut() {
+	char buf[max_read_len];
+	std::vector<char> data;
+	int read = putfile.readsome(buf, max_read_len);
+	data.assign(buf, buf+read);
+	return data;
+}
+
+std::string FileMan::getPutName() {
+	return putname;
+}
+
+std::string FileMan::getGetName() {
+	return getname;
+}
+
+int FileMan::getPutChunks() {
+	return putchunks;
+}

cli/src/ioman.cpp

@@ -0,0 +1,166 @@
+#include "../include/ioman.h"
+
+#include <iostream>
+
+#include <boost/algorithm/string.hpp>
+#include <string>
+#include <vector>
+
+#include <readline/history.h>
+#include <readline/readline.h>
+
+using std::string;
+using std::vector;
+
+using boost::asio::buffer;
+
+IoMan::IoMan(char *ipcstring) : netman(ipcstring),cmdman(fileman) {
+}
+
+IoMan::~IoMan() {
+}
+
+//~ bool IoMan::parseJson(Json::Value *root, string jsonstring) {
+  //~ const char *recvjson;
+  //~ std::string jsonerror;
+  //~ recvjson = jsonstring.c_str();
+  //~ if (!reader->parse(recvjson, recvjson + jsonstring.size(), root, &jsonerror)) {
+    //~ std::cerr << "couldnt parse json data" << std::endl
+              //~ << jsonerror << std::endl;
+    //~ return false;
+  //~ }
+  //~ recvbuf.consume(recvbuf.size());
+  //~ return true;
+//~ }
+
+bool IoMan::init() {
+	CmdMan::CmdRet ret;
+	string work;
+	Json::Value root;
+	
+	try { netman.connect(); }
+	catch(string err) { printErrorMessage(err); return false; }
+	
+	ret = cmdman.cmdVersion(protoVersion);
+	try { netman.sendJsonString(ret.msg); }
+	catch(string err) { printErrorMessage(err); return false; }
+	
+	try { work = netman.receiveJsonString(); }
+	catch(string err) { printErrorMessage(err); return false; }
+	
+	if(!parseJson(&root, work)) return false;
+	
+	if(!root["accept"].asBool()) {
+		work = "IoMan::init() Version check failed. Server reports ";
+		work.append(root["version"].asString());
+		work.append(" but client is ");
+		work.append(protoVersion);
+		printErrorMessage(work);
+		return false;
+	}
+	
+	printWelcomeMessage();
+	return true;
+}
+
+void IoMan::run() {
+	std::cerr << "IoMan::run() begin" << std::endl;
+	bool running = true;
+	char *line = NULL, *user = NULL, *pass = NULL;
+	vector<string> tokens;
+	string work, command;
+	CmdMan::CmdRet cmdret;
+	Json::Value root;
+	
+	while(!user) {
+		user = readline(promptuser.c_str());
+	}
+	while(!pass) {
+		user = readline(promptpass.c_str());
+	}
+	
+	/* move login elsewhere? */
+	cmdret = cmdman.cmdLogin(string(user), string(pass));
+	free(user);
+	free(pass);
+	
+	try { netman.sendJsonString(cmdret.msg); }
+	catch(string err) { printErrorMessage(err); return; }
+	
+	try { work = netman.receiveJsonString(); }
+	catch(string err) { printErrorMessage(err); return; }
+	
+	if(!parseJson(&root, work)) return;
+	if(!root["accept"].asBool()) {
+		work = "IoMan::run() Login refused. ";
+		work.append(root["error"].asString());
+		printErrorMessage(work);
+		return;
+	}
+	
+	
+	while(running) {
+		free(line);
+		
+		line = readline(promptcmd.c_str());
+
+	    // if no input, do not add to history, and go to reading next line
+	    if (strlen(line) == 0) {
+	      continue;
+	    }
+
+	    // split input line into tokens
+	    boost::algorithm::split(tokens, std::string(line),
+				    boost::algorithm::is_any_of(" "),
+				    boost::algorithm::token_compress_on);
+
+	    // if input contains only spaces, do not add to history, and go to reading
+	    // next line
+	    if (tokens.size() < 1) {
+	      continue;
+	    }
+
+	    // add the line to history
+	    add_history(line);
+	    command = tokens[0];
+	    tokens.erase(tokens.begin());
+	    
+	    cmdret = cmdman.execute(command, tokens);
+	    switch(cmdret.type) {
+		    case CmdMan::rettype::error: {
+			printErrorMessage(cmdret.msg);
+			break;
+		    }
+		    case CmdMan::rettype::text: {
+			    // only for userioman
+			    std::cout << cmdret.msg << std::endl;
+			    break;
+		    }
+		    case CmdMan::rettype::json: {
+			try { netman.sendJsonString(cmdret.msg); }
+			catch(string err) { printErrorMessage(err); continue; }
+			
+			while(1) {
+				try { work = netman.receiveJsonString(); }
+				catch(string err) { printErrorMessage(err); break; }
+				
+				if(!work.size()) break;
+				
+				if(!parseJson(&root, work)) break;
+				else if(!handleJson(root)) {
+					running = false;
+					break;
+				}
+			}				
+			break;
+		    }
+	    }
+	    
+	    if(!netman.isConnected()) break;
+	}
+	
+	free(line);
+}
+
+
+

cli/src/machineiomanager.cpp → cli/src/machineioman.cpp

@@ -1,4 +1,4 @@
-#include "../include/machineiomanager.h"
+#include "../include/machineioman.h"
 #include "../include/base64.h"
 #include "../include/commands.h"
 
@@ -12,8 +12,24 @@
 
 using boost::asio::buffer;
 
-void MachineIoManager::run() {
-  std::cerr << "MachineIoManager::run() says hello!" << std::endl;
+bool MachineIoMan::parseJson(Json::Value *root, string jsonstring) {
+	return false;
+}
+
+bool MachineIoMan::handleJson(Json::Value root) {
+	return false;
+}
+
+void MachineIoMan::printErrorMessage(std::string msg) {
+	std::cout << msg << std::endl;
+}
+
+void MachineIoMan::printWelcomeMessage() {
+	std::cout << "please enter user and password" << std::endl;
+}
+
+/* void MachineIoMan::run() {
+  std::cerr << "MachineIoMan::run() says hello!" << std::endl;
 
   boost::asio::streambuf recvbuf;
 
@@ -241,11 +257,6 @@ void MachineIoManager::run() {
             break;
           // dump received data for GUI
           std::cout << recv << std::endl;
-          /*
-          Json::Value arraything = recv["names"];
-          if(arraything.isArray())
-          for(Json::Value d : recv["names"])
-          */
           chunks = recv["remaining"].asInt();
           root["received"] = rec;
           if (!sendJson(root)) {
@@ -272,3 +283,4 @@ void MachineIoManager::run() {
 
   return;
 }
+*/

cli/src/main.cpp

@@ -1,6 +1,6 @@
 #include "../include/commands.h"
-#include "../include/machineiomanager.h"
-#include "../include/useriomanager.h"
+#include "../include/machineioman.h"
+#include "../include/userioman.h"
 
 #include <boost/asio.hpp>
 #include <boost/program_options.hpp>
@@ -26,7 +26,7 @@ int main(int argc, char **argv) {
   bpo::variables_map vm;
   unsigned int machine = 0;
   const char *file = NULL;
-  IoManager *ioman;
+  IoMan *ioman;
 
   if (argc < 2 || !std::strncmp(argv[1], "--help", 6)) {
     show_help(argv[0]);
@@ -65,14 +65,12 @@ int main(int argc, char **argv) {
               file ? file : "");
 
   if (machine) {
-    ioman = new MachineIoManager(argv[1]);
+    ioman = new MachineIoMan(argv[1]);
   } else {
-    ioman = new UserIoManager(argv[1]);
+    ioman = new UserIoMan(argv[1]);
   }
-
-  // ‘MachineIoManager::MachineIoManager(char*&)’
-  if (ioman->connect()) {
-    ioman->run();
+  if(ioman->init()) {
+	ioman->run();
   }
   delete ioman;
   std::printf("done\n");

cli/src/iomanager.cpp → cli/src/netman.cpp

@@ -1,19 +1,77 @@
-#include "../include/iomanager.h"
+#include "../include/netman.h"
 
+#include <boost/asio.hpp>
 #include <iostream>
 
+using boost::asio::ip::tcp;
 using boost::asio::buffer;
 
-IoManager::IoManager(char *ipcstring) {
+NetMan::NetMan(char *ipcstring) {
   ipstring = std::string(ipcstring);
   port = 1234;
   tcpsock = new tcp::socket(ios);
-  wbuilder.settings_["indentation"] = "";
-  // const std::string output = Json::writeString(wbuilder, root);
-  reader = rbuilder.newCharReader();
+	connected = false;
 }
 
-bool IoManager::sendJson(Json::Value root) {
+void NetMan::connect() {
+  tcp::endpoint *ep;
+
+  ep = new tcp::endpoint(boost::asio::ip::address::from_string(ipstring), 1234);
+
+  // establish connection
+  std::cerr << "NetMan::connect() connecting to " << ipstring << std::endl;
+  tcpsock->connect(*ep, errcode);
+  if (errcode) {
+	  delete ep;
+	  throw "NetMan::connect() couldnt connect to " + ipstring + "\n" + errcode.message() + "\n";
+    //~ std::cerr << "couldnt connect to " << ipstring << std::endl
+              //~ << errcode.message() << std::endl;
+    //~ return false;
+  }
+  connected = true;
+  delete ep;
+}
+
+void NetMan::disconnect() {
+  std::cerr << "NetMan::disconnect()" << std::endl;
+	tcpsock->close();
+}
+
+void NetMan::sendJsonString(std::string msg) {
+  std::cerr << "NetMan::sendJsonString() " << msg << std::endl;
+  boost::asio::write(*tcpsock, buffer(msg + "\n"), errcode);
+  if (errcode) {
+	  throw "NetMan::sendJsonString() couldnt send json data\n" + errcode.message() + "\n";
+  }
+}
+
+std::string NetMan::receiveJsonString() {
+	std::string retstring;
+  std::cerr << "NetMan::receiveJsonString()" << std::endl;
+	// use transfer_at_least(1) to avoid deadlock with transfer_all()
+  boost::asio::read_until(*tcpsock, recvbuf, '\n', errcode);
+  if (errcode && errcode != boost::asio::error::eof) {
+	  throw "NetMan::receiveJsonString() couldnt read json data\n" + errcode.message() + "\n";
+  }
+  retstring = boost::asio::buffer_cast<const char *>(recvbuf.data());
+  std::cerr << retstring << std::endl;
+  return retstring;
+}
+
+bool NetMan::isConnected() {
+	return connected;
+}
+
+NetMan::~NetMan() {
+	if(connected) {
+		disconnect();
+	}
+	delete tcpsock;
+}
+
+/*
+
+bool IoMan::sendJson(Json::Value root) {
   boost::asio::write(*tcpsock, buffer(Json::writeString(wbuilder, root)),
                      errcode);
   if (errcode) {
@@ -24,7 +82,7 @@ bool IoManager::sendJson(Json::Value root) {
   return true;
 }
 
-bool IoManager::receiveJson(boost::asio::streambuf &recvbuf) {
+bool IoMan::receiveJson(boost::asio::streambuf &recvbuf) {
   // use transfer_at_least(1) to avoid deadlock with transfer_all()
   boost::asio::read(*tcpsock, recvbuf, boost::asio::transfer_at_least(1),
                     errcode);
@@ -36,20 +94,8 @@ bool IoManager::receiveJson(boost::asio::streambuf &recvbuf) {
   return true;
 }
 
-bool IoManager::parseJson(Json::Value *root, boost::asio::streambuf &recvbuf) {
-  const char *recvjson;
-  std::string jsonerror;
-  recvjson = boost::asio::buffer_cast<const char *>(recvbuf.data());
-  if (!reader->parse(recvjson, recvjson + recvbuf.size(), root, &jsonerror)) {
-    std::cerr << "couldnt parse json data" << std::endl
-              << jsonerror << std::endl;
-    return false;
-  }
-  recvbuf.consume(recvbuf.size());
-  return true;
-}
 
-bool IoManager::connect() {
+bool IoMan::connect() {
   boost::asio::streambuf recvbuf;
   tcp::endpoint *ep;
   Json::Value root, checkok;
@@ -95,7 +141,6 @@ bool IoManager::connect() {
   printf("check ok\n\n\n");
   fflush(stdout);
 
-  /* */
   // TODO remove hardcoded login
   root = Json::Value();
   // send version check
@@ -116,7 +161,6 @@ bool IoManager::connect() {
 
   // dump for GUI
   std::cout << root << std::endl;
-  /* */
 
   // clean up
   delete ep;
@@ -124,9 +168,7 @@ bool IoManager::connect() {
   return true;
 }
 
-IoManager::~IoManager() {
-
-  /* */
+IoMan::~IoMan() {
 
   boost::asio::streambuf recvbuf;
   Json::Value root, checkok;
@@ -149,9 +191,10 @@ IoManager::~IoManager() {
 
   // dump to GUI
   std::cout << root << std::endl;
-  /* */
 
   tcpsock->close();
   delete tcpsock;
   delete reader;
 }
+
+*/

cli/src/useriomanager.cpp → cli/src/userioman.cpp

@@ -1,4 +1,4 @@
-#include "../include/useriomanager.h"
+#include "../include/userioman.h"
 #include "../include/base64.h"
 #include "../include/commands.h"
 
@@ -14,8 +14,24 @@
 
 using boost::asio::buffer;
 
-void UserIoManager::run() {
-  std::cout << "UserIoManager::run() says hello!" << std::endl;
+bool UserIoMan::parseJson(Json::Value *root, string jsonstring) {
+	return false;
+}
+
+bool UserIoMan::handleJson(Json::Value root) {
+	return false;
+}
+
+void UserIoMan::printErrorMessage(std::string msg) {
+	std::cout << msg << std::endl;
+}
+
+void UserIoMan::printWelcomeMessage() {
+	std::cout << "please enter user and password" << std::endl;
+}
+
+/* void UserIoMan::run() {
+  std::cout << "UserIoMan::run() says hello!" << std::endl;
 
   bool keep_reading = true;
   COMMANDID cmd;
@@ -399,3 +415,4 @@ void UserIoManager::run() {
 
   return;
 }
+*/