DiagManager Sample Program

Together with the DiagManager a utility program OpenTestSystem.Otx.DiagManager.Runner.exe to start the DiagManager is delivered, see Installation. With this utility the DiagManager server can be started easily. The program is a console application with command line parameters (arguments). The application will start an OpenTestSystem.Otx.DiagManager.Server inside its own process.

Note: Without the DiagManager no diagnostic communication is possible. For the usage of the OTX-Runtime API a DiagManager must be started explicit. Inside the OTX Development Environment the DiagManager will be started implicit if not already started.

Note: A started DiagManager server can be used by more than one application.

Note: The DiagManager utility program is only a sample application, which shows, how the DiagManager can be used. It shall not be used for productive target environments!

How to start the DiagManager?

The DiagManager utility program must be started with the following arguments. The order of the arguments is not relevant.

Syntax:

OpenTestSystem.Otx.DiagManager.Runner [-options]
 
Options:
 
   -help
   -?
        Print this help message. This option must be used
        exclusive without any other option, otherwise it will
        be ignored.
 
   -port=<PortNumber> [0..1]
        Sets the port number for interprocess communication
        via sockets. The default value is 8888. If the port
        is set explicit, the pipe will be ignored.
 
   -pipe=<PipeName> [0..1]
        Sets the pipe name for interprocess communication via
        pipes. The default value is "???".
 
   -licenseKey=XXXX-XXXX-XXXX-XXXX-XXXX
        Sets a valid license key to active DiagManagerServer. The license
        key has the format "XXXX-XXXX-XXXX-XXXX-XXXX". A valid license
        key must be available. Please ask the software supplier.
 
   -MaxNumberOfConcurrentComChannels=<MaxNumberOfConcurrentComChannels> [0..1]
        Sets maximum number of concurrent ComChannels for the CommandProcessor,
        which can be open at the same time. If the number is exceeded, 
        ComChannels that are no longer used are automatically closed. The 
        default value is "28".
 
   -DiagServiceHandleMapping=<DiagServiceHandleMapping> [0..1]
        Switches the DiagService handle translation of the CommandProcessor
        ON or OFF. Possible value are:
        [
            ON = 1,
            OFF = 0
        ]
        The default value is true. DiagService handle mapping is needed
        to restore DiagService objects of closed and re-opend ComChannels
        when the ComChannels limit is exceeded. The mapping takes time and
        can be switched off, if it is not needed.
 
   -kernelType=<KernelTypeEnum> [0..1]
        Sets the type of the diagnostic runtime system. Possible
        types are:
        [
            VwMcd = 0,
            VwMcdSP = 1
        ]
        The default value is 0 (VwMcd). If the option is not set
        to a valid value, the default value will be used.
 
   -kernelPath=<KernelPath> [1]
        Sets the path to the binary of the diagnostic runtime
        system. If the option is not set to a valid value, the
        DiagManager returns an error.
 
   -configPath=<ConfigPath> [1]
        Sets the path to the configuration folder of the
        diagnostic runtime system. If the option is not set to
        a valid value, the DiagManager returns an error.
 
   -pduApi=<D_PDU_VCI_NAME> [0..1]
        Sets the PDU-API of the diagnostic runtime system.
 
   -javaVmPath=<JavaVmPath> [0..1]
        Sets the path to the Java VM which should be used for
        Java Jobs by the diagnostic runtime system. If the
        value is not set, the Java VM will be searched inside
        the system PATH.
 
   -logPath=<LogPath> [0..1]
        Set the log path. The default log path is "[User]/
        AppData/Roaming/OpenTestSystem/DiagManager/Tracing/".
 
   -logLevel=<LogLevel> [0..1]
        Set the log level (Off = 0, Error = 1, Critical = 2,
        Warning = 3, Info = 4, Debug = 5, Trace = 6). The
        default log level is 3.
 
   -logConfig=<Filename> [0..1]
        Set a logging configuration file. Inside the logging
        configuration file the logPath and the logLevel can
        be overwritten and extended, e.g. Special logLevel for
        one component.
 
   -killAll [0..1]
        All started processes at any port or pipe name will
        be killed. This option must be used exclusive without
        any other option, otherwise it will be ignored. This
        option should only be used to get a clean environment.
        Please note, that this is not a regular exit!
 
Return values:
 
   0    If the server was started successfully or all started
        processes was killed or the help was displayed.
   1    An error occurred. The error message is written into
        the output. Possible errors:
        - The given port number or pipe name is wrong or already
          in use.
        - Kernel path is wrong, does not exist or does not contain
          a valid diagnostic runtime system.
        - Configuration path is wrong, does not exist or does not
          contain a valid configuration file. The configuration
          file format depends on the selected diagnostic runtime
          system.
        - Log path is wrong or cannot be accessed.
        - Log level is wrong.
        - No process to kill exists, see -stopAll option.
        - The server cannot be started, because of any other reason.

Examples:

OpenTestSystem.Otx.DiagManager.Runner -port=8888 -licenseKey=XXXX-XXXX-XXXX-XXXX-XXXX -kernelPath="C:/Program Files (x86)/Volkswagen/VW-MCD_14_0_0/MCD-Kernel" -configPath="C:/ProgramData/emotive/VW-MCD/config"

Code Sample

Sample code of the DiagManager utility program.

#include "../../diagmanager/OpenTestSystem.OtxDiagManager.Server/ServerFactory.h"
#include "../../diagmanager/OpenTestSystem.OtxDiagManager.Server/SocketUtil.h"
using namespace OpenTestSystem::Otx::DiagManager::Server;
#include "../../diagmanager/OpenTestSystem.OtxDiagManager.CommandProcessor/CommandDispatcher.h"
using OpenTestSystem::Otx::DiagManager::CommandProcessor::CommandDispatcher;
#include "../../diagmanager/OpenTestSystem.OtxDiagManager.CommandProcessor/CommandProcessor.h"
using OpenTestSystem::Otx::DiagManager::CommandProcessor::CommandProcessor;
 
