std::string Protocol_Version::to_string() const
{
const uint8_t maj = major_version();
const uint8_t min = minor_version();
if(maj == 3 && min == 0)
return "SSL v3";
if(maj == 3 && min >= 1) // TLS v1.x
return "TLS v1." + std::to_string(min-1);
if(maj == 254) // DTLS 1.x
return "DTLS v1." + std::to_string(255 - min);
// Some very new or very old protocol (or bogus data)
return "Unknown " + std::to_string(maj) + "." + std::to_string(min);
}
std::string IEServer::GetStatus() {
SYSTEM_INFO system_info;
::ZeroMemory(&system_info, sizeof(SYSTEM_INFO));
::GetNativeSystemInfo(&system_info);
OSVERSIONINFO os_version_info;
::ZeroMemory(&os_version_info, sizeof(OSVERSIONINFO));
os_version_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
::GetVersionEx(&os_version_info);
// Allocate only 2 characters for the major and minor versions
// and 5 characters for the build number (+1 for null char)
vector<char> major_buffer(3);
_itoa_s(os_version_info.dwMajorVersion, &major_buffer[0], 3, 10);
vector<char> minor_buffer(3);
_itoa_s(os_version_info.dwMinorVersion, &minor_buffer[0], 3, 10);
vector<char> build_buffer(6);
_itoa_s(os_version_info.dwBuildNumber, &build_buffer[0], 6, 10);
std::string major_version(&major_buffer[0]);
std::string minor_version(&minor_buffer[0]);
std::string build_version(&build_buffer[0]);
std::string os_version = major_version + "." + minor_version + "." + build_version;
std::string arch = "x86";
if (system_info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
arch = "x64";
}
Json::Value build;
build["version"] = "2.21.0";
Json::Value os;
os["arch"] = arch;
os["name"] = "windows";
os["version"] = os_version;
Json::Value status;
status["build"] = build;
status["os"] = os;
Response response;
response.SetSuccessResponse(status);
return response.Serialize();
}
bool
AddressTranslator::readConfiguration() {
#define MAX_PATH_LEN 255
std::string config;
bool tryLoadConfig(true);
char currentDirectory[MAX_PATH_LEN];
#ifdef _WIN32
if (GetCurrentDirectory(MAX_PATH_LEN, currentDirectory)) {
#else
if (getcwd(currentDirectory, MAX_PATH_LEN)) {
#endif
config = currentDirectory;
config += "/";
config += COMMONAPI_SOMEIP_DEFAULT_CONFIG_FILE;
struct stat s;
if (stat(config.c_str(), &s) != 0) {
config = defaultConfig_;
if (stat(config.c_str(), &s) != 0) {
tryLoadConfig = false;
}
}
}
IniFileReader reader;
if (tryLoadConfig && !reader.load(config))
return false;
for (auto itsSection : reader.getSections()) {
if (itsSection.first == "aliases") {
for (auto itsMapping : itsSection.second->getMappings()) {
if (itsMapping.first.find("service:") == 0) {
readServiceAlias(itsMapping.first.substr(8), itsMapping.second);
} else if (itsMapping.first.find("method:") == 0) {
readMethodAlias(itsMapping.first.substr(7), itsMapping.second);
} else if (itsMapping.first.find("event:") == 0) {
readMethodAlias(itsMapping.first.substr(6), itsMapping.second);
} else if (itsMapping.first.find("eventgroup:") == 0) {
readEventgroupAlias(itsMapping.first.substr(11), itsMapping.second);
} else {
COMMONAPI_ERROR("Found invalid alias configuration entry: ", itsMapping.first);
}
}
} else {
service_id_t service;
std::string serviceEntry = itsSection.second->getValue("service");
std::stringstream converter;
if (0 == serviceEntry.find("0x")) {
converter << std::hex << serviceEntry.substr(2);
} else {
converter << std::dec << serviceEntry;
}
converter >> service;
instance_id_t instance;
std::string instanceEntry = itsSection.second->getValue("instance");
converter.str("");
converter.clear();
if (0 == instanceEntry.find("0x")) {
converter << std::hex << instanceEntry.substr(2);
} else {
converter << std::dec << instanceEntry;
}
converter >> instance;
major_version_t major_version(0);
std::uint32_t major_temp(0);
minor_version_t minor_version(0);
std::string majorEntry = itsSection.second->getValue("major");
converter.str("");
converter.clear();
converter << std::dec << majorEntry;
converter >> major_temp;
major_version = static_cast<std::uint8_t>(major_temp);
std::string minorEntry = itsSection.second->getValue("minor");
converter.str("");
converter.clear();
converter << std::dec << minorEntry;
converter >> minor_version;
insert(itsSection.first, service, instance, major_version, minor_version);
}
}
return true;
}
bool
AddressTranslator::isValidService(const service_id_t _service) const {
if (_service < MIN_SERVICE_ID || _service > MAX_SERVICE_ID) {
COMMONAPI_ERROR(
"Found invalid service identifier (", _service, ")");
return false;
}
return true;
}
bool
AddressTranslator::isValidInstance(const instance_id_t _instance) const {
if (_instance < MIN_INSTANCE_ID || _instance > MAX_INSTANCE_ID) {
COMMONAPI_ERROR(
"Found invalid instance identifier (", _instance, ")");
return false;
}
return true;
}
bool
AddressTranslator::isValidMethod(const method_id_t _method) const {
if (_method < MIN_METHOD_ID || _method > MAX_METHOD_ID) {
COMMONAPI_ERROR(
"Found invalid method identifier (", _method, ")");
return false;
}
return true;
}
bool
AddressTranslator::isValidEventgroup(const eventgroup_id_t _eventgroup) const {
if (_eventgroup < MIN_EVENTGROUP_ID || _eventgroup > MAX_EVENTGROUP_ID) {
COMMONAPI_ERROR(
"Found invalid eventgroup identifier (", _eventgroup, ")");
return false;
}
return true;
}
const Address &
AddressTranslator::getAddressAlias(const Address &_address) const {
auto foundAddress = aliases_.find(_address);
if (foundAddress != aliases_.end())
return std::get<0>(foundAddress->second);
return _address;
}
bool Protocol_Version::is_datagram_protocol() const
{
return major_version() == 254;
}
