void
AddressTranslator::readServiceAlias(const std::string &_source, const std::string &_target) {
Address itsSourceAddress, itsTargetAddress;
method_id_t itsDummy;
if (readValue(_source, itsSourceAddress, itsDummy, false) &&
readValue(_target, itsTargetAddress, itsDummy, false)) {
auto findService = aliases_.find(itsSourceAddress);
if (findService == aliases_.end()) {
Alias_t itsTarget = std::make_tuple(itsTargetAddress, MethodAlias_t(), EventgroupAlias_t());
aliases_.insert(std::make_pair(itsSourceAddress, itsTarget));
} else {
if (itsTargetAddress != std::get<0>(findService->second)) {
COMMONAPI_ERROR("Found multiple aliases for address ", itsSourceAddress);
}
}
}
}
bool
AddressTranslator::translate(const Address &_key, CommonAPI::Address &_value) {
bool result(true);
#ifdef _WIN32
EnterCriticalSection(&critSec);
#else
std::lock_guard<std::mutex> itsLock(mutex_);
#endif
const auto it = backwards_.find(_key);
if (it != backwards_.end()) {
_value = it->second;
} else {
COMMONAPI_ERROR(
"Cannot determine CommonAPI address data for "
"SOME/IP address \"", _key, "\"");
result = false;
}
#ifdef _WIN32
LeaveCriticalSection(&critSec);
#endif
return result;
}
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;
}