#include "IDiagRuntimeSystem.h"
#include "DefaultLogger.h"
#include "LogConfigBase.h"
#include "LogConfigSingleton.h"
#include "CrashHandler.h"
#include "CommonHelper.h"
#include "Parameter.h"
#include "Result.h"
#include "ProtoGen/ResultCodesPb.pb.h"
#include "ProtoGen/CommandTypesPb.pb.h"
#include "ProtoGen/NoneOtxDiagApiCommandsPb.pb.h"
using namespace OpenTestSystem::Otx::DiagManager::Common;
 
#include <filesystem.h>
namespace fs = filesystem;
 
#include <string>
#include <string.h>
 
#include <fstream>
#include <iostream>
#include <vector>
#define MAX_PATH          256
#define LINUX_PIPE_PREFIX "/tmp/OpenTestSystem/pipe/"
 
#ifdef _WIN32
#include <Windows.h>
#include <process.h>
#include <Tlhelp32.h>
#include <winbase.h>
std::string GetLastErrorAsString();
HMODULE DiagRuntimeSystemDLL = NULL;
 
#elif __linux__
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h>
#include <signal.h>
#ifdef  USE_VWMCD_LINK_LIBRARY
    #ifdef USE_VWMCDSP
    #include <VwMcdSPDiagRuntimeSystem.h>
    typedef OpenTestSystem::Otx::DiagManager::DiagRuntimeSystem::VwMcdSPDiagRuntimeSystem VwMcdDiagRuntimeSystem;
    #else
    #include <VwMcdDiagRuntimeSystem.h>
    typedef OpenTestSystem::Otx::DiagManager::DiagRuntimeSystem::VwMcdDiagRuntimeSystem VwMcdDiagRuntimeSystem;
    #endif
#else
#include <dlfcn.h>
void* handle;
#endif //  USE_VWMCD_LINK_LIBRARY
#endif
static std::string fileNameCurrent = "";
static bool isDebug = false;
 
static const std::string HelpKey = "-help";
static const std::string QuestionMarkKey = "-?";
static const std::string PortKey = "-port";
static const std::string PipeKey = "-pipe";
static const std::string KernelPathKey = "-kernelPath";
static const std::string KernelTypeKey = "-kernelType";
static const std::string ConfigPathKey = "-configPath";
static const std::string JavaVmPathKey = "-javaVmPath";
static const std::string LogPathKey = "-logPath";
static const std::string LogLevelKey = "-logLevel";
static const std::string LogConfigKey = "-logConfig";
static const std::string KillAllKey = "-killAll";
static const std::string MaxNumberOfConcurrentComChannelsKey = "-MaxNumberOfConcurrentComChannels";
static const std::string DiagServiceHandleMappingKey = "-DiagServiceHandleMapping";
static const std::string DebugKey = "-debug";
static const std::string PduApiKey = "-pduApi";
static const std::string LicenseKey = "-licenseKey";
 
enum KernelTypes
{
    VwMcd = 0,
    VwMcdSP = 1,
    ProdisMcd = 2 // This may not needed in future.
};
 
void SetDefaultArgumentsForRunner(std::map<std::string, std::string>& arguments);
void PrintUsage();
bool KillAllProccesses();
bool UpdateArgumentsByCommandLine(int argc, char** argv, std::map<std::string, std::string>& arguments);
bool SetupLogger(std::string& logPath, int logLevel, std::string& logConfig);
bool SetupLogger(std::string &logPath, int logLevel, std::string &logConfig, std::string portNumber, std::string pipeName);
bool SetupCommandProcessor(CommandProcessor* commandProcessor, std::map<std::string, std::string> & arguments);
bool SetPathForVariableEnvironment(std::string kernelPath, std::string configPath, std::string javavmPath);
IDiagRuntimeSystem* CreateDiagRuntimeSystemInstance(const char * projectName, const char * vehicleInfo, const char* kernelPath, KernelTypes kernelType = KernelTypes::VwMcd);
void PrintDebugTextToConsole(std::string message);
std::string RemoveOldMcdHomeFromPathEnv();
int SetVariableEnvironment(const std::string& env);
void PrintAvaiablePduApi(IDiagRuntimeSystem* drs);
void SwitchPduApi(IDiagRuntimeSystem* drs, const std::string& shortName);
 
