← Back to branch summary

~ubuntu-branches/ubuntu/precise/networkmanagement/precise-updates

« back to all changes in this revision

Viewing changes to backends/NetworkManager/settings/ipv6dbus.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl, Modestas Vainius, Michael Biebl
  • Date: 2011-05-27 12:18:25 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110527121825-vfufwquq3vy0k3zn
Tags: 0.1+git20110526.911025d-1
[ Modestas Vainius ]
* Use official KDE branding in the package descriptions.

[ Michael Biebl ]
* New upstream Git snapshot 911025d81fdfbe09b64705e94e5411f521c38e3e.
* debian/control
  - Bump Build-Depends on kdelibs5-dev and kdebase-workspace-dev to
    (>= 4:4.6.0).
  - Bump Build-Depends on network-manager-dev and libnm-util-dev to
    (>= 0.8.1).
  - Bump Depends on network-manager to (>= 0.8.1).

Show diffs side-by-side

added added

removed removed

Lines of Context:
backends/NetworkManager/settings/ipv6dbus.cpp
 
1
// This file is generated by kconfig_compiler from ipv6.kcfg.
 
2
// All changes you do to this file will be lost.
 
3
 
 
4
#include "ipv6dbus.h"
 
5
 
 
6
#include <arpa/inet.h>
 
7
#include "../../types.h"
 
8
#include "ipv6.h"
 
9
 
 
10
Ipv6Dbus::Ipv6Dbus(Knm::Ipv6Setting * setting) : SettingDbus(setting)
 
11
{
 
12
}
 
13
 
 
14
Ipv6Dbus::~Ipv6Dbus()
 
15
{
 
16
}
 
17
 
 
18
void Ipv6Dbus::fromMap(const QVariantMap & map)
 
19
{
 
20
  kDebug() << "IPv6 map: ";
 
21
  foreach(const QString &key, map.keys())
 
22
      kDebug() << key << " : " << map.value(key);
 
23
 
 
24
  Knm::Ipv6Setting * setting = static_cast<Knm::Ipv6Setting*>(m_setting);
 
25
 
 
26
  if (map.contains("method")) {
 
27
      setting->setMethod(methodStringToEnum(map.value("method").value<QString>())); }
 
28
 
 
29
  if (map.contains("dns")) {
 
30
      QDBusArgument dnsArg = map.value("dns").value< QDBusArgument>();
 
31
      QList<QHostAddress> dbusDns;
 
32
 
 
33
      dnsArg.beginArray();
 
34
      while(!dnsArg.atEnd())
 
35
      {
 
36
          QByteArray utmp;
 
37
          dnsArg >> utmp;
 
38
          Q_IPV6ADDR tmp;
 
39
          for (int i = 0; i < 16; i++)
 
40
          {
 
41
              tmp[i] = utmp[i];
 
42
          }
 
43
          QHostAddress tmpHost(tmp);
 
44
          dbusDns << tmpHost;
 
45
      }
 
46
      //NO dnsArg.endArray(); it's fatal in debug builds.
 
47
 
 
48
      setting->setDns(dbusDns);
 
49
  }
 
50
 
 
51
  if (map.contains(QLatin1String(NM_SETTING_IP6_CONFIG_DNS_SEARCH)) &&
 
52
      !map.value(QLatin1String(NM_SETTING_IP6_CONFIG_DNS_SEARCH)).value<QStringList>().isEmpty()
 
53
     ) {
 
54
    setting->setDnssearch(map.value(QLatin1String(NM_SETTING_IP6_CONFIG_DNS_SEARCH)).value<QStringList>());
 
55
  }
 
56
 
 
57
  if (map.contains("addresses")) {
 
58
      QDBusArgument addressArg = map.value("addresses").value< QDBusArgument>();
 
59
      QList<Solid::Control::IPv6Address> addresses;
 
60
 
 
61
      addressArg.beginArray();
 
62
      while(!addressArg.atEnd())
 
63
      {
 
64
          IpV6AddressMap addressMap;
 
65
          addressArg >> addressMap;
 
66
 
 
67
          if (addressMap.address.isEmpty() || !addressMap.netMask || addressMap.gateway.isEmpty())
 
68
          {
 
69
            kWarning() << "Invalid address format detected.";
 
70
            continue;
 
71
          }
 
72
          Q_IPV6ADDR ip, gateway;
 
73
          for (int i = 0; i < 16; i++)
 
74
          {
 
75
              ip[i] = addressMap.address[i];
 
76
          }
 
77
          for (int i = 0; i < 16; i++)
 
78
          {
 
79
              gateway[i] = addressMap.gateway[i];
 
80
          }
 
81
 
 
82
          Solid::Control::IPv6Address addr(ip, addressMap.netMask, gateway);
 
83
          if (!addr.isValid())
 
84
          {
 
85
            kWarning() << "Invalid address format detected.";
 
86
            continue;
 
87
          }
 
88
 
 
89
          addresses << addr;
 
90
      }
 
91
      //NO addressArg.endArray(); it's fatal in debug builds.
 
92
 
 
93
      setting->setAddresses(addresses);
 
94
  }
 
95
 
 
96
  if (map.contains("routes"))
 
97
  {
 
98
      QDBusArgument routeArg = map.value("routes").value< QDBusArgument>();
 
99
      QList<Solid::Control::IPv6Route> routes;
 
100
 
 
101
      routeArg.beginArray();
 
102
      while(!routeArg.atEnd())
 
103
      {
 
104
          IpV6RouteMap routeMap;
 
105
          routeArg >> routeMap;
 
106
 
 
107
          if (routeMap.route.isEmpty() || !routeMap.prefix || routeMap.nextHop.isEmpty() || !routeMap.metric)
 
108
          {
 
109
              kWarning() << "Invalid route format detected.";
 
110
              continue;
 
111
          }
 
112
          Q_IPV6ADDR addr, nexthop;
 
113
          for (int i = 0; i < 16; i++)
 
114
          {
 
115
              addr[i] = routeMap.route[i];
 
116
          }
 
117
          for (int i = 0; i < 16; i++)
 
118
          {
 
119
              nexthop[i] = routeMap.nextHop[i];
 
120
          }
 
121
 
 
122
          Solid::Control::IPv6Route route(addr, routeMap.prefix, nexthop, routeMap.metric);
 
123
          if (!route.isValid())
 
124
          {
 
125
              kWarning() << "Invalid route format detected.";
 
126
              continue;
 
127
          }
 
128
 
 
129
          routes << route;
 
130
      }
 
131
      setting->setRoutes(routes);
 
132
  }
 
133
 
 
134
  if (map.contains(QLatin1String(NM_SETTING_IP6_CONFIG_IGNORE_AUTO_DNS))) {
 
135
    setting->setIgnoredhcpdns(map.value(QLatin1String(NM_SETTING_IP6_CONFIG_IGNORE_AUTO_DNS)).value<bool>());
 
136
  }
 
137
  if (map.contains(QLatin1String(NM_SETTING_IP6_CONFIG_IGNORE_AUTO_ROUTES))) {
 
138
    setting->setIgnoreautoroute(map.value(QLatin1String(NM_SETTING_IP6_CONFIG_IGNORE_AUTO_ROUTES)).value<bool>());
 
139
  }
 
140
  if (map.contains(QLatin1String(NM_SETTING_IP6_CONFIG_NEVER_DEFAULT))) {
 
141
    setting->setNeverdefault(map.value(QLatin1String(NM_SETTING_IP6_CONFIG_NEVER_DEFAULT)).value<bool>());
 
142
  }
 
143
  if (map.contains(QLatin1String(NM_SETTING_IP6_CONFIG_MAY_FAIL))) {
 
144
    setting->setMayfail(map.value(QLatin1String(NM_SETTING_IP6_CONFIG_MAY_FAIL)).value<bool>());
 
145
  }
 
146
}
 
