Testversion für Franz, etwas weniger bereinigt. ;-)

QmlTest/main.cpp

@@ -4,9 +4,7 @@
 int main(int argc, char *argv[])
 {
     QGuiApplication app(argc, argv);
-
     QQmlApplicationEngine engine;
     engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
-
     return app.exec();
 }

QmlTest/main.qml

@@ -10,6 +10,10 @@ Window {
 
     NetInterfaces {
         id: idItf
+        onSigError:
+        {
+            console.error(msg);
+        }
     }
 
     MouseArea {
@@ -22,12 +26,17 @@ Window {
 
                 if(ifs.length > 0)
                 {
-                    console.log(ifs[0].ipAddress);
+                    ifs[0].ipAddress.b3 = 412;
+                    ifs[0].ipAddress.address = "192.168.0.256"
+                    ifs[0].ipAddress.address = "155.18.2.156"
+                    console.log(ifs[0].ipAddress.address);
                 }
                 else
                 {
                     console.log("No interface found!");
                 }
+
+                idItf.save("/home/wrk/share/gfanet/libgfanet/res/testitf");
             }
         }
     }

libgfanet/inet4d.h

@@ -30,10 +30,10 @@ typedef struct _IFACE_INET_DHCP
 		client.clear();
 		hwaddr.clear();
 	}
-	std::string hostname;	// Hostname to be requested
-	int metric;
 	int leasehours;			// Preferred lease time in hours
 	int leasetime;			// Preferred lease time in seconds
+	int metric;
+	std::string hostname;	// Hostname to be requested
 	std::string vendor;		// Vendor class identifier (dhcpcd)
 	std::string client;		// Client identifier (dhcpcd)
 	std::string hwaddr;

qtplugin/netinterfaces.cpp

@@ -4,6 +4,8 @@
 #define _countof(a)					(sizeof(a) / sizeof(*a))
 #endif	//	_countof
 
+#define _IS_VALID_BYTE_VALUE(b)		(((b) >= 0) && ((b) <= 255))
+
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
@@ -46,12 +48,38 @@ bool NetInterfaces::initialize(void)
 		for(auto it = m_eni.ibl.begin(); it != m_eni.ibl.end(); it++)
 		{
 			ITF_IFACE_BLOCK &ibl = *it;
-			m_itfList.push_back(new Interface(ibl));
+			m_itfList.push_back(new Interface(ibl, static_cast<const Emitter&>(*this), this));
 		}
 	}
 	return bRet;
 }
 
+bool NetInterfaces::save(void)
+{
+	return ::WriteEtcNetworkInterfaces(m_eni, NULL);
+}
+
+bool NetInterfaces::save(QString path)
+{
+	std::string p;
+	const char *pszPath = NULL;
+	if(path.length() > 0)
+	{
+		p = path.toStdString();
+		pszPath = p.c_str();
+	}
+	return ::WriteEtcNetworkInterfaces(m_eni, pszPath);
+}
+
+void NetInterfaces::emitError(const char *pszFormatStr, ...) const
+{
+	va_list args;
+	va_start(args, pszFormatStr);
+	QString qs = QString::vasprintf(pszFormatStr, args);
+	va_end (args);
+    emit sigError(qs);
+}
+
 QVariantList NetInterfaces::getInterface(const QString &itfName)
 {
 	QVariantList list;
@@ -79,10 +107,23 @@ QVariantList NetInterfaces::getInterface(const QString &itfName)
 
 /////////////////////////////////////////////////////////////////////////////
 
-Interface::Interface(ITF_IFACE_BLOCK &ifb, QObject *pParent) : QObject(pParent), m_ifb(ifb)
+Interface::Interface(ITF_IFACE_BLOCK &ifb, const Emitter &errHandler, QObject *pParent) : 	QObject(pParent),
+																							m_ifb(ifb),
+																							m_ipAddr(ifb.inet4s.addr, errHandler, this),
+																							m_netmask(ifb.inet4s.netmask, errHandler, this),
+																							m_gateway(ifb.inet4s.gate, errHandler, this),
+																							m_bcastAddr(ifb.inet4s.bcast, errHandler, this),
+																							m_ptpAddr(ifb.inet4s.pointopoint, errHandler, this),
+																							m_errHandler(errHandler)
+																							/*, m_dnsSvr(ifb.inet4s.namesvr)*/
 {
 	setObjectName("Interface");
-
+	for(size_t i = 0; i < _countof(m_ifb.inet4s.namesvr); i++)
+	{
+		IPv4Address *addr = new IPv4Address(m_ifb.inet4s.namesvr[i], errHandler, this);
+		m_dnsList.append(addr);
+	}
+#if 0
 	for(size_t i = 0; i < _countof(m_ifb.inet4s.namesvr); i++)
 	{
 		if(m_ifb.inet4s.namesvr[i].s_addr)
@@ -96,10 +137,18 @@ Interface::Interface(ITF_IFACE_BLOCK &ifb, QObject *pParent) : QObject(pParent),
 			m_dnsList.append(qs);
 		}
 	}
+#endif
 }
 
 Interface::~Interface(void)
 {
+	IPv4Address *addr;
+	
+    for(int i = 0; i < m_dnsList.count(); i++)
+    {
+        if((addr = m_dnsList.at(i)))
+        	delete addr;
+    }
 }
 
 QString Interface::name(void) const