#ifdef WIN32
void Check32And64BitConflict(std::string kernelPath);
bool IsWow64();
bool Is32BitRunner();
bool Is32BitKernelExist(std::string kernelPath);
bool Is64BitKernelExist(std::string kernelPath);
#endif // WIN32
 
 
int main(int argc, char** argv)
{
    /*MessageBox(0, NULL, "Diag Runner", MB_OK | MB_ICONQUESTION);*/  // used for debugging
    ILog log("OpenTestSystem::Otx::DiagManager::Runner");
    CommandProcessor cmdProcessor;
    std::string kernelPath, configPath, javavmPath;
    std::string logPath, logConfig;
    std::string licenseKey;
    int kernelType;
    int logLevel;
    std::map<std::string, std::string> arguments;
    SetDefaultArgumentsForRunner(arguments);
 
    try {
        fileNameCurrent = std::string(argv[0]);
 
#ifdef _WIN32
        fileNameCurrent = fileNameCurrent.substr(fileNameCurrent.find_last_of('\\') + 1);
 
#elif __linux__
        // fileNameCurrent = fileNameCurrent.substr(fileNameCurrent.find_last_of('\/') + 1); // warning: unknown escape sequence: '\/'
        fileNameCurrent = fileNameCurrent.substr(fileNameCurrent.find_last_of('/') + 1);
#endif
 
        if (argc == 1 || (argc == 2 && (argv[1] == HelpKey || argv[1] == QuestionMarkKey)))
        {
            PrintUsage();
            return EXIT_SUCCESS;
        }
 
        PrintDebugTextToConsole("Initializing...");
        if (argc == 2 && argv[1] == KillAllKey)
        {
            PrintDebugTextToConsole("Killing all proccesses...!");
            KillAllProccesses();
            PrintDebugTextToConsole("Killed all proccesses!");
 
            return EXIT_SUCCESS;
        }
 
        PrintDebugTextToConsole("Updating arguments...!");
        UpdateArgumentsByCommandLine(argc, argv, arguments);
 
        logPath = arguments[LogPathKey];
        logConfig = arguments[LogConfigKey];
        logLevel = atoi(arguments[LogLevelKey].c_str());
 
        PrintDebugTextToConsole("Setting up the logger...");
        if (!SetupLogger(logPath, logLevel, logConfig, arguments[PortKey], arguments[PipeKey]))
        {
            PrintDebugTextToConsole("Setting up the logger failed!");
            return EXIT_FAILURE;
        }
        
        kernelPath = arguments[KernelPathKey];
        configPath = arguments[ConfigPathKey];
        javavmPath = arguments[JavaVmPathKey];
        licenseKey = arguments[LicenseKey];
 
        PrintDebugTextToConsole("Setting the environment variable path...");
        if (!SetPathForVariableEnvironment(kernelPath, configPath, javavmPath))
        {
            log.Error("Setting the environment variable path failed!");
            PrintDebugTextToConsole("Setting the environment variable path failed!");
            return EXIT_FAILURE;
        }
 
        PrintDebugTextToConsole("Setting up the command processor...");
        if (!SetupCommandProcessor(&cmdProcessor, arguments))
        {
            log.Error("Setting up the command processor failed!");
            PrintDebugTextToConsole("Setting up the command processor failed!");
            return EXIT_FAILURE;
        }
 
        kernelType = atoi(arguments[KernelTypeKey].c_str());
 
        Server* sv = NULL;
 
        ServerFactory sFactory;
        if (!arguments[PortKey].empty())
        {
            int port = atoi(arguments[PortKey].c_str());
 
            if (port < 1)
            {
                log.Error("The port is wrong!!!");
                PrintDebugTextToConsole("The port is wrong!!!");
 
                return EXIT_FAILURE;
            }
 
            if (OpenTestSystem::Otx::DiagManager::Server::SocketUtil::CheckPortInUse(port))
            {
                std::string message = "The port " + std::to_string(port) + " is in used.";
                log.Error(message);
                PrintDebugTextToConsole(message);
 
                return EXIT_FAILURE;
            }
 
            sFactory.SetSocketPort(port);
 
            PrintDebugTextToConsole("Creating server with port " + std::to_string(port) + "...");
            sv = sFactory.Create(ServerType::Socket);
        }
        else if (!arguments[PipeKey].empty())
        {
            sFactory.SetPipeName(arguments[PipeKey]);
            PrintDebugTextToConsole("Creating server with pipe " + arguments[PipeKey] + "...");
            sv = sFactory.Create(ServerType::Pipe);
        }
 
        if (sv)
        {
            sv->SetDebugMode(isDebug);
            sv->SetRuntimeSystemCreationHandler([kernelPath, kernelType, &cmdProcessor, &arguments]() {
                PrintDebugTextToConsole("Setting up the DiagRuntimeSystem...");
                IDiagRuntimeSystem* diagRuntime = CreateDiagRuntimeSystemInstance("", "", kernelPath.c_str(), (KernelTypes)kernelType);
                cmdProcessor.SetRuntimeSystem(diagRuntime);
                std::string pduApi = arguments[PduApiKey];
                if (!pduApi.empty())
                {
                    ::SwitchPduApi(diagRuntime, pduApi);
                }
 
                return diagRuntime;
                });
 
            if (!licenseKey.empty())
            {               
                sv->SetLicenseKey(licenseKey);
            }
            else
            {
                PrintDebugTextToConsole("A license key is required to activate DiagManager.");
            }
            
            sv->SetCommandProcessor(&cmdProcessor);
            PrintDebugTextToConsole("The server is ready.");
            sv->Start(isDebug);
            PrintDebugTextToConsole("The server is stopped.");
#ifdef _WIN32
            // Please answer questions if you uncomment below code
            // Why terminate the process?
            // Why exit code is FAILURE?
            //TerminateProcess(GetCurrentProcess(), 1);
#elif __linux__
            //kill(::getpid() , SIGKILL);
#endif
        }
    }
    catch (std::exception& ex)
    {
        std::string message = "Error: " + std::string(ex.what());
        log.Error(ex.what());
        PrintDebugTextToConsole(message);
        PrintUsage();
 
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}
 
 
IDiagRuntimeSystem* CreateDiagRuntimeSystemInstance(const char * projectName, const char * vehicleInfo, const char* kernelPath, KernelTypes kernelType)
{
#ifdef _WIN32
    // represents vwmcd version 17.50.x.x
    std::string DiagRuntimeSystem_17_50_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd_VC142.dll";
    // represents vwmcdsp version 17.50.0.x.x
    std::string DiagRuntimeSystemSP_17_50_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcdSP_VC142.dll";
    // represents vwmcd version 9.00.x.x to 14.00.x.x
    std::string DiagRuntimeSystem_09_00_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.dll";
    // represents vwmcdsp version 9.00.x.x to 14.00.x.x
    std::string DiagRuntimeSystemSP_09_00_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd90SP.dll";
    // represents Prodis mcd
    std::string DiagRuntimeSystem_Prodis_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.ProdisMcd.dll";
    // represents Actia mcd
    std::string DiagRuntimeSystem_Actia_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.ActiaMcd.dll";
    // represents Siemens mcd
    std::string DiagRuntimeSystem_Siemens_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.SiemensMcd.dll";
 
    // Default use mcd version 17.50.x.x
    std::string DiagRuntimeSystemFileName = DiagRuntimeSystem_17_50_FileName;
    std::string kernelTypeStr = "VwMcd1750";
    if (kernelType == KernelTypes::VwMcdSP)
    {
        kernelTypeStr = "VwMcd1750SP";
        DiagRuntimeSystemFileName = DiagRuntimeSystemSP_17_50_FileName;
    }
 
    if (fs::exists(std::string(kernelPath) + "/McdKernel_vc120.dll")
        || fs::exists(std::string(kernelPath) + "/McdKernel_vc120_64.dll")) // check vwmcd 90
    {
        if (kernelType == KernelTypes::VwMcdSP)
        {
            kernelTypeStr = "VwMcd90SP";
            DiagRuntimeSystemFileName = DiagRuntimeSystemSP_09_00_FileName;
        }
        else
        {
            kernelTypeStr = "VwMcd90";
            DiagRuntimeSystemFileName = DiagRuntimeSystem_09_00_FileName;
        }
    }
    else if (fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142.dll")
        || fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142_64.dll"))
    {
        kernelTypeStr = "ProdisMcd";
        DiagRuntimeSystemFileName = DiagRuntimeSystem_Prodis_FileName;
    }
    else if (fs::exists(std::string(kernelPath) + "/DiagServer.dll"))
    {
        kernelTypeStr = "ActiaMcd";
        DiagRuntimeSystemFileName = DiagRuntimeSystem_Actia_FileName;
    }
    else if (fs::exists(std::string(kernelPath) + "/dkernel-core-vw.dll"))
    {
        kernelTypeStr = "SiemensMcd";
        DiagRuntimeSystemFileName = DiagRuntimeSystem_Siemens_FileName;
    }
 
    PrintDebugTextToConsole("The Kernel Type is " + kernelTypeStr + ".");
    if (DiagRuntimeSystemDLL == NULL)
    {
        DiagRuntimeSystemDLL = ::LoadLibrary(DiagRuntimeSystemFileName.c_str());
    }
 
    if (DiagRuntimeSystemDLL == NULL)
    {
        std::string errorMessage = GetLastErrorAsString();
        PrintDebugTextToConsole(errorMessage);
        Check32And64BitConflict(std::string(kernelPath));
 
        return nullptr;
    }
    typedef IDiagRuntimeSystem* (__cdecl* typeCreateDiagRuntimeSystem)(const char * projectName, const char * vehicleInfo);
    typeCreateDiagRuntimeSystem createFunction = reinterpret_cast<typeCreateDiagRuntimeSystem>(::GetProcAddress(DiagRuntimeSystemDLL, "CreateDiagRuntimeSystem"));
 
    if (createFunction == nullptr)
        return nullptr;
 
    return createFunction(projectName, vehicleInfo);
#elif __linux__
    #ifdef  USE_VWMCD_LINK_LIBRARY
    return new VwMcdDiagRuntimeSystem(projectName, vehicleInfo);
    #else
    if (!handle && kernelType == KernelTypes::VwMcd)
    {
        PrintDebugTextToConsole("Kernel Type is VwMcd");
        handle = dlopen("libOpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd.so", RTLD_NOW);
    }
    else if (!handle && kernelType == KernelTypes::VwMcdSP)
    {
        PrintDebugTextToConsole("Kernel Type is VwMcdSP");
        handle = dlopen("libOpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcdSP.so", RTLD_NOW);
    }
 
    if (!handle) {
        /* fail to load the library */
        std::cout << dlerror() << std::endl;
        return nullptr;
    }
    typedef IDiagRuntimeSystem* typeCreateDiagRuntimeSystem(const char* projectName, const char* vehicleInfo);
    typeCreateDiagRuntimeSystem* createFunction = reinterpret_cast<typeCreateDiagRuntimeSystem*>(dlsym(handle, "CreateDiagRuntimeSystem"));
 
    if (!createFunction)
    {
        dlclose(handle);
        return nullptr;
    }
    IDiagRuntimeSystem* digRuntimeSystem = createFunction(projectName, vehicleInfo);
    dlclose(handle);
    createFunction = NULL;
    return digRuntimeSystem;
    #endif
#endif
}
 
#ifdef WIN32
void Check32And64BitConflict(std::string kernelPath)
{
    try
    {
        bool isRunner32 = Is32BitRunner();
        bool isKernel32Exist = Is32BitKernelExist(kernelPath);
        bool isKernel64Exist = Is64BitKernelExist(kernelPath);
 
        if (isRunner32 != isKernel32Exist
            && isRunner32 == isKernel64Exist)
        {
            std::string runnerBit = isRunner32 ? "32" : "64";
            std::string kernelBit = isKernel32Exist ? "32" : "64";
            std::string errorMessage = "Conflict between DiagManager Runner ("+runnerBit+") and MCD-Kernel ("+kernelBit+").";
 
            PrintDebugTextToConsole(errorMessage);
        }
    }
    catch (...) {}
}
 
bool IsWow64()
{
    BOOL bIsWow64 = FALSE;
 
    typedef BOOL(WINAPI* LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
    LPFN_ISWOW64PROCESS fnIsWow64Process;
    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle(TEXT("kernel32")), "IsWow64Process");
 
    if (NULL != fnIsWow64Process)
    {
        if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64))
        {
            return "";
        }
    }
 
    return bIsWow64 == TRUE ? true : false;
}
 
