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 DBusAddressTranslator::readConfiguration() { #define MAX_PATH_LEN 255 std::string config; 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_DBUS_DEFAULT_CONFIG_FILE; struct stat s; if (stat(config.c_str(), &s) != 0) { config = defaultConfig_; } } IniFileReader reader; if (!reader.load(config)) return false; for (auto itsMapping : reader.getSections()) { if(itsMapping.first == "segments") { std::map<std::string, std::string> mappings = itsMapping.second->getMappings(); ConnectionId_t connectionId; std::string busType; for(auto const &it : mappings) { connectionId = it.first; busType = it.second; if(busType == "SESSION") { dbusTypes_.insert({ connectionId, DBusType_t::SESSION }); } else if (busType == "SYSTEM") { dbusTypes_.insert({ connectionId, DBusType_t::SYSTEM }); } else { COMMONAPI_FATAL("Invalid bus type specified in .ini file, " "choose one of {SYSTEM, SESSION}"); continue; } COMMONAPI_INFO("D-Bus bus type for connection: " + connectionId + " is set to: " + busType + " via ini file"); } continue; } CommonAPI::Address itsAddress(itsMapping.first); std::string service = itsMapping.second->getValue("service"); std::string path = itsMapping.second->getValue("path"); std::string interfaceName = itsMapping.second->getValue("interface"); insert(itsMapping.first, service, path, interfaceName); } return true; } bool DBusAddressTranslator::isValid( const std::string &_name, const char _separator, bool _ignoreFirst, bool _isAllowedToStartWithDigit, bool _isBusName) const { (void)_isAllowedToStartWithDigit; // DBus addresses must contain at least one separator std::size_t separatorPos = _name.find(_separator); if (separatorPos == std::string::npos) { COMMONAPI_ERROR( "Invalid name \'", _name, "\'. Contains no \'", _separator, "\'"); return false; } bool isInitial(true); std::size_t start(0); if (_ignoreFirst) { start = 1; if (separatorPos == 0) { // accept "root-only" i.e. '/' object path if (1 == _name.length()) { return true; } separatorPos = _name.find(_separator, separatorPos+1); } } while (start != std::string::npos) { // DBus names parts must not be empty std::string part; if (isInitial) { isInitial = false; } else { start++; } if (separatorPos == std::string::npos) { part = _name.substr(start); } else { part = _name.substr(start, separatorPos-start); } if ("" == part) { COMMONAPI_ERROR( "Invalid interface name \'", _name, "\'. Must not contain empty parts."); return false; } // DBus name parts consist of the ASCII characters [0-9][A-Z][a-z]_, for (auto c : part) { // bus names may additionally contain [-] if (_isBusName && c == '-') continue; if (c < '0' || (c > '9' && c < 'A') || (c > 'Z' && c < '_') || (c > '_' && c < 'a') || c > 'z') { COMMONAPI_ERROR( "Invalid interface name \'", _name, "\'. Contains illegal character \'", c, "\'. Only \'[0-9][A-Z][a-z]_\' are allowed."); return false; } } start = separatorPos; separatorPos = _name.find(_separator, separatorPos+1); } // DBus names must not exceed the maximum length if (_name.length() > DBUS_MAXIMUM_NAME_LENGTH) { COMMONAPI_ERROR( "Invalid interface name \'", _name, "\'. Size exceeds maximum size."); return false; } return true; }