moved

Sapfor/_src/Server/checkUniq.cpp

@@ -0,0 +1,33 @@
+#include <boost/interprocess/sync/named_mutex.hpp>
+
+using namespace boost::interprocess;
+
+named_mutex* uniqInstance = NULL;
+
+void __bst_create(const char* name)
+{
+    try
+    {
+        uniqInstance = new named_mutex(open_or_create, name);
+    }
+    catch (interprocess_exception& e)
+    {
+        printf("ERROR %s\n", e.what());
+    }
+    if (uniqInstance == NULL)
+        exit(-22);
+}
+
+bool __bst_tryToLock()
+{
+    if (uniqInstance)
+        return uniqInstance->try_lock();
+    else
+        return true;
+}
+
+void __bst_unlock()
+{
+    if (uniqInstance)
+        uniqInstance->unlock();
+}

Sapfor/_src/Server/server.cpp

@@ -0,0 +1,878 @@
+#if _WIN32
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#include <ws2tcpip.h>
+#include <Windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <thread>
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <unordered_map>
+#include <ctime>
+#include <vector>
+
+//build under linux 
+//g++ -O3 -std=c++17 checkUniq.cpp server.cpp -o Visualizer_2 -lpthread -lstdc++fs"; 
+
+#if _WIN32
+#include <filesystem>
+#include <direct.h>
+namespace fs = std::filesystem;
+#define getcwd _getcwd
+#else 
+//с++14 unix + -lstdc++fs
+/*#include <experimental/filesystem>
+namespace fs = std::experimental::filesystem;*/
+//с++17 unix
+#include <filesystem>
+namespace fs = std::filesystem;
+#include <unistd.h> 
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+using namespace std;
+
+#if _WIN32
+//link with Ws2_32.lib
+#pragma comment(lib, "Ws2_32.lib")
+
+#define SPF_NAME     "Components\\Sapfor_F.exe"
+#define SPF_NAME_NEW "Components\\Sapfor_F_new.exe"
+
+#define SPC_NAME     "Components\\Sapfor_C.exe"
+#define SPC_NAME_NEW "Components\\Sapfor_C_new.exe"
+
+#define VIZ_NAME     "Components\\VisualSapfor.jar"
+#define VIZ_NAME_NEW "Components\\VisualSapfor_new.jar"
+#define FILE_LOG     "Components\\Server_log.txt"
+
+#define SPF_ASYNC    " "
+#else
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#define SOCKET int
+#define INVALID_SOCKET (SOCKET)(~0)
+#define SOCKADDR sockaddr 
+#define closesocket close
+
+#define SPF_NAME      "Components/Sapfor_F"
+#define SPF_NAME_NEW  "Components/Sapfor_F_new"
+
+#define SPC_NAME      "Components/Sapfor_C"
+#define SPC_NAME_NEW  "Components/Sapfor_C_new"
+
+#define VIZ_NAME      "Components/VisualSapfor.jar"
+#define VIZ_NAME_NEW  "Components/VisualSapfor_new.jar"
+#define FILE_LOG      "Components/Server_log.txt"
+
+#define SPF_ASYNC     "&"
+
+void WSACleanup() { }
+int  WSAGetLastError() { return 0; }
+void Sleep(int millisec) { usleep(millisec * 2000); }
+
+#endif
+
+#define __print(prefix, format, ...) do { } while (0)
+
+#define __print_log(file, format, ...) do { } while (0)
+/*
+#define __print(prefix, format, ...) do {\
+   printf((string("%s: ") + format + string("\n")).c_str(), prefix, ##__VA_ARGS__); \
+   fflush(NULL); \
+} while (0)
+
+#define __print_log(file, format, ...) do {\
+   if (file) { \
+       time_t now = time(0);\
+       auto dt = string(ctime(&now)); \
+       dt = dt.erase(dt.size() - 1); \
+       fprintf(file, (string("%s: ") + format + string("\n")).c_str(), dt.c_str(), ##__VA_ARGS__); \
+       fflush(file); \
+   } \
+} while (0)
+*/
+#define SERV "[SERVER]"
+
+static const char* VERSION = "11";
+static FILE* logFile = NULL;
+
+extern void __bst_create(const char* name);
+extern bool __bst_tryToLock();
+extern void __bst_unlock();
+
+
+static void signal_handler(int s)
+{
+    __print(SERV, "Caught signal %d", s);
+    __bst_unlock();
+    exit(1);
+}
+
+static int getPort(const SOCKET& listenSocket)
+{
+    sockaddr_in info;
+    socklen_t len = sizeof(info);
+    memset(&info, 0, len);
+
+    int err = getsockname(listenSocket, (sockaddr*)&info, &len);
+    if (err != 0)
+    {
+        __print(SERV, "Error of getaddrinfo(): %d", err);
+        WSACleanup();
+        __bst_unlock();
+        exit(1);
+    }
+    return ntohs(info.sin_port);
+}
+
+static int initServer(SOCKET& listenSocket, const string& address, int port = 0)
+{
+    int iResult;
+#if _WIN32	
+    WSADATA wsaData = { 0 };
+    int resultc = WSAStartup(MAKEWORD(2, 0), &wsaData);
+    if (resultc != 0)
+    {
+        __print(SERV, "result of WSAStartup is %d", resultc);
+        return 1;
+    }
+#endif
+
+#if _WIN32
+    addrinfo* result = NULL, hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    hints.ai_flags = AI_PASSIVE;
+
+    iResult = getaddrinfo(address.c_str(), to_string(port).c_str(), &hints, &result);
+    if (iResult != 0)
+    {
+        __print(SERV, "Error of getaddrinfo(): %d", iResult);
+        WSACleanup();
+        return 1;
+    }
+
+    listenSocket = INVALID_SOCKET;
+    listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
+#else
+    listenSocket = socket(AF_INET, SOCK_STREAM, 0);
+#endif
+    if (listenSocket < 0)
+    {
+        __print(SERV, "Error of socket(): %d", listenSocket);
+        WSACleanup();
+        return 1;
+    }
+
+	linger lin;
+    lin.l_onoff = 1;
+    lin.l_linger = 2;
+    iResult = setsockopt(listenSocket, SOL_SOCKET, SO_LINGER, (char*)(&lin), sizeof(lin));
+    if (iResult != 0)
+    {
+        __print(SERV, "Error of setsockopt(): %d", iResult);
+        return 1;
+    }
+	
+    
+#if _WIN32
+    iResult = bind(listenSocket, result->ai_addr, result->ai_addrlen);
+#else
+    sockaddr_in addr;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    iResult = ::bind(listenSocket, (struct sockaddr*) & addr, sizeof(addr));
+#endif
+    if (iResult < 0)
+    {
+        __print(SERV, "Bind failed with error: %d", iResult);
+        closesocket(listenSocket);
+        WSACleanup();
+        return 1;
+    }
+
+    iResult = listen(listenSocket, 1);
+    if (iResult < 0)
+    {
+        __print(SERV, "Listen failed with error: %d", iResult);
+        closesocket(listenSocket);
+        WSACleanup();
+        return 1;
+    }
+    return 0;
+}
+
+static int initClient(SOCKET& javaSocket, const string& address, int port)
+{
+    javaSocket = socket(AF_INET, SOCK_STREAM, 0);
+	
+    if (javaSocket == INVALID_SOCKET)
+    {
+        __print(SERV, "Error of creating java socket");
+        return -1;
+    }
+
+	linger lin;
+    lin.l_onoff = 1;
+    lin.l_linger = 2;
+    int iResult = setsockopt(javaSocket, SOL_SOCKET, SO_LINGER, (char*)(&lin), sizeof(lin));
+    if (iResult != 0)
+    {
+        __print(SERV, "Error of setsockopt(): %d", iResult);
+        return 1;
+    }
+	
+    sockaddr_in clientService;
+    clientService.sin_family = AF_INET;
+    clientService.sin_addr.s_addr = inet_addr(address.c_str());
+    clientService.sin_port = htons(port);
+    int result = connect(javaSocket, (SOCKADDR*)(&clientService), sizeof(clientService));
+
+    if (result != 0)
+        __print(SERV, "Error %d of connect to socket %s: %d", WSAGetLastError(), address.c_str(), port);
+
+    return result;
+}
+
+static volatile bool spfRun = false;
+static volatile int retCodeF = 0;
+static void runSapfor(const string command)
+{
+    spfRun = true;
+    __print("[SERVER-th1]", "Try to start Sapfor");
+    __print_log(logFile, "Try to start Sapfor");
+    retCodeF = 0;
+    retCodeF = system(command.c_str());
+    __print("[SERVER-th1]", "SAPFOR done with exit code %d", retCodeF);
+    __print_log(logFile, "SAPFOR done with exit code %d", retCodeF);
+    spfRun = false;
+}
+
+static volatile bool spcRun = false;
+static volatile int retCodeC = 0;
+static void runSapforC(const string command)
+{
+    spcRun = true;
+    __print("[SERVER-th3]", "Try to start Sapfor(C)");
+    __print_log(logFile, "Try to start Sapfor(C)");
+    retCodeC = 0;
+    retCodeC = system(command.c_str());
+    __print("[SERVER-th3]", "SAPFOR(C) done with exit code %d", retCodeC);
+    __print_log(logFile, "SAPFOR(C) done with exit code %d", retCodeC);
+    spcRun = false;
+}
+
+static volatile bool vizRun = false;
+static void runVisulizer(const string command)
+{
+    vizRun = true;
+    __print("[SERVER-th2]", "Try to start Visualizer");
+    __print_log(logFile, "Try to start Visualizer");
+    int id = system(command.c_str());
+    __print("[SERVER-th2]", "Visualizer done with exit code %d", id);
+    __print_log(logFile, "Visualizer done with exit code %d", id);
+    vizRun = false;
+}
+
+static bool doCommand(SOCKET& spfSoc, SOCKET& javaSoc, SOCKET& serverSoc1, SOCKET& serverSoc2, const string& command, bool& needToUpdateViz, string &returnToJava)
+{
+    if (command.find("restart:") == 0)
+    {
+        __print(SERV, "Restart SAPFOR");
+        closesocket(spfSoc);
+        spfSoc = INVALID_SOCKET;
+
+        //wait shutdown of spf
+        while (spfRun)
+            ;
+
+        return true;
+    }
+    else if (command.find("close:") == 0)
+    {
+        __print(SERV, "Shutdown");
+        closesocket(spfSoc);
+        closesocket(javaSoc);
+        closesocket(serverSoc1);
+        closesocket(serverSoc2);
+        javaSoc = spfSoc = INVALID_SOCKET;
+
+        Sleep(500);
+        __bst_unlock();
+        exit(0);
+    }
+    else if (command.find("update:") == 0)
+    {
+        __print(SERV, "Update Visualizer");
+        closesocket(spfSoc);
+        closesocket(javaSoc);
+        javaSoc = spfSoc = INVALID_SOCKET;
+
+        //wait shutdown of viz
+        while (vizRun)
+            ;
+
+        //copy new version
+        if (fs::exists(VIZ_NAME_NEW))
+        {
+            int countOf = 0;
+            error_code err;
+            do {
+                ++countOf;
+                fs::copy_file(VIZ_NAME_NEW, VIZ_NAME, fs::copy_options::overwrite_existing, err);
+                __print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
+                if (err.value() != 0)
+                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            } while (err.value() != 0 && countOf < 5);            
+        }
+        else
+            __print(SERV, "Can not find new version of Visualizer in '%s' path", VIZ_NAME_NEW);
+        //restart
+        needToUpdateViz = true;
+        return true;
+    }
+    else if (command.find("update_spf:") == 0)
+    {
+        __print(SERV, "Update SAPFOR");
+        closesocket(spfSoc);
+        spfSoc = INVALID_SOCKET;
+
+        //wait shutdown of spf
+        while (spfRun)
+            ;
+        //copy new version
+        if (fs::exists(SPF_NAME_NEW))
+        {
+            int countOf = 0;
+            error_code err;
+            do {
+                ++countOf;
+                fs::copy_file(SPF_NAME_NEW, SPF_NAME, fs::copy_options::overwrite_existing, err);
+                __print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
+                if (err.value() != 0)
+                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            } while (err.value() != 0 && countOf < 5);
+        }
+        else
+            __print(SERV, "Can not find new version of sapfor in '%s' path", SPF_NAME_NEW);
+        //restart
+        return true;
+    }
+    else if (command.find("update_spc:") == 0)
+    {
+        __print(SERV, "Update SAPFOR");
+        closesocket(spfSoc);
+        spfSoc = INVALID_SOCKET;
+
+        //wait shutdown of spc
+        while (spcRun)
+            ;
+        //copy new version
+        if (fs::exists(SPC_NAME_NEW))
+        {
+            int countOf = 0;
+            error_code err;
+            do {
+                ++countOf;
+                fs::copy_file(SPC_NAME_NEW, SPC_NAME, fs::copy_options::overwrite_existing, err);
+                __print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
+                if (err.value() != 0)
+                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            } while (err.value() != 0 && countOf < 5);
+        }
+        else
+            __print(SERV, "Can not find new version of sapfor in '%s' path", SPC_NAME_NEW);
+        //restart
+        return true;
+    }
+    else if (command.find("update_server:") == 0)
+    {
+        __print(SERV, "Update SERVER");
+        closesocket(spfSoc);
+        spfSoc = INVALID_SOCKET;
+
+        //wait shutdown of spf
+        while (spfRun)
+            ;
+
+        //wait shutdown of spc
+        while (spcRun)
+            ;
+
+        closesocket(javaSoc);
+        javaSoc = INVALID_SOCKET;
+        __print(SERV, "SAPFOR was closed, Visualizer socker was closed, exit");
+
+        Sleep(500);
+        __bst_unlock();
+        exit(0);
+    }
+    else if (command.find("get_version:") == 0)
+    {
+        __print(SERV, "Get version of server: %s", VERSION);
+        returnToJava = string(VERSION) + " |" + __DATE__ + "| |" + __TIME__ + "|\n";
+        return true;
+    }
+    else if (command.find("get_pid:") == 0)
+    {
+        unsigned int pid = 0;
+#ifdef _WIN32
+        pid = GetCurrentProcessId();
+#else
+        pid = getpid();
+#endif
+        const string pids = std::to_string(pid);
+        __print(SERV, "Get pid of server: %s", pids.c_str());
+        returnToJava = pids + "\n";
+        return true;
+    }
+    else
+    {
+        string copy = command;
+        if (copy.back() == '\n')
+            copy = copy.erase(copy.size() - 1);
+        __print(SERV, "Recv command %s", copy.c_str());
+    }
+    return false;
+}
+
+static void closeAndExit(const vector<SOCKET>& toClose, const string& message, int exitCode = 0)
+{
+    for (auto& elem : toClose)
+        closesocket(elem);
+    if (message != "")
+        __print(SERV, "%s", message.c_str());
+    __bst_unlock();
+    exit(exitCode);
+}
+
+static bool isSapforDebug(int argc, char** argv)
+{
+    for (int z = 1; z < argc; ++z)
+        if (string("-spfDeb") == argv[z])
+            return true;
+    return false;
+}
+
+static bool isVizDebug(int argc, char** argv)
+{
+    for (int z = 1; z < argc; ++z)
+        if (string("-vizDeb") == argv[z])
+            return true;
+    return false;
+}
+
+static string getJavaPath(int argc, char** argv)
+{
+    string path = "";
+    for (int z = 1; z < argc; ++z)
+        if (string("-javaPath") == argv[z])
+            return argv[z + 1];
+
+    return path;
+}
+
+static int doRecv(SOCKET& soc, string& command)
+{
+    int count = 0; //общее количество прочитаного
+    int err = 0; //количество прочитанного на данной итерации.
+    const int maxSize = 4096; //максимальный размер прочитываемой за раз порции.
+    char* buf = NULL; //буфер
+    do
+    {
+        buf = new char[maxSize + 1];
+        err = recv(soc, buf, maxSize, 0);
+        if (err > 0) 
+        {
+            count += err;
+            buf[err] = '\0';
+            command += buf;
+        }
+        delete[] buf;
+        buf = NULL;
+
+    } while (err > 0 && command.back() != '\n');
+    __print(SERV, "'%s' length='%d'\n", command.c_str(), command.length());
+    return err < 0 ? err : count;
+}
+
+int main(int argc, char** argv)
+{
+    if (argc == 2 && argv[1] == string("-help"))
+    {
+        printf("commands:\n");
+        printf("  -hashSkip\n");
+        printf("  -unlock\n");
+        printf("  -javaPath <path>\n");
+        exit(0);
+    }
+
+    signal(SIGINT, signal_handler);
+    signal(SIGABRT, signal_handler);
+#if _WIN32
+    signal(SIGBREAK, signal_handler);
+#else
+    signal(SIGKILL, signal_handler);
+#endif
+
+    char buff[1024];
+    char* test = getcwd(buff, 1024);
+
+    const string path = test ? buff : argv[0];
+    bool isSpfDeb = isSapforDebug(argc, argv);
+    bool isVizDeb = isVizDebug(argc, argv);
+    string javaPath = getJavaPath(argc, argv);
+
+    if (argc == 2 && argv[1] == string("-hashSkip"))
+        ;
+    else
+    {
+        const size_t hashOfPath = hash<string>{}(path);
+        __print(SERV, "Open or create mutex of '%s' path, hash = %zu", path.c_str(), hashOfPath);
+
+        __bst_create(to_string(hashOfPath).c_str());
+        if (argc == 2 && argv[1] == string("-unlock"))
+        {
+            if (!__bst_tryToLock())
+            {
+                __print(SERV, "Try to unlock '%s' path", path.c_str());
+                __bst_unlock();
+                exit(0);
+            }
+        }
+
+        if (!__bst_tryToLock())
+        {
+            __print(SERV, "The instance of Visualizer from '%s' path was started", path.c_str());
+            exit(0);
+        }
+    }
+    logFile = fopen(FILE_LOG, "w");
+    if (logFile == NULL)
+        __print(SERV, "Can not open log file '%s'", FILE_LOG);
+
+    setlocale(LC_ALL, "Russian");
+    SOCKET serverSPF = INVALID_SOCKET, serverJAVA = INVALID_SOCKET;
+    int sapforPort = 0, javaPort = 0;
+
+    __print_log(logFile, "create socket for Sapfor");
+    if (initServer(serverSPF, "127.0.0.1", sapforPort) != 0) // create server for Sapfor
+        return -1;
+    sapforPort = getPort(serverSPF);
+    __print_log(logFile, "done with port %d", sapforPort);
+
+    __print_log(logFile, "create socket for Visualizer");
+    if (initServer(serverJAVA, "127.0.0.1", javaPort) != 0) // create server for Visuzlier
+    {
+        closesocket(serverSPF);
+        return -1;
+    }
+    javaPort = getPort(serverJAVA);
+    __print_log(logFile, "done with port %d", javaPort);
+
+    printf("SOCKET PORT for SAPFOR %d, SOCKET PORT for Visualizer %d\n", sapforPort, javaPort);
+
+    const int maxSize = 4096;
+    char* buf = new char[maxSize + 1];
+
+    int err;
+    
+    SOCKET spfSoc = INVALID_SOCKET, javaSoc = INVALID_SOCKET;
+    bool needToUpdateViz = true;
+    int t = 0;
+
+    __print_log(logFile, "start main communications");
+    while (true)
+    {
+        if (!vizRun && needToUpdateViz && !isVizDeb)
+        {
+            __print_log(logFile, "try to restart Visualizer, flags before: vizRun(%d), needToUpdateViz(%d), isVizDeb(%d)", 
+                        vizRun, needToUpdateViz, isVizDeb);
+
+            __print(SERV, "Run Visualizer from '%s' path with port %d", VIZ_NAME, javaPort);
+            if (fs::exists(VIZ_NAME))
+            {                
+                needToUpdateViz = false;
+                string toRun = string("-Dfile.encoding=UTF-8 -jar ") + VIZ_NAME + " --port " + to_string(javaPort) + SPF_ASYNC;
+                if (javaPath != "")
+                    toRun = "\"" + javaPath + "\\java\" " + toRun;
+                else
+                    toRun = "java " + toRun;
+
+                __print_log(logFile, "try to start with command '%s'", toRun.c_str());
+
+                thread viz(runVisulizer, toRun);
+                viz.detach();
+                
+                __print_log(logFile, "done");
+                //wait run of viz
+                //while (!vizRun) ;
+            }
+            else
+            {
+                __print(SERV, "Can not find Visualizer in '%s' path", VIZ_NAME);
+                __print_log(logFile, "Can not find Visualizer in '%s' path", VIZ_NAME);
+                //closeAndExit({ serverSPF , serverJAVA }, "Component not found", -1);
+            }
+        }
+
+        if (!spfRun && !isSpfDeb)
+        {
+            __print_log(logFile, "try to restart Sapfor, flags before: spfRun(%d), isSpfDeb(%d)",
+                        spfRun, isSpfDeb);
+
+            __print(SERV, "Run Sapfor from '%s' path with port %d", SPF_NAME, sapforPort);
+            if (fs::exists(SPF_NAME))
+            {
+                const string toRun = SPF_NAME + string(" -client ") + to_string(sapforPort) + SPF_ASYNC;
+                __print_log(logFile, "try to start with command '%s'", toRun.c_str());
+
+                thread sapfor(runSapfor, toRun);
+                sapfor.detach();
+
+                __print_log(logFile, "done");
+                //wait run of spf
+                //while (!spfRun) ;
+            }
+            else
+            {
+                __print(SERV, "Can not find Sapfor in '%s' path", SPF_NAME);
+                __print_log(logFile, "Can not find Sapfor in '%s' path", SPF_NAME);
+                //closeAndExit({ serverSPF , serverJAVA }, "Component not found", -1);
+            }
+        }
+
+        bool spfExists = (fs::exists(SPF_NAME) || isSpfDeb);
+
+        __print_log(logFile, "start connections");
+
+        for (int z = 0; z < 2; ++z)
+        {
+            if (javaSoc == INVALID_SOCKET && z == 1)
+            {
+                __print_log(logFile, "wait acception from Visualizer");
+                javaSoc = accept(serverJAVA, NULL, NULL);
+                if (javaSoc != INVALID_SOCKET)
+                {
+                    __print(SERV, "VISUALIZER connected to server");
+                    __print_log(logFile, "VISUALIZER connected to server");
+                }
+            }
+
+            if (spfSoc == INVALID_SOCKET && z == 0 && spfExists)
+            {
+                __print_log(logFile, "wait acception from Sapfor");
+                spfSoc = accept(serverSPF, NULL, NULL);
+                if (spfSoc != INVALID_SOCKET)
+                {
+                    __print(SERV, "SAPFOR connected to server");
+                    __print_log(logFile, "SAPFOR connected to server");
+                }
+            }
+        }
+        __print_log(logFile, "done connections");
+
+        while ( ((spfSoc != INVALID_SOCKET && spfExists) || (!fs::exists(SPF_NAME) && !isSpfDeb)) && 
+                 javaSoc != INVALID_SOCKET)
+        {
+            string retCode = "";
+            string command = "";
+
+            __print_log(logFile, "wait for command from Visualizer");
+            err = doRecv(javaSoc, command);
+            __print_log(logFile, "done with code %d", err);
+            if (err <= 0)
+            {
+                __print(SERV, "Error recv from Visualizer with code %d", err);
+                __print_log(logFile, "error recv from Visualizer with code %d", err);
+                closesocket(javaSoc);
+                closesocket(spfSoc);
+                javaSoc = spfSoc = INVALID_SOCKET;
+                break;
+            }
+            else
+            {
+                string returnToJava = "";
+                __print_log(logFile, "do command '%s'", command.c_str());
+                if (doCommand(spfSoc, javaSoc, serverSPF, serverJAVA, command, needToUpdateViz, returnToJava))
+                {
+                    if (javaSoc != INVALID_SOCKET)
+                    {
+                        int needToRecv = 1;
+                        if (returnToJava == "")
+                            buf[0] = '\n';
+                        else
+                        {
+                            memcpy(buf, returnToJava.c_str(), sizeof(char) * returnToJava.size());
+                            needToRecv = returnToJava.size();
+                        }
+
+                        int err = send(javaSoc, buf, needToRecv, 0);
+                        if (err != needToRecv)
+                        {
+                            closesocket(javaSoc);
+                            javaSoc = INVALID_SOCKET;
+                            __print_log(logFile, "done with invalid break ");
+                            break;
+                        }
+                        else
+                        {
+                            //after 'get_version' command
+                            if (needToRecv > 1)
+                            {
+                                __print_log(logFile, "done with continue");
+                                continue;
+                            }
+                        }
+                    }
+                    __print_log(logFile, "done with break");
+                    break;
+                }
+                __print_log(logFile, "done");
+            }
+
+            __print_log(logFile, "try to send command to Sapfor with size %d", command.size());
+            err = send(spfSoc, command.c_str(), command.size(), 0);
+            __print_log(logFile, "done with code %d", err);
+
+            if (err != command.size())
+            {
+                __print(SERV, "Error of send(): %d", err);
+                __print_log(logFile, "error of send(): %d", err);
+                closesocket(spfSoc);
+                spfSoc = INVALID_SOCKET;
+            }
+            else
+                __print(SERV, "Send command to SAPFOR");
+
+            __print_log(logFile, "try to recv answer from Sapfor");
+            err = recv(spfSoc, buf, maxSize, 0);
+            __print_log(logFile, "done with code %d", err);
+
+            int sizeLong = -1;
+            char* bufLong = NULL;
+
+            if (err <= 0)
+            {
+                __print(SERV, "Error recv(): %d", err);
+                __print_log(logFile, "error recv(): %d", err);
+                closesocket(spfSoc);
+                spfSoc = INVALID_SOCKET;
+
+                if (spfRun)
+                    retCode = "WRONG\n";
+                else
+                {
+                    if (fs::exists(SPF_NAME))
+                    {
+                        if (retCodeF != 0)
+                            retCode = "SIG_FAULT\n";
+                        else
+                            retCode = "WRONG\n";
+                    }
+                    else
+                        retCode = "NOT_FOUND\n";
+                }
+            }
+            else
+            {
+                if (err >= maxSize)
+                    closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
+
+                buf[err] = '\0';
+                err = sscanf(buf, "%d", &sizeLong);
+                if (err == -1)
+                    closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
+
+                bufLong = (char*)malloc(sizeof(char) * (sizeLong + 1));
+                if (bufLong == NULL)
+                {
+                    __print(SERV, "Error in malloc, exit, need to alloc %d", sizeLong + 1);
+                    closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "", -1);
+                }
+            }
+
+            if (retCode.find("WRONG") == string::npos && 
+                retCode.find("NOT_FOUND") == string::npos &&
+                retCode.find("SIG_FAULT") == string::npos)
+            {
+                retCode = "";
+                err = send(spfSoc, buf, 1, 0);
+                int start = 0;
+                int sum = 0;
+                while (sum != sizeLong)
+                {
+                    __print_log(logFile, "try to recv results from Sapfor");
+                    err = recv(spfSoc, bufLong + start, sizeLong - sum, 0);
+                    __print_log(logFile, "done with code %d", err);
+                    if (err <= 0)
+                    {
+                        __print(SERV, "Error of recv from SAPFOR with code %d", err);
+                        __print_log(logFile, "error of recv from SAPFOR with code %d", err);
+                        retCode = "WRONG\n";
+                        closesocket(spfSoc);
+                        spfSoc = INVALID_SOCKET;
+                        break;
+                    }
+                    else
+                        __print(SERV, "Recv from SAPFOR result == %d size, request size %d", err, sizeLong - sum);
+                    sum += err;
+                    start += err;
+                }
+                __print(SERV, "Recv from SAPFOR total %d size", sum);
+                __print_log(logFile, "done recv from SAPFOR with total %d size", sum);
+
+                if (sum >= sizeLong + 1)
+                    closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
+
+                bufLong[sum] = '\0';
+                retCode = bufLong;
+                free(bufLong);
+            }
+            else 
+                __print(SERV, "Send error code to Visualizer: %s", retCode.c_str());
+
+            __print_log(logFile, "send response to Sapfor");
+            err = send(spfSoc, buf, 1, 0);
+            __print_log(logFile, "done with code %d", err);
+
+            __print_log(logFile, "send response to Visualizer");
+            err = send(javaSoc, retCode.c_str(), retCode.size(), 0);
+            __print_log(logFile, "done with code %d", err);
+            if (err != retCode.size())
+            {
+                __print(SERV, "Error send to Visualizer");
+                __print_log(logFile, "error send to Visualizer");
+                closesocket(spfSoc);
+                closesocket(javaSoc);
+                javaSoc = spfSoc = INVALID_SOCKET;
+                break;
+            }
+            else
+                __print(SERV, "Send result to Visualizer %d", (int)retCode.size());
+        }
+        __print(SERV, "Invalid SAPFOR socket, try to restart");
+        __print_log(logFile, "invalid SAPFOR socket, try to restart");
+        Sleep(100);
+    }
+
+    __bst_unlock();
+    return 0;
+}
+