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; }