@@ -117,25 +166,199 @@ QString Interface::method(void) const
 	return ::GetIfaceMethodStr(m_ifb.method);
 }
 
-QString Interface::ipAddress(void) const
+IPv4Address* Interface::ipAddress(void)
 {
+	return &m_ipAddr;
 //	if(m_ifb.proto == IFP_Inet && m_ifb.method == IFM_Static)
-		return inet_ntoa(m_ifb.inet4s.addr);
+//		return inet_ntoa(m_ifb.inet4s.addr);
 //	else
 //		return "";
 }
 
-QString Interface::netMask(void) const
+IPv4Address* Interface::netMask(void)
+{
+	return &m_netmask;
+}
+
+IPv4Address* Interface::gateway(void)
+{
+	return &m_gateway;
+}
+
+IPv4Address* Interface::bcastAddress(void)
 {
-	return inet_ntoa(m_ifb.inet4s.netmask);
+	return &m_bcastAddr;
 }
 
-QString Interface::gateway(void) const
+IPv4Address* Interface::ptpAddress(void)
 {
-	return inet_ntoa(m_ifb.inet4s.gate);
+	return &m_ptpAddr;
 }
 
+#if 0
 QStringList Interface::dnsServers(void) const
 {
 	return m_dnsList;
 }
+#endif
+
+QQmlListProperty<IPv4Address> Interface::dnsServer(void)
+{
+	return QQmlListProperty<IPv4Address>(this, m_dnsList);
+}
+
+/*QString Interface::dns1(void) const
+{
+	return inet_ntoa(m_ifb.inet4s.namesvr[0]);
+}
+
+QString Interface::dns2(void) const
+{
+	return inet_ntoa(m_ifb.inet4s.namesvr[1]);
+}
+
+QString Interface::dns3(void) const
+{
+	return inet_ntoa(m_ifb.inet4s.namesvr[2]);
+}*/
+
+/////////////////////////////////////////////////////////////////////////////
+
+IPv4Address::IPv4Address(struct in_addr &addr, const Emitter &errHandler, QObject *pParent) : QObject(pParent), m_addr(addr), m_errHandler(errHandler)
+{
+}
+
+IPv4Address::~IPv4Address(void)
+{
+}
+
+QString IPv4Address::address(void) const
+{
+	return inet_ntoa(m_addr);
+}
+
+int IPv4Address::b0(void) const
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	return (int)pb[0];
+}
+
+int IPv4Address::b1(void) const
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	return (int)pb[1];
+}
+
+int IPv4Address::b2(void) const
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	return (int)pb[2];
+}
+
+int IPv4Address::b3(void) const
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	return (int)pb[3];
+}
+    
+void IPv4Address::set_address(const QString &addr)
+{
+	struct in_addr newAddr, oldAddr;
+	std::string sa = addr.toStdString();
+
+	if(!inet_aton(sa.c_str(), &newAddr))
+	{
+		m_errHandler.emitError("Invalid IP address: '%s'!", sa.c_str());
+		return;
+	}
+
+	if(m_addr.s_addr != newAddr.s_addr)
+	{
+		oldAddr.s_addr = m_addr.s_addr;
+		m_addr.s_addr  = newAddr.s_addr;
+
+		unsigned char *pb1 = (unsigned char*)&oldAddr.s_addr;
+		unsigned char *pb2 = (unsigned char*)&newAddr.s_addr;
+		if(pb1[0] != pb2[0])
+			emit b0_Changed(pb2[0]);
+		if(pb1[1] != pb2[1])
+			emit b1_Changed(pb2[1]);
+		if(pb1[2] != pb2[2])
+			emit b2_Changed(pb2[2]);
+		if(pb1[3] != pb2[3])
+			emit b3_Changed(pb2[3]);
+		emit address_Changed(address());
+	}
+}
+
+void IPv4Address::set_b0(int b)
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	if(!_IS_VALID_BYTE_VALUE(b))
+	{
+		m_errHandler.emitError("Invalid IP address byte 0: '%d'!", b);
+		return;
+	}
+	if(b == (int)pb[0])
+		return;
+	pb[0] = (unsigned char)b;
+	emit b0_Changed(b);
+	emit address_Changed(address());
+}
+
+void IPv4Address::set_b1(int b)
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	if(!_IS_VALID_BYTE_VALUE(b))
+	{
+		m_errHandler.emitError("Invalid IP address byte 1: '%d'!", b);
+		return;
+	}
+	if(b == (int)pb[1])
+		return;
+	pb[1] = (unsigned char)b;
+	emit b1_Changed(b);
+	emit address_Changed(address());
+}
+
+void IPv4Address::set_b2(int b)
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	if(!_IS_VALID_BYTE_VALUE(b))
+	{
+		m_errHandler.emitError("Invalid IP address byte 2: '%d'!", b);
+		return;
+	}
+	if(b == (int)pb[2])
+		return;
+	pb[2] = (unsigned char)b;
+	emit b2_Changed(b);
+	emit address_Changed(address());
+}
+
+void IPv4Address::set_b3(int b)
+{
+	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
+	if(!_IS_VALID_BYTE_VALUE(b))
+	{
+		m_errHandler.emitError("Invalid IP address byte 3: '%d'!", b);
+		return;
+	}
+	if(b == (int)pb[3])
+		return;
+	pb[3] = (unsigned char)b;
+	emit b3_Changed(b);
+	emit address_Changed(address());
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+#if 0
+Nameservers::Nameservers(struct in_addr (&namesvr)[3], QObject *pParent) : QObject(pParent), m_dnsSvr(namesvr)
+{
+}
+
+Nameservers::~Nameservers(void)
+{
+}
+#endif

qtplugin/netinterfaces.h

@@ -14,6 +14,70 @@
 /////////////////////////////////////////////////////////////////////////////
 // netinterfaces.h - Declarations:
 
+class Emitter
+{
+public:
+	virtual void emitError(const char *pszFormatStr, ...) const	= 0;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+#if 0
+class Nameservers : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit Nameservers(struct in_addr (&namesvr)[3], QObject *pParent = 0);
+    virtual ~Nameservers(void);
+
+private:
+	struct in_addr (&m_dnsSvr)[3];
+};
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+class IPv4Address : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString address READ address WRITE set_address NOTIFY address_Changed)
+    Q_PROPERTY(int b0 READ b0 WRITE set_b0 NOTIFY b0_Changed)
+    Q_PROPERTY(int b1 READ b1 WRITE set_b1 NOTIFY b1_Changed)
+    Q_PROPERTY(int b2 READ b2 WRITE set_b2 NOTIFY b2_Changed)
+    Q_PROPERTY(int b3 READ b3 WRITE set_b3 NOTIFY b3_Changed)
+
+public:
+    explicit IPv4Address(struct in_addr &addr, const Emitter &errHandler, QObject *pParent = 0);
+    virtual ~IPv4Address(void);
+
+private:
+    QString address(void) const;
+    int b0(void) const;
+    int b1(void) const;
+    int b2(void) const;
+    int b3(void) const;
+    
+    void set_address(const QString &addr);
+    void set_b0(int b);
+    void set_b1(int b);
+    void set_b2(int b);
+    void set_b3(int b);
+
+signals:
+	void address_Changed(const QString&);
+	void b0_Changed(int);
+	void b1_Changed(int);
+	void b2_Changed(int);
+	void b3_Changed(int);
+
+private:
+	struct in_addr &m_addr;
+	const Emitter &m_errHandler;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
 class Interface : public QObject
 {
     Q_OBJECT
@@ -21,14 +85,23 @@ class Interface : public QObject
     Q_PROPERTY(QString family READ family)
     Q_PROPERTY(QString method READ method)
 	// static
-    Q_PROPERTY(QString ipAddress READ ipAddress)
-    Q_PROPERTY(QString netMask READ netMask)
-    Q_PROPERTY(QString gateway READ gateway)
+    Q_PROPERTY(IPv4Address* ipAddress READ ipAddress)
+    Q_PROPERTY(IPv4Address* netMask READ netMask)
+    Q_PROPERTY(IPv4Address* gateway READ gateway)
+    Q_PROPERTY(IPv4Address* bcastAddress READ bcastAddress)
+    Q_PROPERTY(IPv4Address* ptpAddress READ ptpAddress)
+    Q_PROPERTY(QQmlListProperty<IPv4Address> dnsServer READ dnsServer)
+
+#if 0
     Q_PROPERTY(QStringList dnsServers READ dnsServers)
+#endif
+//    Q_PROPERTY(QString dns1 READ dns1)
+//    Q_PROPERTY(QString dns2 READ dns2)
+//    Q_PROPERTY(QString dns3 READ dns3)
     // dhcp
 
 public:
-    explicit Interface(ITF_IFACE_BLOCK &ifb, QObject *pParent = 0);
+    explicit Interface(ITF_IFACE_BLOCK &ifb, const Emitter &errHandler, QObject *pParent = 0);
     virtual ~Interface(void);
 
     inline const ITF_IFACE_BLOCK & getIface(void) const {
@@ -49,19 +122,38 @@ private:
     QString name(void) const;
     QString family(void) const;
     QString method(void) const;
-    QString ipAddress(void) const;
-    QString netMask(void) const;
-    QString gateway(void) const;
+    IPv4Address* ipAddress(void);
+    IPv4Address* netMask(void);
+    IPv4Address* gateway(void);
+    IPv4Address* bcastAddress(void);
+    IPv4Address* ptpAddress(void);
+    QQmlListProperty<IPv4Address> dnsServer(void);
+
+//    QString dns1(void) const;
+//    QString dns2(void) const;
+//    QString dns3(void) const;
+#if 0
     QStringList dnsServers(void) const;
+#endif
 
 private:
 	ITF_IFACE_BLOCK &m_ifb;
+	IPv4Address m_ipAddr;
+	IPv4Address m_netmask;
+	IPv4Address m_gateway;
+	IPv4Address m_bcastAddr;
+	IPv4Address m_ptpAddr;
+	QList<IPv4Address*> m_dnsList;
+	const Emitter &m_errHandler;
+#if 0
 	QStringList m_dnsList;
+	Nameservers m_dnsSvr;
+#endif
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
-class NetInterfaces : public QObject, public QQmlParserStatus
+class NetInterfaces : public QObject, public QQmlParserStatus, public Emitter
 {
     Q_OBJECT
     Q_INTERFACES(QQmlParserStatus)
@@ -73,10 +165,18 @@ public:
 public:
 	Q_INVOKABLE void reset(void);
 	Q_INVOKABLE bool initialize(void);
+	Q_INVOKABLE bool save(void);
+	Q_INVOKABLE bool save(QString path);
 	Q_INVOKABLE QVariantList getInterface(const QString &itfName);
 
 	virtual void classBegin();
 	virtual void componentComplete();
+	virtual void emitError(const char *pszFormatStr, ...) const;
+
+private:
+
+signals:
+	void sigError(QString msg) const;
 
 private:
 	ETC_NETWORK_INTERFACES m_eni;

qtplugin/netinterfaces_plugin.cpp

@@ -7,4 +7,5 @@ void NetInterfacesPlugin::registerTypes(const char *uri)
     // gfa.plugins.qml.net
     qmlRegisterType<NetInterfaces>(uri, 1, 0, "NetInterfaces");
     qmlRegisterUncreatableType<Interface>(uri, 1, 0, "Interface", "return type only");
+    qmlRegisterUncreatableType<IPv4Address>(uri, 1, 0, "IPv4Address", "return type only");
 }