diff --git a/autotests/settings/ipv4settingtest.cpp b/autotests/settings/ipv4settingtest.cpp index e38af40..c9434e0 100644 --- a/autotests/settings/ipv4settingtest.cpp +++ b/autotests/settings/ipv4settingtest.cpp @@ -1,143 +1,197 @@ /* Copyright 2012-2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "ipv4settingtest.h" #include "generictypes.h" #include "settings/ipv4setting.h" #include #include #include void IPv4SettingTest::testSetting_data() { QTest::addColumn("method"); QTest::addColumn("dns"); QTest::addColumn("dnsSearch"); QTest::addColumn("addresses"); QTest::addColumn("routes"); QTest::addColumn("routeMetric"); QTest::addColumn("ignoreAutoRoutes"); QTest::addColumn("ignoreAutoDns"); QTest::addColumn("dhcpClientId"); QTest::addColumn("dhcpSendHostname"); QTest::addColumn("dhcpHostname"); QTest::addColumn("neverDefault"); QTest::addColumn("mayFail"); + QTest::addColumn("dadTimeout"); + QTest::addColumn("dhcpFqdn"); + QTest::addColumn("dnsOptions"); + QTest::addColumn("dnsPriority"); + QTest::addColumn("gateway"); + QTest::addColumn("addressData"); + QTest::addColumn("routeData"); QList dns; dns << inet_addr("10.0.0.1"); dns << inet_addr("10.0.1.1"); QStringList dnsSearch; dnsSearch << "foo.com"; dnsSearch << "foo.bar"; QList > addresses; QList addr; addr << inet_addr("192.168.1.1"); addr << 25; addr << 0; addresses << addr; QList > routes; QList routeAddr; routeAddr << inet_addr("192.168.1.1"); routeAddr << 25; routeAddr << inet_addr("192.169.1.1"); routeAddr << 25; addresses << routeAddr; + QStringList dnsOptions; + dnsOptions << "opt1"; + dnsOptions << "opt2"; + + NMVariantMapList addressData; + QVariantMap addressMap; + addressMap["address"] = "192.168.1.1"; + addressMap["prefix"] = 25; + addressData.append(addressMap); + + NMVariantMapList routeData; + QVariantMap routeMap; + routeMap["dest"] = "192.168.1.1"; + routeMap["prefix"] = 25; + routeData.append(routeMap); + routeMap.clear(); + routeMap["dest"] = "192.168.1.2"; + routeMap["prefix"] = 25; + routeData.append(routeMap); + QTest::newRow("setting1") << QString("auto") // method << dns // dns << dnsSearch // dnsSearch << addresses // addresses << routes // routes << 100 // routeMetric << true // ignoreAutoRoutes << true // ignoreAutoDns << QString("home-test") // dhcpClientId << false // dhcpSendHostname << QString("home-test") // dhcpHostname << true // neverDefault - << false; // mayFail + << false // mayFail + << 100 // dadTimeout + << QString("foo.com") // dhcpFqdn + << dnsOptions // dnsOptions + << 100 // dnsPriority + << QString("1.1.1.1") // gateway + << addressData // addressData + << routeData; // routeData } void IPv4SettingTest::testSetting() { QFETCH(QString, method); QFETCH(UIntList, dns); QFETCH(QStringList, dnsSearch); QFETCH(UIntListList, addresses); QFETCH(UIntListList, routes); QFETCH(int, routeMetric); QFETCH(bool, ignoreAutoRoutes); QFETCH(bool, ignoreAutoDns); QFETCH(QString, dhcpClientId); QFETCH(bool, dhcpSendHostname); QFETCH(QString, dhcpHostname); QFETCH(bool, neverDefault); QFETCH(bool, mayFail); + QFETCH(qint32, dadTimeout); + QFETCH(QString, dhcpFqdn); + QFETCH(QStringList, dnsOptions); + QFETCH(qint32, dnsPriority); + QFETCH(QString, gateway); + QFETCH(NMVariantMapList, addressData); + QFETCH(NMVariantMapList, routeData); QVariantMap map; map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), method); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS), QVariant::fromValue(dns)); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_SEARCH), dnsSearch); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES), QVariant::fromValue(addresses)); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES), QVariant::fromValue(routes)); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC), routeMetric); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES), ignoreAutoRoutes); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS), ignoreAutoDns); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID), dhcpClientId); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME), dhcpSendHostname); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME), dhcpHostname); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT), neverDefault); map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_MAY_FAIL), mayFail); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT), dadTimeout); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_FQDN), dhcpFqdn); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS), dnsOptions); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY), dnsPriority); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_GATEWAY), gateway); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA), QVariant::fromValue(addressData)); + map.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA), QVariant::fromValue(routeData)); NetworkManager::Ipv4Setting setting; setting.fromMap(map); QVariantMap map1 = setting.toMap(); // Will fail if set some default values, because they are skipped in toMap() method QVariantMap::const_iterator it = map.constBegin(); while (it != map.constEnd()) { if (it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS) && it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES) && - it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)) { + it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES) && + it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA) && + it.key() != QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA)) { QCOMPARE(it.value(), map1.value(it.key())); } ++it; } QCOMPARE(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS)).value(), map1.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS)).value()); QCOMPARE(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES)).value(), map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES)).value()); QCOMPARE(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)).value(), map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)).value()); + QCOMPARE(qdbus_cast(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA))), + qdbus_cast(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA)))); + QCOMPARE(qdbus_cast(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA))), + qdbus_cast(map.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA)))); } QTEST_MAIN(IPv4SettingTest) diff --git a/src/settings/ipv4setting.cpp b/src/settings/ipv4setting.cpp index f33fb94..cb3d2bf 100644 --- a/src/settings/ipv4setting.cpp +++ b/src/settings/ipv4setting.cpp @@ -1,515 +1,696 @@ /* Copyright 2012-2013 Jan Grulich Copyright 2013 Daniel Nicoletti This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "ipv4setting.h" #include "ipv4setting_p.h" #include "generictypes.h" #include #include NetworkManager::Ipv4SettingPrivate::Ipv4SettingPrivate() : name(NMQT_SETTING_IP4_CONFIG_SETTING_NAME) , method(NetworkManager::Ipv4Setting::Automatic) , routeMetric(-1) , ignoreAutoRoutes(false) , ignoreAutoDns(false) , dhcpSendHostname(true) , neverDefault(false) , mayFail(true) + , dadTimeout(-1) + , dnsPriority(0) { } NetworkManager::Ipv4Setting::Ipv4Setting() : Setting(Setting::Ipv4) , d_ptr(new Ipv4SettingPrivate()) { } NetworkManager::Ipv4Setting::Ipv4Setting(const Ptr &other) : Setting(other) , d_ptr(new Ipv4SettingPrivate()) { setMethod(other->method()); setDns(other->dns()); setDnsSearch(other->dnsSearch()); setAddresses(other->addresses()); setRoutes(other->routes()); setRouteMetric(other->routeMetric()); setIgnoreAutoRoutes(other->ignoreAutoRoutes()); setIgnoreAutoDns(other->ignoreAutoDns()); setDhcpClientId(other->dhcpClientId()); setDhcpSendHostname(other->dhcpSendHostname()); setDhcpHostname(other->dhcpHostname()); setNeverDefault(other->neverDefault()); setMayFail(other->mayFail()); + setDadTimeout(other->dadTimeout()); + setDhcpFqdn(other->dhcpFqdn()); + setDnsOptions(other->dnsOptions()); + setDnsPriority(other->dnsPriority()); + setAddressData(other->addressData()); + setRouteData(other->routeData()); } NetworkManager::Ipv4Setting::~Ipv4Setting() { delete d_ptr; } QString NetworkManager::Ipv4Setting::name() const { Q_D(const Ipv4Setting); return d->name; } void NetworkManager::Ipv4Setting::setMethod(NetworkManager::Ipv4Setting::ConfigMethod type) { Q_D(Ipv4Setting); d->method = type; } NetworkManager::Ipv4Setting::ConfigMethod NetworkManager::Ipv4Setting::method() const { Q_D(const Ipv4Setting); return d->method; } void NetworkManager::Ipv4Setting::setDns(const QList &dns) { Q_D(Ipv4Setting); d->dns = dns; } QList NetworkManager::Ipv4Setting::dns() const { Q_D(const Ipv4Setting); return d->dns; } void NetworkManager::Ipv4Setting::setDnsSearch(const QStringList &domains) { Q_D(Ipv4Setting); d->dnsSearch = domains; } QStringList NetworkManager::Ipv4Setting::dnsSearch() const { Q_D(const Ipv4Setting); return d->dnsSearch; } void NetworkManager::Ipv4Setting::setAddresses(const QList &ipv4addresses) { Q_D(Ipv4Setting); d->addresses = ipv4addresses; } QList< NetworkManager::IpAddress > NetworkManager::Ipv4Setting::addresses() const { Q_D(const Ipv4Setting); return d->addresses; } void NetworkManager::Ipv4Setting::setRoutes(const QList &ipv4routes) { Q_D(Ipv4Setting); d->routes = ipv4routes; } QList< NetworkManager::IpRoute > NetworkManager::Ipv4Setting::routes() const { Q_D(const Ipv4Setting); return d->routes; } void NetworkManager::Ipv4Setting::setRouteMetric(int metric) { Q_D(Ipv4Setting); d->routeMetric = metric; } int NetworkManager::Ipv4Setting::routeMetric() const { Q_D(const Ipv4Setting); return d->routeMetric; } void NetworkManager::Ipv4Setting::setIgnoreAutoRoutes(bool ignore) { Q_D(Ipv4Setting); d->ignoreAutoRoutes = ignore; } bool NetworkManager::Ipv4Setting::ignoreAutoRoutes() const { Q_D(const Ipv4Setting); return d->ignoreAutoRoutes; } void NetworkManager::Ipv4Setting::setIgnoreAutoDns(bool ignore) { Q_D(Ipv4Setting); d->ignoreAutoDns = ignore; } bool NetworkManager::Ipv4Setting::ignoreAutoDns() const { Q_D(const Ipv4Setting); return d->ignoreAutoDns; } void NetworkManager::Ipv4Setting::setDhcpClientId(const QString &id) { Q_D(Ipv4Setting); d->dhcpClientId = id; } QString NetworkManager::Ipv4Setting::dhcpClientId() const { Q_D(const Ipv4Setting); return d->dhcpClientId; } void NetworkManager::Ipv4Setting::setDhcpSendHostname(bool send) { Q_D(Ipv4Setting); d->dhcpSendHostname = send; } bool NetworkManager::Ipv4Setting::dhcpSendHostname() const { Q_D(const Ipv4Setting); return d->dhcpSendHostname; } void NetworkManager::Ipv4Setting::setDhcpHostname(const QString &hostname) { Q_D(Ipv4Setting); d->dhcpHostname = hostname; } QString NetworkManager::Ipv4Setting::dhcpHostname() const { Q_D(const Ipv4Setting); return d->dhcpHostname; } void NetworkManager::Ipv4Setting::setNeverDefault(bool neverDefault) { Q_D(Ipv4Setting); d->neverDefault = neverDefault; } bool NetworkManager::Ipv4Setting::neverDefault() const { Q_D(const Ipv4Setting); return d->neverDefault; } void NetworkManager::Ipv4Setting::setMayFail(bool mayFail) { Q_D(Ipv4Setting); d->mayFail = mayFail; } bool NetworkManager::Ipv4Setting::mayFail() const { Q_D(const Ipv4Setting); return d->mayFail; } +void NetworkManager::Ipv4Setting::setDadTimeout(qint32 timeout) +{ + Q_D(Ipv4Setting); + + d->dadTimeout = timeout; +} + +qint32 NetworkManager::Ipv4Setting::dadTimeout() const +{ + Q_D(const Ipv4Setting); + + return d->dadTimeout; +} + +void NetworkManager::Ipv4Setting::setDhcpFqdn(const QString &fqdn) +{ + Q_D(Ipv4Setting); + + d->dhcpFqdn = fqdn; +} + +QString NetworkManager::Ipv4Setting::dhcpFqdn() const +{ + Q_D(const Ipv4Setting); + + return d->dhcpFqdn; +} + +void NetworkManager::Ipv4Setting::setDnsOptions(const QStringList &options) +{ + Q_D(Ipv4Setting); + + d->dnsOptions = options; +} + +QStringList NetworkManager::Ipv4Setting::dnsOptions() const +{ + Q_D(const Ipv4Setting); + + return d->dnsOptions; +} + +void NetworkManager::Ipv4Setting::setDnsPriority(qint32 priority) +{ + Q_D(Ipv4Setting); + + d->dnsPriority = priority; +} + +qint32 NetworkManager::Ipv4Setting::dnsPriority() const +{ + Q_D(const Ipv4Setting); + + return d->dnsPriority; +} + +void NetworkManager::Ipv4Setting::setGateway(const QString &gateway) +{ + Q_D(Ipv4Setting); + + d->gateway = gateway; +} + +QString NetworkManager::Ipv4Setting::gateway() const +{ + Q_D(const Ipv4Setting); + + return d->gateway; +} + +void NetworkManager::Ipv4Setting::setAddressData(const NMVariantMapList &addressData) +{ + Q_D(Ipv4Setting); + + d->addressData = addressData; +} + +NMVariantMapList NetworkManager::Ipv4Setting::addressData() const +{ + Q_D(const Ipv4Setting); + + return d->addressData; +} + +void NetworkManager::Ipv4Setting::setRouteData(const NMVariantMapList &routeData) +{ + Q_D(Ipv4Setting); + + d->routeData = routeData; +} + +NMVariantMapList NetworkManager::Ipv4Setting::routeData() const +{ + Q_D(const Ipv4Setting); + + return d->routeData; +} + void NetworkManager::Ipv4Setting::fromMap(const QVariantMap &setting) { if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD))) { const QString methodType = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD)).toString(); if (methodType.toLower() == QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_AUTO)) { setMethod(Automatic); } else if (methodType.toLower() == QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL)) { setMethod(LinkLocal); } else if (methodType.toLower() == QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_MANUAL)) { setMethod(Manual); } else if (methodType.toLower() == QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_SHARED)) { setMethod(Shared); } else if (methodType.toLower() == QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_DISABLED)) { setMethod(Disabled); } else { setMethod(Automatic); } } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS))) { QList dbusDns; QList temp; if (setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS)).canConvert()) { QDBusArgument dnsArg = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS)).value(); temp = qdbus_cast >(dnsArg); } else { temp = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS)).value >(); } Q_FOREACH (const uint utmp, temp) { QHostAddress tmpHost(ntohl(utmp)); dbusDns << tmpHost; } setDns(dbusDns); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_SEARCH))) { setDnsSearch(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_SEARCH)).toStringList()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES))) { QList addresses; QList > temp; if (setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES)).canConvert< QDBusArgument>()) { QDBusArgument addressArg = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES)).value(); temp = qdbus_cast > >(addressArg); } else { temp = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES)).value > >(); } Q_FOREACH (const QList &uintList, temp) { if (uintList.count() != 3) { continue; } NetworkManager::IpAddress address; address.setIp(QHostAddress(ntohl(uintList.at(0)))); address.setPrefixLength(uintList.at(1)); address.setGateway(QHostAddress(ntohl(uintList.at(2)))); if (!address.isValid()) { continue; } addresses << address; } setAddresses(addresses); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES))) { QList routes; QList > temp; if (setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)).canConvert< QDBusArgument>()) { QDBusArgument routeArg = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)).value(); temp = qdbus_cast > >(routeArg); } else { temp = setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES)).value > >(); } Q_FOREACH (const QList &uintList, temp) { if (uintList.count() != 4) { continue; } NetworkManager::IpRoute route; route.setIp(QHostAddress(ntohl(uintList.at(0)))); route.setPrefixLength(uintList.at(1)); route.setNextHop(QHostAddress(ntohl(uintList.at(2)))); route.setMetric((quint32)uintList.at(3)); if (!route.isValid()) { continue; } routes << route; } if (!routes.isEmpty()) { setRoutes(routes); } } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC))) { setRouteMetric(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC)).toInt()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES))) { setIgnoreAutoRoutes(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES)).toBool()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS))) { setIgnoreAutoDns(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS)).toBool()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID))) { setDhcpClientId(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID)).toString()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME))) { setDhcpSendHostname(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME)).toBool()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME))) { setDhcpHostname(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME)).toString()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT))) { setNeverDefault(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT)).toBool()); } if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_MAY_FAIL))) { setMayFail(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_MAY_FAIL)).toBool()); } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT))) { + setDadTimeout(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT)).toUInt()); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_FQDN))) { + setDhcpFqdn(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_FQDN)).toString()); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS))) { + setDnsOptions(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS)).toStringList()); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY))) { + setDnsPriority(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY)).toInt()); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_GATEWAY))) { + setGateway(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_GATEWAY)).toString()); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA))) { + setRouteData(qdbus_cast(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA)))); + } + + if (setting.contains(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA))) { + setAddressData(qdbus_cast(setting.value(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA)))); + } } QVariantMap NetworkManager::Ipv4Setting::toMap() const { QVariantMap setting; if (method() == Automatic) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_AUTO)); } else if (method() == LinkLocal) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL)); } else if (method() == Manual) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_MANUAL)); } else if (method() == Shared) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_SHARED)); } else if (method() == Disabled) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD), QLatin1String(NMQT_SETTING_IP4_CONFIG_METHOD_DISABLED)); } if (!dns().isEmpty()) { QList dbusDns; Q_FOREACH (const QHostAddress & dns, dns()) { dbusDns << htonl(dns.toIPv4Address()); } setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS), QVariant::fromValue(dbusDns)); } if (!dnsSearch().isEmpty()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_SEARCH), dnsSearch()); } if (!addresses().isEmpty()) { QList > dbusAddresses; Q_FOREACH (const NetworkManager::IpAddress & addr, addresses()) { QList dbusAddress; dbusAddress << htonl(addr.ip().toIPv4Address()) << addr.prefixLength() << htonl(addr.gateway().toIPv4Address()); dbusAddresses << dbusAddress; } setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESSES), QVariant::fromValue(dbusAddresses)); } if (!routes().isEmpty()) { QList > dbusRoutes; Q_FOREACH (const NetworkManager::IpRoute & route, routes()) { QList dbusRoute; dbusRoute << htonl(route.ip().toIPv4Address()) << route.prefixLength() << htonl(route.nextHop().toIPv4Address()) << route.metric(); dbusRoutes << dbusRoute; } setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTES), QVariant::fromValue(dbusRoutes)); } if(routeMetric() >= 0) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC), routeMetric()); } if (ignoreAutoRoutes()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES), ignoreAutoRoutes()); } if (ignoreAutoDns()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS), ignoreAutoDns()); } if (!dhcpClientId().isEmpty()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID), dhcpClientId()); } if (!dhcpSendHostname()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME), dhcpSendHostname()); } if (!dhcpHostname().isEmpty()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME), dhcpHostname()); } if (neverDefault()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT), neverDefault()); } if (!mayFail()) { setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_MAY_FAIL), mayFail()); } + if (dadTimeout() >= 0) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT), dadTimeout()); + } + + if (!dhcpFqdn().isEmpty()) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DHCP_FQDN), dhcpFqdn()); + } + + if (!dnsOptions().isEmpty()) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS), dnsOptions()); + } + + if (dnsPriority() != 0) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY), dnsPriority()); + } + + if (!gateway().isEmpty()) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_GATEWAY), gateway()); + } + + if (!addressData().empty()) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA), QVariant::fromValue(addressData())); + } + + if (!routeData().empty()) { + setting.insert(QLatin1String(NMQT_SETTING_IP4_CONFIG_ROUTE_DATA), QVariant::fromValue(routeData())); + } + return setting; } QDebug NetworkManager::operator <<(QDebug dbg, const NetworkManager::Ipv4Setting &setting) { dbg.nospace() << "type: " << setting.typeAsString(setting.type()) << '\n'; dbg.nospace() << "initialized: " << !setting.isNull() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_METHOD << ": " << setting.method() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DNS << ":\n"; Q_FOREACH (const QHostAddress & address, setting.dns()) { dbg.nospace() << address.toString() << '\n'; } dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DNS_SEARCH << ": " << setting.dnsSearch() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_ADDRESSES << '\n'; Q_FOREACH (const NetworkManager::IpAddress & address, setting.addresses()) { dbg.nospace() << address.ip() << ": " << address.gateway() << ": " << address.netmask() << '\n'; } dbg.nospace() << NMQT_SETTING_IP4_CONFIG_ROUTES << '\n'; Q_FOREACH (const NetworkManager::IpRoute & route, setting.routes()) { dbg.nospace() << route.ip() << ": " << route.netmask() << ": " << route.nextHop() << ": " << route.metric() << '\n'; } dbg.nospace() << NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC << ":" << setting.routeMetric() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES << ": " << setting.ignoreAutoRoutes() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS << ": " << setting.ignoreAutoDns() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID << ": " << setting.dhcpClientId() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME << ": " << setting.dhcpSendHostname() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME << ": " << setting.dhcpHostname() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT << ": " << setting.neverDefault() << '\n'; dbg.nospace() << NMQT_SETTING_IP4_CONFIG_MAY_FAIL << ": " << setting.mayFail() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT << ": " << setting.dadTimeout() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DHCP_FQDN << ": " << setting.dhcpFqdn() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS << ": " << setting.dnsOptions() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY << ": " << setting.dnsPriority() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_GATEWAY << ": " << setting.gateway() << '\n'; + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA << ": " << '\n'; + Q_FOREACH (const QVariantMap & addressData, setting.addressData()) { + QVariantMap::const_iterator i = addressData.constBegin(); + while (i != addressData.constEnd()) { + dbg.nospace() << i.key() << ": " << i.value() << '\n'; + } + } + dbg.nospace() << NMQT_SETTING_IP4_CONFIG_ROUTE_DATA << ": " << '\n'; + Q_FOREACH (const QVariantMap & routeData, setting.routeData()) { + QVariantMap::const_iterator i = routeData.constBegin(); + while (i != routeData.constEnd()) { + dbg.nospace() << i.key() << ": " << i.value() << '\n'; + } + } return dbg.maybeSpace(); } diff --git a/src/settings/ipv4setting.h b/src/settings/ipv4setting.h index 5656660..13a731f 100644 --- a/src/settings/ipv4setting.h +++ b/src/settings/ipv4setting.h @@ -1,128 +1,156 @@ /* Copyright 2012-2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef NETWORKMANAGERQT_IPV4_SETTING_H #define NETWORKMANAGERQT_IPV4_SETTING_H #include "ipconfig.h" #include #include "setting.h" #include #include #define NMQT_SETTING_IP4_CONFIG_SETTING_NAME NM_SETTING_IP4_CONFIG_SETTING_NAME #define NMQT_SETTING_IP4_CONFIG_METHOD NM_SETTING_IP_CONFIG_METHOD #define NMQT_SETTING_IP4_CONFIG_DNS NM_SETTING_IP_CONFIG_DNS #define NMQT_SETTING_IP4_CONFIG_DNS_SEARCH NM_SETTING_IP_CONFIG_DNS_SEARCH #define NMQT_SETTING_IP4_CONFIG_ADDRESSES NM_SETTING_IP_CONFIG_ADDRESSES #define NMQT_SETTING_IP4_CONFIG_GATEWAY NM_SETTING_IP_CONFIG_GATEWAY #define NMQT_SETTING_IP4_CONFIG_ROUTES NM_SETTING_IP_CONFIG_ROUTES #define NMQT_SETTING_IP4_CONFIG_ROUTE_METRIC NM_SETTING_IP_CONFIG_ROUTE_METRIC #define NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES NM_SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES #define NMQT_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS #define NMQT_SETTING_IP4_CONFIG_DHCP_HOSTNAME NM_SETTING_IP_CONFIG_DHCP_HOSTNAME #define NMQT_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME NM_SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME #define NMQT_SETTING_IP4_CONFIG_NEVER_DEFAULT NM_SETTING_IP_CONFIG_NEVER_DEFAULT #define NMQT_SETTING_IP4_CONFIG_MAY_FAIL NM_SETTING_IP_CONFIG_MAY_FAIL #define NMQT_SETTING_IP4_CONFIG_DHCP_CLIENT_ID NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID #define NMQT_SETTING_IP4_CONFIG_METHOD_AUTO NM_SETTING_IP4_CONFIG_METHOD_AUTO #define NMQT_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL #define NMQT_SETTING_IP4_CONFIG_METHOD_MANUAL NM_SETTING_IP4_CONFIG_METHOD_MANUAL #define NMQT_SETTING_IP4_CONFIG_METHOD_SHARED NM_SETTING_IP4_CONFIG_METHOD_SHARED #define NMQT_SETTING_IP4_CONFIG_METHOD_DISABLED NM_SETTING_IP4_CONFIG_METHOD_DISABLED +#define NMQT_SETTING_IP4_CONFIG_DAD_TIMEOUT NM_SETTING_IP_CONFIG_DAD_TIMEOUT +#define NMQT_SETTING_IP4_CONFIG_DHCP_FQDN NM_SETTING_IP4_CONFIG_DHCP_FQDN +#define NMQT_SETTING_IP4_CONFIG_DNS_OPTIONS NM_SETTING_IP_CONFIG_DNS_OPTIONS +#define NMQT_SETTING_IP4_CONFIG_DNS_PRIORITY NM_SETTING_IP_CONFIG_DNS_PRIORITY +#define NMQT_SETTING_IP4_CONFIG_GATEWAY NM_SETTING_IP_CONFIG_GATEWAY +#define NMQT_SETTING_IP4_CONFIG_ROUTE_DATA "route-data" +#define NMQT_SETTING_IP4_CONFIG_ADDRESS_DATA "address-data" namespace NetworkManager { class Ipv4SettingPrivate; /** * Represents ipv4 setting */ class NETWORKMANAGERQT_EXPORT Ipv4Setting : public Setting { public: typedef QSharedPointer Ptr; typedef QList List; enum ConfigMethod {Automatic, LinkLocal, Manual, Shared, Disabled}; Ipv4Setting(); explicit Ipv4Setting(const Ptr &other); ~Ipv4Setting() override; QString name() const override; void setMethod(ConfigMethod method); ConfigMethod method() const; void setDns(const QList &dns); QList dns() const; void setDnsSearch(const QStringList &domains); QStringList dnsSearch() const; void setAddresses(const QList &ipv4addresses); QList addresses() const; void setRoutes(const QList &ipv4routes); QList routes() const; void setRouteMetric(int metric); int routeMetric() const; void setIgnoreAutoRoutes(bool ignore); bool ignoreAutoRoutes() const; void setIgnoreAutoDns(bool ignore); bool ignoreAutoDns() const; void setDhcpClientId(const QString &id); QString dhcpClientId() const; void setDhcpSendHostname(bool send); bool dhcpSendHostname() const; void setDhcpHostname(const QString &hostname); QString dhcpHostname() const; void setNeverDefault(bool neverDefault); bool neverDefault() const; void setMayFail(bool mayFail); bool mayFail() const; + void setDadTimeout(qint32 timeout); + qint32 dadTimeout() const; + + void setDhcpFqdn(const QString &fqdn); + QString dhcpFqdn() const; + + void setDnsOptions(const QStringList &options); + QStringList dnsOptions() const; + + void setDnsPriority(qint32 priority); + qint32 dnsPriority() const; + + void setGateway(const QString &gateway); + QString gateway() const; + + void setAddressData(const NMVariantMapList &addressData); + NMVariantMapList addressData() const; + + void setRouteData(const NMVariantMapList &routeData); + NMVariantMapList routeData() const; + void fromMap(const QVariantMap &setting) override; QVariantMap toMap() const override; protected: Ipv4SettingPrivate *d_ptr; private: Q_DECLARE_PRIVATE(Ipv4Setting) }; NETWORKMANAGERQT_EXPORT QDebug operator<<(QDebug dbg, const Ipv4Setting &setting); } #endif // NETWORKMANAGERQT_IPV4_SETTING_H diff --git a/src/settings/ipv4setting_p.h b/src/settings/ipv4setting_p.h index 8cc91bb..01041dc 100644 --- a/src/settings/ipv4setting_p.h +++ b/src/settings/ipv4setting_p.h @@ -1,54 +1,62 @@ /* Copyright 2012-2013 Jan Grulich This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) version 3, or any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy defined in Section 6 of version 3 of the license. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef NETWORKMANAGERQT_IPV4_SETTING_P_H #define NETWORKMANAGERQT_IPV4_SETTING_P_H #include "../ipconfig.h" +#include #include #include namespace NetworkManager { class Ipv4SettingPrivate { public: Ipv4SettingPrivate(); QString name; NetworkManager::Ipv4Setting::ConfigMethod method; QList dns; QStringList dnsSearch; QList addresses; QList routes; int routeMetric; bool ignoreAutoRoutes; bool ignoreAutoDns; QString dhcpClientId; bool dhcpSendHostname; QString dhcpHostname; bool neverDefault; bool mayFail; + qint32 dadTimeout; + QString dhcpFqdn; + QStringList dnsOptions; + qint32 dnsPriority; + QString gateway; + NMVariantMapList addressData; + NMVariantMapList routeData; }; } #endif // NETWORKMANAGERQT_IPV4_SETTING_P_H