bool Is32BitRunner()
{
    SYSTEM_INFO systemInfo = { 0 };
    GetNativeSystemInfo(&systemInfo);
 
    // x86 environment
    if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
        return true;
 
    // Check if the process is an x86 process that is running on x64 environment.
    // IsWow64 returns true if the process is an x86 process
    return IsWow64();
}
 
bool Is32BitKernelExist(std::string kernelPath)
{
    return (fs::exists(std::string(kernelPath) + "/McdKernel_vc120.dll")
        || fs::exists(std::string(kernelPath) + "/McdKernel_vc142.dll"));
}
 
bool Is64BitKernelExist(std::string kernelPath)
{
    return (fs::exists(std::string(kernelPath) + "/McdKernel_vc120_64.dll")
        || fs::exists(std::string(kernelPath) + "/McdKernel_vc142_64.dll"));
}
 
#endif // WIN32
 
std::string GetAppDataPath()
{
    char homedir[MAX_PATH];
 
#ifdef _WIN32
    snprintf(homedir, MAX_PATH, "%s", getenv("APPDATA"));
 
#elif __ANDROID__
    snprintf(homedir, MAX_PATH, "%s", getenv("TMPDIR"));
 
#else
    if (getenv("TEMP") != NULL)
    {
        snprintf(homedir, MAX_PATH, "%s", getenv("TEMP"));
    }
    else
    {
        if (getenv("TMP") != NULL)
        {
            snprintf(homedir, MAX_PATH, "%s", getenv("TMP"));
        }
        else
        {
            if (getenv("TMPDIR") != NULL)
            {
                snprintf(homedir, MAX_PATH, "%s", getenv("TMPDIR"));
            }
            else
            {
                snprintf(homedir, MAX_PATH, "%s", "/tmp");
            }
        }
    }
 
#endif
    std::string appdata;
    char* c = strdup(homedir);
    if (c)
    {
        appdata = c;
        std::free(c);
    }
    return appdata;
}
 
 
void SetDefaultArgumentsForRunner(std::map<std::string, std::string>& arguments)
{
    std::string defaultLogPath = fs::path(GetAppDataPath()).append("OpenTestSystem").append(CommonHelper::Get().GetSortVersion()).append("DiagManager").append("Logging").string();
    arguments[PortKey] = "8888";
    arguments[PipeKey] = "???";
    arguments[KernelPathKey] = "";
    arguments[ConfigPathKey] = "";
    arguments[JavaVmPathKey] = "";
    arguments[LogPathKey] = defaultLogPath;
    arguments[LogLevelKey] = "3";
    arguments[LogConfigKey] = "";
    arguments[KernelTypeKey] = KernelTypes::VwMcd;
    arguments[MaxNumberOfConcurrentComChannelsKey] = "28";
    arguments[DiagServiceHandleMappingKey] = "1";
    arguments[PduApiKey] = "";
    arguments[LicenseKey] = "";
}
 
 
bool UpdateArgumentsByCommandLine(int argc, char** argv, std::map<std::string, std::string>& arguments)
{
    for (int i = 1; i < argc; i++)
    {
        std::string argument = argv[i];
        std::string key;
        const size_t idx = argument.find('=');
 
        if (std::string::npos != idx)
        {
            key = argument.substr(0, idx);
            auto iter = arguments.find(key);
 
            if (iter == arguments.end())
            {
                PrintUsage();
 
                return false;
            }
 
            if (strcmp(key.c_str(), PortKey.c_str()) == 0)
            {
                arguments[PipeKey] = "";
            }
            else if (strcmp(key.c_str(), PipeKey.c_str()) == 0)
            {
                arguments[PortKey] = "";
            }
 
            std::string value = argument.substr(idx + 1, argument.length() - idx);
            arguments[key] = value;
        }
        else if (strcmp(argument.c_str(), DebugKey.c_str()) == 0)
        {
            isDebug = true;
        }
    }
 
    return true;
}
 