147
 
 
148
Knm::Ipv6Setting::EnumMethod::type Ipv6Dbus::methodStringToEnum(QString method)
 
149
{
 
150
    if (method.toLower() == "automatic" || method.toLower() == "auto")
 
151
        return Knm::Ipv6Setting::EnumMethod::Automatic;
 
152
    else if (method.toLower() == "linklocal" || method.toLower() == "link-local")
 
153
        return Knm::Ipv6Setting::EnumMethod::LinkLocal;
 
154
    else if (method.toLower() == "manual")
 
155
        return Knm::Ipv6Setting::EnumMethod::Manual;
 
156
    else if (method.toLower() == "shared")
 
157
        return Knm::Ipv6Setting::EnumMethod::Shared;
 
158
    else if (method.toLower() == "ignore")
 
159
        return Knm::Ipv6Setting::EnumMethod::Ignore;
 
160
    else
 
161
    {
 
162
        kDebug() << "Unknown method given:" << method;
 
163
        return Knm::Ipv6Setting::EnumMethod::Automatic;
 
164
    }
 
165
}
 
166
 
 
167
QVariantMap Ipv6Dbus::toMap()
 
168
{
 
169
  QVariantMap map;
 
170
  Knm::Ipv6Setting * setting = static_cast<Knm::Ipv6Setting *>(m_setting);
 
171
  switch (setting->method()) {
 
172
      case Knm::Ipv6Setting::EnumMethod::Automatic:
 
173
          map.insert("method", "auto");
 
174
          break;
 
175
      case Knm::Ipv6Setting::EnumMethod::LinkLocal:
 
176
          map.insert("method", "link-local");
 
177
          break;
 
178
      case Knm::Ipv6Setting::EnumMethod::Manual:
 
179
          map.insert("method", "manual");
 
180
          break;
 
181
      case Knm::Ipv6Setting::EnumMethod::Shared:
 
182
          map.insert("method", "shared");
 
183
          break;
 
184
      case Knm::Ipv6Setting::EnumMethod::Ignore:
 
185
          map.insert("method", "ignore");
 
186
          break;
 
187
  }
 
188
 
 
189
  if (!setting->dns().isEmpty()) {
 
190
      QList<QByteArray> dbusDns;
 
191
      foreach (const QHostAddress &dns, setting->dns()) {
 
192
          Q_IPV6ADDR dnsAddress = dns.toIPv6Address();
 
193
          QByteArray assembledDnsAddress;
 
194
          for (int i = 0; i <16; i++)
 
195
          {
 
196
              assembledDnsAddress[i] = dnsAddress[i];
 
197
          }
 
198
 
 
199
          dbusDns << assembledDnsAddress;
 
200
      }
 
201
      map.insert("dns", QVariant::fromValue(dbusDns));
 
202
  }
 
203
 
 
204
  if (!setting->dnssearch().isEmpty()) {
 
205
      map.insert(QLatin1String(NM_SETTING_IP6_CONFIG_DNS_SEARCH), setting->dnssearch());
 
206
  }
 
207
  if (!setting->addresses().isEmpty()) {
 
208
      QList<IpV6AddressMap> dbusAddresses;
 
209
      foreach (const Solid::Control::IPv6Address &addr, setting->addresses()) {
 
210
          IpV6AddressMap dbusAddress;
 
211
          Q_IPV6ADDR address = addr.address();
 
212
          QList<quint8> assembledAddress;
 
213
          for (int i = 0; i < 16; i++)
 
214
          {
 
215
              assembledAddress << address[i];
 
216
          }
 
217
 
 
218
          Q_IPV6ADDR gateway = addr.gateway();
 
219
          QList<quint8> assembledGateway;
 
220
          for (int i = 0; i < 16; i++)
 
221
          {
 
222
              assembledGateway << gateway[i];
 
223
          }
 
224
 
 
225
          dbusAddress.address = assembledAddress;
 
226
          dbusAddress.netMask = addr.netMask();
 
227
          dbusAddress.gateway = assembledGateway;
 
228
          dbusAddresses << dbusAddress;
 
229
      }
 
230
      map.insert("addresses", QVariant::fromValue(dbusAddresses));
 
231
  }
 
232
  if (!setting->routes().isEmpty()) {
 
233
      QList<IpV6RouteMap> dbusRoutes;
 
234
      foreach (const Solid::Control::IPv6Route &route, setting->routes()) {
 
235
          IpV6RouteMap dbusRoute;
 
236
 
 
237
          Q_IPV6ADDR Route = route.route();
 
238
          QList<quint8> assembledRoute;
 
239
          for (int i = 0; i < 16; i++)
 
240
          {
 
241
              assembledRoute << Route[i];
 
242
          }
 
243
 
 
244
          Q_IPV6ADDR nextHop = route.nextHop();
 
245
          QList<quint8> assembledNextHop;
 
246
          for (int i = 0; i < 16; i++)
 
247
          {
 
248
              assembledNextHop << nextHop[i];
 
249
          }
 
250
 
 
251
          dbusRoute.route = assembledRoute;
 
252
          dbusRoute.prefix = route.prefix();
 
253
          dbusRoute.nextHop = assembledNextHop;
 
254
          dbusRoute.metric = route.metric();
 
255
          dbusRoutes << dbusRoute;
 
256
      }
 
257
 
 
258
      map.insert("routes", QVariant::fromValue(dbusRoutes));
 
259
  }
 
260
 
 
261
 
 
262
  insertIfTrue(map, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_DNS, setting->ignoredhcpdns());
 
263
  insertIfTrue(map, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_ROUTES, setting->ignoreautoroute());
 
264
  insertIfTrue(map, NM_SETTING_IP6_CONFIG_NEVER_DEFAULT, setting->neverdefault());
 
265
  insertIfTrue(map, NM_SETTING_IP6_CONFIG_MAY_FAIL, setting->mayfail());
 
266
  return map;
 
267
}
 
