void NetworkingObjectBase::GenerateDnsServersMap()

in src/modules/networking/src/lib/Networking.cpp [659:742]
77 lines of code
15 McCabe index (conditional complexity)

void NetworkingObjectBase::GenerateDnsServersMap()
{
    this->m_dnsServersMap.clear();
    if (true != EnableAndStartDaemon(g_systemdResolvedServiceName, NetworkingLog::Get()))
    {
        OsConfigLogError(NetworkingLog::Get(), "Unable to start service %s. DnsServers data will be empty.", g_systemdResolvedServiceName);
        return;
    }

    std::string dnsServersData = RunCommand(g_getDnsServers);

    std::vector<std::string> globalDnsServers;
    GetGlobalDnsServers(dnsServersData, globalDnsServers);

    std::smatch interfaceNamePrefixMatch;
    while (std::regex_search(dnsServersData, interfaceNamePrefixMatch, g_interfaceNamePrefixPatternDnsServers))
    {
        std::string interfaceNamePrefix = interfaceNamePrefixMatch.str(0);
        std::string interfaceNameData = interfaceNamePrefixMatch.suffix().str();
        size_t interfaceNameSuffixFront = interfaceNameData.find(g_closeParenthesis);

        std::string interfaceName;
        if (interfaceNameSuffixFront != std::string::npos)
        {
            interfaceName = interfaceNameData.substr(0, interfaceNameSuffixFront);
        }

        dnsServersData = interfaceNameData;
        std::string interfaceData = std::regex_search(dnsServersData, interfaceNamePrefixMatch, g_interfaceNamePrefixPatternDnsServers) ? dnsServersData.substr(0, interfaceNamePrefixMatch.position(0)) : dnsServersData;

        if (IsKnownInterfaceName(interfaceName))
        {
            std::map<std::string, std::vector<std::string>>::iterator dnsServersMapIterator;
            std::string dnsServers;
            std::smatch dnsServersPrefixMatch;
            if (std::regex_search(interfaceData, dnsServersPrefixMatch, g_dnsServersPrefixPattern))
            {
                bool isValidData = true;
                std::stringstream dnsServerStream(dnsServersPrefixMatch.suffix().str());
                while(isValidData && std::getline(dnsServerStream, dnsServers))
                {
                    std::string dnsServer;
                    std::stringstream line(dnsServers);
                    while (std::getline(line, dnsServer, g_spaceCharacter))
                    {
                        dnsServer.erase(remove(dnsServer.begin(), dnsServer.end(), g_spaceCharacter), dnsServer.end());
                        if ((std::regex_match(dnsServer, g_ipv4Pattern)) || (std::regex_match(dnsServer, g_ipv6Pattern)))
                        {
                            dnsServersMapIterator = this->m_dnsServersMap.find(interfaceName);
                            if (dnsServersMapIterator != this->m_dnsServersMap.end())
                            {
                                (dnsServersMapIterator->second).push_back(dnsServer);
                            }
                            else
                            {
                                std::vector<std::string> dnsServers{ dnsServer };
                                this->m_dnsServersMap.insert(std::pair<std::string, std::vector<std::string>>(interfaceName, dnsServers));
                            }
                        }
                        else
                        {
                            isValidData = false;
                            break;
                        }
                    }
                }
            }

            if (!globalDnsServers.empty())
            {
                dnsServersMapIterator = this->m_dnsServersMap.find(interfaceName);
                if (dnsServersMapIterator != this->m_dnsServersMap.end())
                {
                    (dnsServersMapIterator->second).insert((dnsServersMapIterator->second).end(), globalDnsServers.begin(), globalDnsServers.end());
                    RemoveDuplicates(dnsServersMapIterator->second);
                }
                else
                {
                    this->m_dnsServersMap.insert(std::pair<std::string, std::vector<std::string>>(interfaceName, globalDnsServers));
                }
            }
        }
    }
}