bool SetupLogger(std::string& logPath, int logLevel, std::string& logConfig)
{
    return SetupLogger(logPath, logLevel, logConfig, "", "");
}
 
bool SetupLogger(std::string &logPath, int logLevel, std::string &logConfig, std::string portNumber, std::string pipeName)
{
    char seperated;
 
#ifdef _WIN32
    seperated = '\\';
 
#elif __linux__
    seperated = '/';
 
#endif
    if (!logPath.empty())
    {
        try
        {
            fs::create_directories(logPath);
 
            if (logPath[logPath.length() - 1] != seperated)
            {
                logPath.push_back(seperated);
            }
 
            const std::string fileName = "DiagManagerRunner.log";
            DefaultLogger * log = new DefaultLogger(logPath, fileName);
            log->SetDiagManagerInfo(portNumber, pipeName);
            DefaultLogger::Set(log);
            CrashHandler::InstallCrashHandler(logPath, fileName);
 
        }
        catch (...)
        {
            std::cout << std::endl;
            PrintDebugTextToConsole("Error: The path \"" + logPath + "\" not found!");
            return false;
        }
    }
 
    if (logLevel > -1 && logLevel < 7 && logLevel != 3)
    {
        LogConfigBase * logConfig = new LogConfigBase();
        logConfig->SetDefaultLevel((ILog::Level)logLevel);
        LogConfigSingleton::Set(std::shared_ptr<ILogConfig>(logConfig));
    }
 
    if (!logConfig.empty())
    {
    }
 
    return true;
}
 
bool SetupCommandProcessor(CommandProcessor* commandProcessor, std::map<std::string, std::string>& arguments)
{
    try
    {
        int MaxNumberOfConcurrentComChannels = atoi(arguments[MaxNumberOfConcurrentComChannelsKey].c_str());
        int DiagServiceHandleMapping = atoi(arguments[DiagServiceHandleMappingKey].c_str());
 
        // CommandProcessor sets the CommandDispatcher
        auto commandDispatcher = std::make_unique<CommandDispatcher>();
        auto* comChannelManager = commandDispatcher->GetComChannelManager();
        comChannelManager->SetMaxChannels(MaxNumberOfConcurrentComChannels);
        commandProcessor->SetCommandDispatcher(std::move(commandDispatcher));
        PrintDebugTextToConsole("MaxNumberOfConcurrentComChannels: " + std::to_string(MaxNumberOfConcurrentComChannels));
 
        // CommandProcessor sets the DiagServiceHandleMapping
        if (DiagServiceHandleMapping == 1)
        {
            commandProcessor->StartDiagServiceHandleMapping();
        }
        PrintDebugTextToConsole("DiagServiceHandleMapping: " + std::string(DiagServiceHandleMapping ? "on" : "off"));
    }
    catch (std::exception& e)
    {
        PrintDebugTextToConsole(e.what());
        return false;
    }
    return true;
}
 