268
 
 
269
QVariantMap Ipv6Dbus::toSecretsMap()
 
270
{
 
271
  QVariantMap map;
 
272
  return map;
 
273
}
 
274
 
 
275
QDBusArgument &operator<<(QDBusArgument &argument, const IpV6AddressMap &map)
 
276
{
 
277
    argument.beginStructure();
 
278
    argument << map.address << map.netMask << map.gateway;
 
279
    argument.endStructure();
 
280
    return argument;
 
281
}
 
282
 
 
283
const QDBusArgument &operator>>(const QDBusArgument &argument, IpV6AddressMap &map)
 
284
{
 
285
    argument.beginStructure();
 
286
    argument >> map.address >> map.netMask >> map.gateway;
 
287
    argument.endStructure();
 
288
    return argument;
 
289
}
 
290
 
 
291
QDBusArgument &operator<<(QDBusArgument &argument, const IpV6RouteMap &map)
 
292
{
 
293
    argument.beginStructure();
 
294
    argument << map.route << map.prefix << map.nextHop << map.metric;
 
295
    argument.endStructure();
 
296
    return argument;
 
297
}
 
298
 
 
299
const QDBusArgument &operator>>(const QDBusArgument &argument, IpV6RouteMap &map)
 
300
{
 
301
    argument.beginStructure();
 
302
    argument >> map.route >> map.prefix >> map.nextHop >> map.metric;
 
303
    argument.endStructure();
 
304
    return argument;
 
305
}