File indexing completed on 2025-03-23 12:49:50

 /*
     SPDX-FileCopyrightText: 2018 Aleksander Morgado <aleksander@aleksander.es>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "ipconfig.h"
 
 #include <arpa/inet.h>
 
 #include "dnsconfiguration.h"
 
 #include <QVariant>
 
 namespace NetworkManager
 {
 class NetworkManager::DnsConfiguration::Private
 {
 public:
     Private(const QStringList &theSearches, const QStringList &theOptions, const QList<DnsDomain> theDomains)
         : searches(theSearches)
         , options(theOptions)
         , domains(theDomains)
     {
     }
     Private()
     {
     }
     QStringList searches;
     QStringList options;
     QList<DnsDomain> domains;
 };
 
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration(const QStringList &searches, const QStringList &options, const QList<DnsDomain> domains)
     : d(new Private(searches, options, domains))
 {
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration()
     : d(new Private())
 {
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration(const DnsConfiguration &other)
     : d(new Private)
 {
     *this = other;
 }
 
 NetworkManager::DnsConfiguration::~DnsConfiguration()
 {
     delete d;
 }
 
 QStringList NetworkManager::DnsConfiguration::searches() const
 {
     return d->searches;
 }
 
 void NetworkManager::DnsConfiguration::setSearches(const QStringList &searches)
 {
     d->searches = searches;
 }
 
 QStringList NetworkManager::DnsConfiguration::options() const
 {
     return d->options;
 }
 
 void NetworkManager::DnsConfiguration::setOptions(const QStringList &options)
 {
     d->options = options;
 }
 
 QList<NetworkManager::DnsDomain> NetworkManager::DnsConfiguration::domains() const
 {
     return d->domains;
 }
 
 void NetworkManager::DnsConfiguration::setDomains(const QList<NetworkManager::DnsDomain> &domains)
 {
     d->domains = domains;
 }
 
 QVariantMap NetworkManager::DnsConfiguration::toMap() const
 {
     QVariantMap map;
 
     map["searches"] = d->searches;
     map["options"] = d->options;
 
     QVariantMap domains;
     for (const NetworkManager::DnsDomain &domain : std::as_const(d->domains)) {
         QVariantMap contents;
         QStringList serversList;
         const QList<QHostAddress> servers = domain.servers();
         for (const QHostAddress &address : servers) {
             serversList.append(address.toString());
         }
         contents["servers"] = serversList;
         contents["options"] = domain.options();
         domains[domain.name()] = contents;
     }
     map["domains"] = domains;
 
     return map;
 }
 
 void NetworkManager::DnsConfiguration::fromMap(const QVariantMap &map)
 {
     d->searches = map["searches"].toStringList();
     d->options = map["options"].toStringList();
     d->domains = QList<NetworkManager::DnsDomain>();
 
     QVariantMap domains = map["domains"].toMap();
     QVariantMap::const_iterator i = domains.constBegin();
     while (i != domains.constEnd()) {
         const QVariantMap contents = i.value().toMap();
         QList<QHostAddress> addressList;
         const QStringList serversList = contents["servers"].toStringList();
         for (const QString &server : serversList) {
             addressList.append(QHostAddress(server));
         }
         NetworkManager::DnsDomain domain(i.key(), addressList, contents["options"].toStringList());
         d->domains.append(domain);
         ++i;
     }
 }
 
 NetworkManager::DnsConfiguration &NetworkManager::DnsConfiguration::operator=(const DnsConfiguration &other)
 {
     if (this == &other) {
         return *this;
     }
 
     *d = *other.d;
     return *this;
 }