int SetVariableEnvironment(const std::string& env)
{
    char* envString = new char[env.length() + 1];
    strncpy(envString, env.c_str(), env.length());
    envString[env.length()] = '\0'; // the '\0' at the end of the string when it initializes the array
 
    size_t pos = env.find('=');
    std::string envName = env.substr(0, pos);
    std::string envPath = env.substr(pos + 1, env.length());
 
    std::string textConsole = "Setting the environment variable \"" +
        envName +
        "\" with the path \"" +
        envPath + "\"";
 
    PrintDebugTextToConsole(textConsole);
    int ret = putenv(envString);
 
    textConsole = "The environment variable \"" +
        envName +
        "\" path is set to \"" +
        envPath + "\"";
    PrintDebugTextToConsole(textConsole);
    
    delete[] envString;
    
    return ret;
}
 
bool SetPathForVariableEnvironment(std::string kernelPath, std::string configPath, std::string javavmPath)
{
    std::string seperated = "";
 
#ifdef _WIN32
    seperated = ";";
 
#elif __linux__
    seperated = ":";
 
#endif
    if (!kernelPath.empty())
    {
        if (!fs::exists(kernelPath))
        {
            PrintDebugTextToConsole("Error: The path \"" + kernelPath + "\" not found!");
            return false;
        }
 
        //std::string pathEnvs = RemoveOldMcdHomeFromPathEnv();
        PrintDebugTextToConsole("Find PATH environment");
        std::string pathEnvs = getenv("PATH");
        std::string home;
        PrintDebugTextToConsole("Set kernelPath to environment system");
 
        if (fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142.dll")
            || fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142_64.dll")) 
        {
            home = "PRODIS_MCD_HOME=" + kernelPath;
        }
        else if (fs::exists(std::string(kernelPath) + "/dkernel-core-vw.dll"))
        {
            home = "SIEMENS_MCD_HOME=" + kernelPath;
        }
        else {
            home = "VW_MCD_HOME=" + kernelPath;
        }
        SetVariableEnvironment(home);
 
        std::string newPath(kernelPath);
        newPath.append(seperated);
        newPath.append(pathEnvs);
        std::string path = "PATH=" + newPath;
        SetVariableEnvironment(path);
    }
 
    if (!configPath.empty())
    {
        if (!fs::exists(configPath))
        {
            PrintDebugTextToConsole("Error: The path \"" + configPath + "\" not found!");
            return false;
        }
 
        PrintDebugTextToConsole("Set configPath to environment system");
        std::string config ;
        if (fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142.dll")
            || fs::exists(std::string(kernelPath) + "/ProdisMcdKernel_vc142_64.dll")) 
        {
            config = "PRODIS_MCD_CONFIG=" + configPath;
        }
        else if (fs::exists(std::string(kernelPath) + "/dkernel-core-vw.dll"))
        {
            config = "SIEMENS_MCD_CONFIG=" + configPath;
        }
        else {
            config = "VW_MCD_CONFIG=" + configPath;
        }
        SetVariableEnvironment(config);
    }
 
    if (!javavmPath.empty())
    {
        if (!fs::exists(javavmPath))
        {
            PrintDebugTextToConsole("Error: The path \"" + javavmPath + "\" not found!");
 
            return false;
        }
 
        std::string pathEnvs = getenv("PATH");
 
        std::string newPath(javavmPath);
        newPath.append(seperated);
        newPath.append(pathEnvs);
        std::string path = "PATH=" + newPath;
        SetVariableEnvironment(path.c_str());
    }
 
    return true;
}
 
// Gap/Lack #12995
std::string RemoveOldMcdHomeFromPathEnv()
{
    std::string oldMcdHomePath = getenv("VW_MCD_HOME");
    std::string pathEnvs = getenv("PATH");
    std::size_t pos = pathEnvs.find(oldMcdHomePath);
    if (pos != std::string::npos)
    {
        pathEnvs.erase(pos, oldMcdHomePath.length());
    }
 
    return pathEnvs;
}
 
void PrintAvaiablePduApi(IDiagRuntimeSystem* drs)
{
    if (!isDebug) return;
 
    std::cout << "Possible PDU-API name are: [" << std::endl;
    Command cmd;
    cmd.SetCommandType(CommandTypesPb::GetPduApiNameList);
 
    std::shared_ptr<Parameter> pHandle = std::make_shared<Parameter>();
    cmd.AddParameter(1, pHandle);
 
    Result* result = drs->Execute(cmd);
 
    int resuldCode = result->GetResultCode();
    if (resuldCode == ResultCodesPb::Success)
    {
        auto pduNameList =result->GetParameter(1)->GetValueAsList();
        for (Parameter pduNameParam : pduNameList) {
            std::cout << "   " << pduNameParam.GetValueAsString() << std::endl;
        }
    }
    std::cout << "]" << std::endl;
    delete result;
}
 
void SwitchPduApi(IDiagRuntimeSystem* drs, const std::string& shortName)
{
    PrintDebugTextToConsole("Switch to '" + shortName + "' PDU-API");
    std::shared_ptr<SwitchPduApiPb> pb = std::make_shared<SwitchPduApiPb>();
    pb->set_pduapishortname(shortName);
 
    Command cmd;
    cmd.SetCommandType(CommandTypesPb::SwitchPduApi);
 
    std::string bytes;
    pb->SerializeToString(&bytes);
 
    std::shared_ptr<Parameter> pHandle = std::make_shared<Parameter>();
    pHandle->SetBytesValue(bytes);
    cmd.AddParameter(1, pHandle);
 
    Result* result = drs->Execute(cmd);
 
    int resuldCode = result->GetResultCode();
    if (resuldCode == ResultCodesPb::Failed)
    {
        int errorcode;
        ExceptionTypesPb type;
        std::string message;
        result->GetExceptionData(errorcode, type, message);
 
        delete result;
        PrintAvaiablePduApi(drs);
        throw std::runtime_error(message.c_str());
    }
    delete result;
}
 
#ifdef __linux__
std::vector<pid_t> getAllProcIdByName(std::string procName)
{
    std::vector<pid_t> listProcesses;
    // Open the /proc directory
    DIR *dp = opendir("/proc");
 
    if (dp != NULL)
    {
        // Enumerate all entries in directory until process found
        //struct dirent *dirp;
 
        while (struct dirent* dirp = readdir(dp))
        {
            // Skip non-numeric entries
            int id = atoi(dirp->d_name);
 
            if (id > 0)
            {
                // Read contents of virtual /proc/{pid}/cmdline file
                std::string cmdPath = std::string("/proc/") + dirp->d_name + "/cmdline";
                std::ifstream cmdFile(cmdPath.c_str());
                std::string cmdLine;
                std::getline(cmdFile, cmdLine);
 
                if (!cmdLine.empty())
                {
                    // Keep first cmdline item which contains the program path
                    size_t pos = cmdLine.find('\0');
 
                    if (pos != std::string::npos)
                    {
                        cmdLine = cmdLine.substr(0, pos);
                    }
 
                    // Keep program name only, removing the path
                    pos = cmdLine.rfind('/');
 
                    if (pos != std::string::npos)
                    {
                        cmdLine = cmdLine.substr(pos + 1);
                    }
 
                    // Compare against requested process name
                    if (procName == cmdLine)
                    {
                        listProcesses.push_back(id);
                    }
                }
            }
        }
    }
 
    closedir(dp);
 
    return listProcesses;
}
#endif
 
bool KillAllProccesses()
{
    bool result = false;
 
#ifdef _WIN32
    DWORD processCurrent = GetCurrentProcessId();
    HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 pe32;
 
    pe32.dwSize = sizeof(PROCESSENTRY32);
 
    if (!Process32First(snap, &pe32))
    {
        CloseHandle(snap);
 
        return false;
    }
 
    do
    {
        if (processCurrent != pe32.th32ProcessID && strcmp(pe32.szExeFile, fileNameCurrent.c_str()) == 0)
        {
            HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe32.th32ProcessID);
 
            if (hProcess == NULL)
            {
                continue;
            }
 
            result = TerminateProcess(hProcess, 1);
 
            CloseHandle(hProcess);
        }
    } while (Process32Next(snap, &pe32));
 
    CloseHandle(snap);
 
#elif __linux__
    pid_t processCurrent = ::getpid();
    std::vector<pid_t> processesFound = getAllProcIdByName(fileNameCurrent);
 
    if (processesFound.size() > 1)
    {
        for (auto process = processesFound.begin(); process != processesFound.end(); ++process)
        {
            if (*process != processCurrent && *process)
            {
                kill(*process, SIGTERM);
            }
        }
    }
 
    try
    {
        std::string directory = std::string(LINUX_PIPE_PREFIX);
        if (fs::exists(directory))
        {
            fs::remove_all(directory);
        }
    }
    catch (std::exception& e)
    {
    }
#endif
 
    return result;
}
 
 
#ifdef _WIN32
std::string GetLastErrorAsString()
{
    //Get the error message ID, if any.
    DWORD errorMessageID = ::GetLastError();
    if (errorMessageID == 0) {
        return std::string(); //No error message has been recorded
    }
 
    LPSTR messageBuffer = nullptr;
 
    //Ask Win32 to give us the string version of that message ID.
    //The parameters we pass in, tell Win32 to create the buffer that holds the message for us (because we don't yet know how long the message string will be).
    size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
 
    //Copy the error message into a std::string.
    std::string message(messageBuffer, size);
 
    //Free the Win32's string's buffer.
    LocalFree(messageBuffer);
 
    return message;
}
#endif
void PrintUsage()
{
    std::cout << "" << std::endl;
    std::cout << "Creates and starts a new process with the OTX DiagManager server." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "The OTX DiagManager (short DiagManager) is a software component between" << std::endl;
    std::cout << "diagnostic applications and various, interchangeable diagnostic runtime" << std::endl;
    std::cout << "systems. The DiagManager is part of the OTX-Runtime API, but it can also" << std::endl;
    std::cout << "be used stand-alone." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "OpenTestSystem.Otx.DiagManager.Runner [-options]" << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -help" << std::endl;
    std::cout << "   -?" << std::endl;
    std::cout << "        Print this help message. This option must be used" << std::endl;
    std::cout << "        exclusive without any other option, otherwise it will" << std::endl;
    std::cout << "        be ignored." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -debug" << std::endl;
    std::cout << "        If set, debug messages will be written into the" << std::endl;
    std::cout << "        standard i/o." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -port=<PortNumber> [0..1]" << std::endl;
    std::cout << "        Sets the port number for interprocess communication" << std::endl;
    std::cout << "        via sockets. The default value is 8888. If the port" << std::endl;
    std::cout << "        is set explicit, the pipe will be ignored." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -pipe=<PipeName> [0..1]" << std::endl;
    std::cout << "        Sets the pipe name for interprocess communication via" << std::endl;
    std::cout << "        pipes. The default value is \"???\"." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -MaxNumberOfConcurrentComChannels=<MaxNumberOfConcurrentComChannels> [0..1]" << std::endl;
    std::cout << "        Sets max number of concurrent ComChannels for the CommandProcessor." << std::endl;
    std::cout << "        Sets maximum number of concurrent ComChannels for the CommandProcessor," << std::endl;
    std::cout << "        which can be open at the same time. If the number is exceeded," << std::endl;
    std::cout << "        ComChannels that are no longer used are automatically closed. The" << std::endl;
    std::cout << "        default value is \"28\"." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -DiagServiceHandleMapping=<DiagServiceHandleMapping> [0..1]" << std::endl;
    std::cout << "        Switches the DiagService handle translation of the CommandProcessor" << std::endl;
    std::cout << "        ON or OFF. Possible value are:" << std::endl;
    std::cout << "        [" << std::endl;
    std::cout << "          OFF = 0," << std::endl;
    std::cout << "          ON = 1" << std::endl;
    std::cout << "        ]" << std::endl;
    std::cout << "        The default value is ON. DiagService handle mapping is needed" << std::endl;
    std::cout << "        to restore DiagService objects of closed and re-opend ComChannels" << std::endl;
    std::cout << "        when the ComChannels limit is exceeded. The mapping takes time and" << std::endl;
    std::cout << "        can be switched off, if it is not needed." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -kernelType=<KernelTypeEnum> [0..1]" << std::endl;
    std::cout << "        Sets the type of the diagnostic runtime system. Possible" << std::endl;
    std::cout << "        types are:" << std::endl;
    std::cout << "        [" << std::endl;
    std::cout << "            VwMcd = 0," << std::endl;
    std::cout << "            VwMcdSP = 1," << std::endl;
    std::cout << "            ProdisMCD = 2" << std::endl;
    std::cout << "        ]" << std::endl;
    std::cout << "        The default value is 0 (VwMcd). If the option is not set" << std::endl;
    std::cout << "        to a valid value, the default value will be used." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -kernelPath=<KernelPath> [1]" << std::endl;
    std::cout << "        Sets the path to the binary of the diagnostic runtime" << std::endl;
    std::cout << "        system. If the option is not set to a valid value, the" << std::endl;
    std::cout << "        DiagManager returns an error." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -configPath=<ConfigPath> [1]" << std::endl;
    std::cout << "        Sets the path to the configuration folder of the" << std::endl;
    std::cout << "        diagnostic runtime system. If the option is not set to" << std::endl;
    std::cout << "        a valid value, the DiagManager returns an error." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -pduApi=<D_PDU_VCI_NAME> [0..1]" << std::endl;
    std::cout << "        Sets the PDU-API of the diagnostic runtime system." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -javaVmPath=<JavaVmPath> [0..1]" << std::endl;
    std::cout << "        Sets the path to the Java VM which should be used for" << std::endl;
    std::cout << "        Java Jobs by the diagnostic runtime system. If the" << std::endl;
    std::cout << "        value is not set, the Java VM will be searched inside" << std::endl;
    std::cout << "        the system PATH." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -logPath=<LogPath> [0..1]" << std::endl;
    std::cout << "        Sets the log path. The default log path is \"[User]/" << std::endl;
    std::cout << "        AppData/Roaming/OpenTestSystem/[Version]/DiagManager/Logging/\"." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -logLevel=<LogLevel> [0..1]" << std::endl;
    std::cout << "        Sets the log level (Off = 0, Error = 1, Critical = 2," << std::endl;
    std::cout << "        Warning = 3, Info = 4, Debug = 5, Trace = 6). The" << std::endl;
    std::cout << "        default log level is 3." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -licenseKey=<LicenseKey> [1]" << std::endl;
    std::cout << "        Sets the license key to activate DiagManager" << std::endl;
    std::cout << "        If the option is not set to a valid value, the" << std::endl;
    std::cout << "        DiagManager cannot be activated." << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   -killAll [0..1]" << std::endl;
    std::cout << "        All started processes at any port or pipe name will" << std::endl;
    std::cout << "        be killed. This option must be used exclusively without" << std::endl;
    std::cout << "        any other option, otherwise it will be ignored. This" << std::endl;
    std::cout << "        option should only be used to get a clean environment." << std::endl;
    std::cout << "        Please note, that this is not a regular exit!" << std::endl;
    std::cout << "" << std::endl;
    std::cout << "Return values:" << std::endl;
    std::cout << "" << std::endl;
    std::cout << "   0    If the server was started successfully or all started" << std::endl;
    std::cout << "        processes was killed or the help was displayed." << std::endl;
    std::cout << "   1    An error occurred. The error message is written into" << std::endl;
    std::cout << "        the output. Possible errors:" << std::endl;
    std::cout << "        - The given port number or the pipe name is wrong or already" << std::endl;
    std::cout << "          in use." << std::endl;
    std::cout << "        - The Kernel path is wrong, does not exist or does not contain" << std::endl;
    std::cout << "          a valid diagnostic runtime system." << std::endl;
    std::cout << "        - The Configuration path is wrong, does not exist or does not" << std::endl;
    std::cout << "          contain a valid configuration file. The configuration" << std::endl;
    std::cout << "          file format depends on the selected diagnostic runtime" << std::endl;
    std::cout << "          system." << std::endl;
    std::cout << "        - The Log path is wrong or cannot be accessed." << std::endl;
    std::cout << "        - The Log level is wrong." << std::endl;
    std::cout << "        - No process to kill exists, see -stopAll option." << std::endl;
    std::cout << "        - The server cannot be started because of any other reason." << std::endl;
    std::cout << "" << std::endl;
}
 
void PrintDebugTextToConsole(std::string message)
{
    if (isDebug)
    {
        std::cout << message << std::endl;
    }
}