Netzwerk-Editor und -Monitor.

README.md

@@ -27,6 +27,7 @@ libgfaqt.so (-lgfaqt)
 * QML-Wrapper für MySql-Info.
 * QML-Wrapper für Tiva/SPI-Info.
 * QML-Wrapper zur Netzwerk-Interface-Konfiguration.
+* QML-Wrapper für Netzwerk-Monitor.
 
 ---
 

src/qappctrl.cpp

@@ -111,6 +111,7 @@ void QGfaAppCtrl::RegisterQmlTypes(QQmlEngine &rEng, int nVerMajor, int nVerMino
 	qmlRegisterUncreatableType<QDhcp>("com.gfa.ipc.appctrl", nVerMajor, nVerMinor, "QDhcp", QStringLiteral("class not creatable in QML"));
 	qmlRegisterUncreatableType<QStatic>("com.gfa.ipc.appctrl", nVerMajor, nVerMinor, "QStatic", QStringLiteral("class not creatable in QML"));
 	qmlRegisterUncreatableType<QIPv4Address>("com.gfa.ipc.appctrl", nVerMajor, nVerMinor, "QIPv4Address", QStringLiteral("class not creatable in QML"));
+//	qmlRegisterUncreatableType<QQmlListProperty<QInterface>>("com.gfa.ipc.appctrl", nVerMajor, nVerMinor, "QQmlListProperty<QInterface>", QStringLiteral("class not creatable in QML"));
 
 	rEng.rootContext()->setContextProperty(QStringLiteral("qGfaAppCtrl"), this);
 }

src/qappctrl.h

@@ -16,6 +16,7 @@
 #include <qqmlparserstatus.h>
 #include <gfa/mutex.h>
 #include <gfa/gfanet.h>
+#include <gfa/gfanetmon.h>
 
 #ifdef __cplusplus
 
@@ -255,45 +256,46 @@ public:
 
 /////////////////////////////////////////////////////////////////////////////
 
+class QGfaNetInterfacesSchemaModel;
+
 typedef bool (*PFN_ADDRESS_VALIDATOR)(const struct in_addr &addr);
 
 class QIPv4Address : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QString address READ address WRITE setAddress NOTIFY addressChanged)
+    Q_PROPERTY(QVariant address READ address WRITE setAddress NOTIFY addressChanged)
     Q_PROPERTY(int b0 READ b0 WRITE setB0 NOTIFY b0Changed)
     Q_PROPERTY(int b1 READ b1 WRITE setB1 NOTIFY b1Changed)
     Q_PROPERTY(int b2 READ b2 WRITE setB2 NOTIFY b2Changed)
     Q_PROPERTY(int b3 READ b3 WRITE setB3 NOTIFY b3Changed)
-    Q_PROPERTY(double addr READ addr WRITE setAddr NOTIFY addrChanged)
-
+    Q_PROPERTY(QVariant addr READ addr WRITE setAddr NOTIFY addrChanged)
 
 public:
     explicit QIPv4Address(struct in_addr &addr, NotificationSink &notifyer, QObject *pParent = 0, PFN_ADDRESS_VALIDATOR pfnAddrValidator = NULL);
     virtual ~QIPv4Address(void);
+    void setAddr(const QVariant &val);
 
 private:
-    QString address(void) const;
+    QVariant address(void) const;
     int b0(void) const;
     int b1(void) const;
     int b2(void) const;
     int b3(void) const;
-    double addr(void) const;
+    QVariant addr(void) const;
     
-    void setAddress(const QString &addr);
+    void setAddress(const QVariant &addr);
     void setB0(int b);
     void setB1(int b);
     void setB2(int b);
     void setB3(int b);
-    void setAddr(double val);
 
 signals:
-	void addressChanged(const QString&);
+	void addressChanged(const QVariant&);
 	void b0Changed(int);
 	void b1Changed(int);
 	void b2Changed(int);
 	void b3Changed(int);
-	void addrChanged(double);
+	void addrChanged(const QVariant&);
 
 private:
 	struct in_addr &m_addr;
@@ -303,6 +305,8 @@ private:
 
 /////////////////////////////////////////////////////////////////////////////
 
+Q_DECLARE_METATYPE(QQmlListProperty<QIPv4Address>)
+
 class QStatic : public QObject
 {
     Q_OBJECT
@@ -335,7 +339,7 @@ private:
     void setNetPrefix(int netprefix);
 
 private slots:
-    void netmaskChanged(const QString&);
+    void netmaskChanged(const QVariant&);
 
 signals:
 	void metricChanged(int metric);
@@ -358,13 +362,23 @@ private:
 class QDhcp : public QObject
 {
     Q_OBJECT
+    Q_PROPERTY(QIPv4Address* ipAddress READ ipAddress CONSTANT)
+    Q_PROPERTY(QIPv4Address* netMask READ netMask CONSTANT)
 
 public:
     explicit QDhcp(IFACE_INET_DHCP &itfd, NotificationSink &notifyer, QObject *pParent = 0);
     virtual ~QDhcp(void);
+    
+    void setDynamicAddr(const struct in_addr &addr, const struct in_addr &mask, bool bDelete);
+
+private:
+    QIPv4Address* ipAddress(void);
+    QIPv4Address* netMask(void);
 
 private:
 	IFACE_INET_DHCP &m_itfd;
+	QIPv4Address m_ipAddr;	// dynamic address
+	QIPv4Address m_netmask;	// dynamic mask
 	NotificationSink &m_rNotifyer;
 };
 
@@ -380,7 +394,7 @@ public:
     explicit QInet(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent = 0);
     virtual ~QInet(void);
 
-private:
+public:
     QStatic* stat(void);
     QDhcp* dhcp(void);
 
@@ -395,13 +409,25 @@ private:
 class QInterface : public QObject
 {
     Q_OBJECT
+    Q_PROPERTY(QInet* inet READ inet CONSTANT)
     Q_PROPERTY(QString name READ name CONSTANT)
     Q_PROPERTY(QString afName READ afName NOTIFY afNameChanged)
-    Q_PROPERTY(int af READ af WRITE setAf NOTIFY afChanged)
+    Q_PROPERTY(QString inherits READ inherits CONSTANT)
+    Q_PROPERTY(QVariant af READ af WRITE setAf NOTIFY afChanged)
     Q_PROPERTY(QString methodName READ methodName NOTIFY methodNameChanged)
     Q_PROPERTY(int method READ method WRITE setMethod NOTIFY methodChanged)
     Q_PROPERTY(int selCfg READ selCfg WRITE setSelCfg NOTIFY selCfgChanged)
-    Q_PROPERTY(QInet* inet READ inet CONSTANT)
+    Q_PROPERTY(QVariant macAddr READ macAddr NOTIFY macAddrChanged)
+    Q_PROPERTY(QVariant up READ up NOTIFY upChanged)
+    Q_PROPERTY(QVariant running READ running NOTIFY runningChanged)
+    Q_PROPERTY(QVariant txPacket READ txPacket NOTIFY txPacketChanged)
+    Q_PROPERTY(QVariant rxPacket READ rxPacket NOTIFY rxPacketChanged)
+    Q_PROPERTY(QVariant txByte READ txByte NOTIFY txByteChanged)
+    Q_PROPERTY(QVariant rxByte READ rxByte NOTIFY rxByteChanged)
+    Q_PROPERTY(QVariant rxErrors READ rxErrors NOTIFY rxErrorsChanged)
+    Q_PROPERTY(QVariant txErrors READ txErrors NOTIFY txErrorsChanged)
+    Q_PROPERTY(QVariant rxDropped READ rxDropped NOTIFY rxDroppedChanged)
+    Q_PROPERTY(QVariant txDropped READ txDropped NOTIFY txDroppedChanged)
 
 public:
     explicit QInterface(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent = 0);
@@ -422,6 +448,8 @@ public:
     inline const char * getName(void) const {
 	    return m_ifb.cfgName.c_str();}
 
+	void onNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts);
+
 	enum AddressFamily
 	{
 		AF_Unknown	= 0,
@@ -465,59 +493,113 @@ public:
 private:
     QString name(void) const;
     QString afName(void) const;
-    int af(void) const;
-    void setAf(int af);
+    QVariant af(void) const;
+    void setAf(const QVariant &val);
+    QString inherits(void) const;
     QString methodName(void) const;
     int method(void) const;
     void setMethod(int method);
     int selCfg(void) const;
     void setSelCfg(int cfg);
     QInet* inet(void);
+    QVariant up(void) const;
+    void setUp(bool up);
+    QVariant running(void) const;
+    void setRunning(bool running);
+    QVariant txPacket(void) const;
+    void setTxPacket(const QVariant &val, bool bDelete);
+    QVariant rxPacket(void) const;
+    void setRxPacket(const QVariant &val, bool bDelete);
+    QVariant txByte(void) const;
+    void setTxByte(const QVariant &val, bool bDelete);
+    QVariant rxByte(void) const;
+    void setRxByte(const QVariant &val, bool bDelete);
+    QVariant rxErrors(void) const;
+    void setRxErrors(const QVariant &val, bool bDelete);
+    QVariant txErrors(void) const;
+    void setTxErrors(const QVariant &val, bool bDelete);
+    QVariant rxDropped(void) const;
+    void setRxDropped(const QVariant &val, bool bDelete);
+    QVariant txDropped(void) const;
+    void setTxDropped(const QVariant &val, bool bDelete);
+    QVariant macAddr(void) const;
+    void setMacAddr(const unsigned char *mac, size_t nCbMac, bool bDelete);
 
 signals:
 	void afNameChanged(void);
-	void afChanged(int af);
+	void afChanged(const QVariant &val);
 	void methodNameChanged(void);
 	void methodChanged(int method);
 	void selCfgChanged(int cfg);
+	void upChanged(const QVariant &val);
+	void runningChanged(const QVariant &val);
+	void txPacketChanged(const QVariant &val);
+	void rxPacketChanged(const QVariant &val);
+	void txByteChanged(const QVariant &val);
+	void rxByteChanged(const QVariant &val);
+	void rxErrorsChanged(const QVariant &val);
+	void txErrorsChanged(const QVariant &val);
+	void rxDroppedChanged(const QVariant &val);
+	void txDroppedChanged(const QVariant &val);
+	void macAddrChanged(const QVariant &val);
 
 private:
 	ITF_IFACE_BLOCK &m_ifb;
 	QInet m_inet;
 	NotificationSink &m_rNotifyer;
 	int m_selCfg;
+	qint64 m_nRxPacket;
+	qint64 m_nTxPacket;
+	qint64 m_nRxByte;
+	qint64 m_nTxByte;
+	qint64 m_nRxErrors;
+	qint64 m_nTxErrors;
+	qint64 m_nRxDropped;
+	qint64 m_nTxDropped;
+	unsigned char m_szMacAddr[ETH_ALEN];
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
-class QGfaNetInterfacesSchemaTreeItem
+class QGfaNetInterfacesSchemaTreeItem : public QObject
 {
+    Q_OBJECT
+
+	typedef QVariant (*PFN_FORMATTED_VALUE)(const QVariant &raw);
+
 public:
-	explicit QGfaNetInterfacesSchemaTreeItem(QGfaNetInterfacesSchemaTreeItem *pParentItem = NULL);
-	QGfaNetInterfacesSchemaTreeItem(const QVariant &name, const QVariant &data, const QVariant &dataF, QGfaNetInterfacesSchemaTreeItem *parentItem);
+	QGfaNetInterfacesSchemaTreeItem(QGfaNetInterfacesSchemaModel &model, const QVariant &name = QVariant(), const QVariant &data = QVariant(), PFN_FORMATTED_VALUE pfnFmtVal = NULL, QGfaNetInterfacesSchemaTreeItem *pParentItem = NULL);
 	~QGfaNetInterfacesSchemaTreeItem(void);
 
 	void appendChild(QGfaNetInterfacesSchemaTreeItem *child);
 	void clear(void);
 
 	QGfaNetInterfacesSchemaTreeItem *child(int row);
-	QGfaNetInterfacesSchemaTreeItem *getChildItemByName(const char *pszName);
 	int childCount() const;
 	int columnCount() const;
 	QVariant data(int column) const;
 	int row() const;
 	QGfaNetInterfacesSchemaTreeItem *parentItem();
-	int compareValue(const QVariant &val) const;
-	bool updateValue(const QVariant &val, const QVariant &valF = QVariant());
+	QModelIndex index(void);
+	bool updateValue(const QVariant &val);
+	void setIndex(const QModelIndex &index);
 
+private slots:
+	void onValueChanged(const QVariant &val);
+	
 private:
 	QVector<QGfaNetInterfacesSchemaTreeItem*> m_childItems;
 	QVector<QVariant> m_itemData;
 	QGfaNetInterfacesSchemaTreeItem *m_parentItem;
+	QGfaNetInterfacesSchemaModel &m_model;
+	QModelIndex m_index;
+	PFN_FORMATTED_VALUE m_pfnFmtVal;
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
+class QNetworkInterfaces;
+
 class QGfaNetInterfacesSchemaModel : public QAbstractItemModel
 {
     Q_OBJECT
@@ -543,10 +625,20 @@ public:
 	int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
 	int columnCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
 	QHash<int, QByteArray> roleNames() const Q_DECL_OVERRIDE;
-
-	void setModelData(LPETC_NETWORK_INTERFACES pnif);
+	QObject* getChildObject(QObject *parent, std::vector<const char*> childNames);
+	void setModelData(QObject *pifs);
 	void clearAll(void);
 
+public:
+	static QVariant boolToString(const QVariant &val);
+	static QVariant ipV4String(const QVariant &val);
+	static QVariant afToString(const QVariant &val);
+	static QVariant methodToString(const QVariant &val);
+	static QVariant formatByteSize(const QVariant &val);
+	static int qVariantStrLen(const QVariant &val);
+	static bool qVariantInt(const QVariant &val, int &nVal);
+	static bool qVariantUInt(const QVariant &val, unsigned int &nVal);
+
 private:
     QGfaNetInterfacesSchemaTreeItem *m_pRootItem;
     QHash<int, QByteArray> m_roleNameMapping;
@@ -554,6 +646,8 @@ private:
 
 /////////////////////////////////////////////////////////////////////////////
 
+Q_DECLARE_METATYPE(QQmlListProperty<QInterface>)
+
 class QNetworkInterfaces :	public QObject,
 							public QQmlParserStatus,
 							public NotificationSink
@@ -567,7 +661,7 @@ class QNetworkInterfaces :	public QObject,
     Q_PROPERTY(int itfFilterMethod READ itfFilterMethod WRITE setItfFilterMethod NOTIFY itfFilterMethodChanged)
     Q_PROPERTY(bool ifUpDownInProgress READ ifUpDownInProgress CONSTANT)
     Q_PROPERTY(QGfaNetInterfacesSchemaModel *schemaModel READ schemaModel CONSTANT)
-
+    
 public:
     explicit QNetworkInterfaces(QObject *pParent = 0);
     virtual ~QNetworkInterfaces(void);
@@ -634,12 +728,15 @@ private:
 	int itfFilterMethod(void) const;
 	void setItfFilterMethod(int method);
 	bool ifUpDownInProgress(void) const;
+	void onNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts);
+	QInterface* GetInterfaceByName(const char *pszName);
 
     static void onIfUpDown(const char *pszMsg, void *pCtx);
     static void onIfUpCompleted(int nExitCode, void *pCtx);
     static void onIfDownCompleted(int nExitCode, void *pCtx);
     static void onIfRestartCompleted(int nExitCode, void *pCtx);
-
+	static void onStaticNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts, void *pParam);
+	
 	QGfaNetInterfacesSchemaModel* schemaModel(void);
 
 private:
@@ -654,8 +751,11 @@ private:
 	pid_t m_ifUpDownPid;
 	CLocalMutex m_mutex;
 	QGfaNetInterfacesSchemaModel m_netInterfacesSchemaModel;
+	CGfaNetMon m_netMon;
 };
 
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
 class QTivaInfo : public QObject

src/qnetworkinfo.cpp

@@ -1,6 +1,7 @@
+#include <QJsonObject>
 #include "qappctrl.h"
-//#include "helpers.h"
 #include "defines.h"
+#include "helpers.h"
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
@@ -10,6 +11,8 @@
 #define _countof(a)					(sizeof(a) / sizeof(*a))
 #endif	//	_countof
 
+#define _PREFIX_TO_MASK(pf)			htonl(~((1 << (32 - (pf))) - 1))
+
 /////////////////////////////////////////////////////////////////////////////
 
 typedef struct _SCHEMA_MODEL_ROLES
@@ -97,17 +100,21 @@ static bool _IsValidNetmask(const struct in_addr &in)
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
-/////////////////////////////////////////////////////////////////////////////
-
-QGfaNetInterfacesSchemaTreeItem::QGfaNetInterfacesSchemaTreeItem(QGfaNetInterfacesSchemaTreeItem *pParentItem) : m_parentItem(pParentItem)
-{
-}
-
-QGfaNetInterfacesSchemaTreeItem::QGfaNetInterfacesSchemaTreeItem(const QVariant &name, const QVariant &data, const QVariant &dataF, QGfaNetInterfacesSchemaTreeItem *pParentItem) : m_parentItem(pParentItem)
+QGfaNetInterfacesSchemaTreeItem::QGfaNetInterfacesSchemaTreeItem(QGfaNetInterfacesSchemaModel &model, const QVariant &name, const QVariant &data, PFN_FORMATTED_VALUE pfnFmtVal, QGfaNetInterfacesSchemaTreeItem *pParentItem) :
+																																								m_parentItem(pParentItem),
+																																								m_model(model),
+																																								m_pfnFmtVal(pfnFmtVal)
 {
-	m_itemData.append(name);
-	m_itemData.append(data);
-	m_itemData.append(dataF.isValid() ? dataF : data);
+	if(name.isValid())
+	{
+		m_itemData.append(name);
+		
+		if(data.isValid())
+		{
+			m_itemData.append(data);
+			m_itemData.append(m_pfnFmtVal ? (*m_pfnFmtVal)(data) : data);
+		}
+	}
 }
 
 QGfaNetInterfacesSchemaTreeItem::~QGfaNetInterfacesSchemaTreeItem(void)
@@ -165,58 +172,21 @@ int QGfaNetInterfacesSchemaTreeItem::row() const
     return 0;
 }
 
-QGfaNetInterfacesSchemaTreeItem* QGfaNetInterfacesSchemaTreeItem::getChildItemByName(const char *pszName)
-{
-	for(QGfaNetInterfacesSchemaTreeItem* pItem : m_childItems)
-	{
-		QVariant name = pItem->data(0);
-
-		if(name.isValid())
-		{
-			if(name == QVariant(pszName))
-				return pItem;
-		}
-	}
-
-	return NULL;
-}
-
-int QGfaNetInterfacesSchemaTreeItem::compareValue(const QVariant &val) const
-{
-	if((m_itemData.size() >= 3) && val.isValid())
-	{
-		if(m_itemData[1].type() == val.type())
-			return !(m_itemData[1] == val);
-	}
-
-	return 1;
-}
-
-bool QGfaNetInterfacesSchemaTreeItem::updateValue(const QVariant &val, const QVariant &valF)
+bool QGfaNetInterfacesSchemaTreeItem::updateValue(const QVariant &val)
 {
 	bool bUpdated = false;
 
 	if(m_itemData.size() >= 3)
 	{
+		QModelIndex idx = index();
+
 		if(val.isValid())
 		{
 			if(m_itemData[1] != val)
 			{
 				m_itemData[1] = val;
-				bUpdated = true;
-			}
-
-			if(valF.isValid())
-			{
-				if(m_itemData[2] != valF)
-				{
-					m_itemData[2] = valF;
-					bUpdated = true;
-				}
-			}
-			else if(m_itemData[2] != val)
-			{
-				m_itemData[2] = val;
+				m_itemData[2] = m_pfnFmtVal ? (*m_pfnFmtVal)(val) : val;
+				emit m_model.dataChanged(idx, idx, QVector<int>());
 				bUpdated = true;
 			}
 		}
@@ -231,13 +201,28 @@ bool QGfaNetInterfacesSchemaTreeItem::updateValue(const QVariant &val, const QVa
 	return bUpdated;
 }
 
+void QGfaNetInterfacesSchemaTreeItem::setIndex(const QModelIndex &index)
+{
+	m_index = index;
+}
+
+QModelIndex QGfaNetInterfacesSchemaTreeItem::index(void)
+{
+	return m_index;
+}
+
+void QGfaNetInterfacesSchemaTreeItem::onValueChanged(const QVariant &val)
+{
+	updateValue(val);
+}
+
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
 QGfaNetInterfacesSchemaModel::QGfaNetInterfacesSchemaModel(QObject *pParent) : QAbstractItemModel(pParent)
 {
-	m_pRootItem = new QGfaNetInterfacesSchemaTreeItem();
+	m_pRootItem = new QGfaNetInterfacesSchemaTreeItem(*this);
 
 	for(size_t i = 0; i < _countof(g_roles); ++i)
 	{
@@ -308,7 +293,11 @@ QModelIndex QGfaNetInterfacesSchemaModel::index(int row, int column, const QMode
 
 	QGfaNetInterfacesSchemaTreeItem *pChildItem = pParentItem->child(row);
 	if(pChildItem)
-		return createIndex(row, column, pChildItem);
+	{
+		QModelIndex index = createIndex(row, column, pChildItem);
+		pChildItem->setIndex(index);
+		return index;
+	}
 	return QModelIndex();
 }
 
@@ -362,6 +351,24 @@ QHash<int, QByteArray> QGfaNetInterfacesSchemaModel::roleNames() const
 
 /////////////////////////////////////////////////////////////////////////////
 
+QObject* QGfaNetInterfacesSchemaModel::getChildObject(QObject *parent, std::vector<const char*> childNames)
+{
+	QObject *obj = NULL;
+
+	if(parent && !childNames.empty())
+	{
+		obj = parent;
+		
+		for(const char *pszChild : childNames)
+		{
+			obj = qvariant_cast<QObject*>(obj->property(pszChild));
+		}
+	}
+
+	return obj;
+}
+
+#if 0
 void QGfaNetInterfacesSchemaModel::setModelData(LPETC_NETWORK_INTERFACES pnif)
 {
 	int i;
@@ -398,6 +405,16 @@ void QGfaNetInterfacesSchemaModel::setModelData(LPETC_NETWORK_INTERFACES pnif)
 			QGfaNetInterfacesSchemaTreeItem *pTmpTi = new QGfaNetInterfacesSchemaTreeItem("Inherits", ifb.inherits.c_str(), QVariant(), pNiTi);
 			pNiTi->appendChild(pTmpTi);
 		}
+		
+		{
+			QGfaNetInterfacesSchemaTreeItem *pTmpTi = new QGfaNetInterfacesSchemaTreeItem("Up", ifb.up, ifb.up ? "yes" : "no", pNiTi);
+			pNiTi->appendChild(pTmpTi);
+		}
+		
+		{
+			QGfaNetInterfacesSchemaTreeItem *pTmpTi = new QGfaNetInterfacesSchemaTreeItem("Running", ifb.running, ifb.running ? "yes" : "no", pNiTi);
+			pNiTi->appendChild(pTmpTi);
+		}
 
 		if(ifb.method == IFM_Static)
 		{
@@ -571,6 +588,349 @@ void QGfaNetInterfacesSchemaModel::setModelData(LPETC_NETWORK_INTERFACES pnif)
 
 	endResetModel();
 }
+#endif
+
+void QGfaNetInterfacesSchemaModel::setModelData(QObject *pifs)
+{
+	beginResetModel();
+	m_pRootItem->clear();
+
+	QQmlListProperty<QInterface> itfs = qvariant_cast<QQmlListProperty<QInterface>>(pifs->property("interfaces"));
+	
+	for(int i = 0; i < itfs.count(&itfs); ++i)
+	{
+		QObject *pif = static_cast<QObject*>(itfs.at(&itfs, i));
+
+		if(pif)
+		{
+			QVariant vTmp;
+			QGfaNetInterfacesSchemaTreeItem *pNiTi, *pStats, *pTmpTi;
+
+			pNiTi = new QGfaNetInterfacesSchemaTreeItem(*this, pif->property("name"), pif->property("method"), &QGfaNetInterfacesSchemaModel::methodToString, m_pRootItem);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "MAC-Addr.", pif->property("macAddr"), NULL, pNiTi);
+			QObject::connect(pif, SIGNAL(macAddrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pNiTi->appendChild(pTmpTi);
+
+			vTmp = pif->property("inherits");
+			if(qVariantStrLen(vTmp) > 0)
+			{
+				pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Inherits", vTmp, NULL, pNiTi);
+				pNiTi->appendChild(pTmpTi);
+			}
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Up", pif->property("up"), &QGfaNetInterfacesSchemaModel::boolToString, pNiTi);
+			QObject::connect(pif, SIGNAL(upChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pNiTi->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Running", pif->property("running"), &QGfaNetInterfacesSchemaModel::boolToString, pNiTi);
+			QObject::connect(pif, SIGNAL(runningChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pNiTi->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Addr. Family", pif->property("af"), &QGfaNetInterfacesSchemaModel::afToString, pNiTi);
+			QObject::connect(pif, SIGNAL(afChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pNiTi->appendChild(pTmpTi);
+
+			QInterface::ItfMethod method = (QInterface::ItfMethod)pif->property("method").toInt();
+			QInterface::AddressFamily af = (QInterface::AddressFamily)pif->property("af").toInt();
+
+			if(method == QInterface::IM_Dhcp)
+			{
+				if(af == QInterface::AF_Inet)
+				{
+					int nTmp;
+					QObject *pDhcp, *pAddr;
+					
+					if((pDhcp = getChildObject(pif, {"inet", "dhcp"})))
+					{
+						if((pAddr = getChildObject(pDhcp, {"ipAddress"})))
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Address", pAddr->property("addr"), &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+							QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						if((pAddr = getChildObject(pDhcp, {"netMask"})))
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Netmask", pAddr->property("addr"), &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+							QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("leasetime");
+						if(qVariantInt(vTmp, nTmp) && nTmp >= 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Lease Time", nTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("leasehours");
+						if(qVariantInt(vTmp, nTmp) && nTmp >= 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Lease Hours", nTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("metric");
+						if(qVariantInt(vTmp, nTmp) && nTmp >= 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Metric", nTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("hostname");
+						if(qVariantStrLen(vTmp) > 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Hostname", vTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("vendor");
+						if(qVariantStrLen(vTmp) > 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Vendor", vTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+
+						vTmp = pDhcp->property("client");
+						if(qVariantStrLen(vTmp) > 0)
+						{
+							pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Client", vTmp, NULL, pNiTi);
+							pNiTi->appendChild(pTmpTi);
+						}
+					}
+				}
+			}
+			else if(method == QInterface::IM_Static)
+			{
+				if(af == QInterface::AF_Inet)
+				{
+					int nTmp;
+					unsigned int nUTmp;
+					QObject *pStatic, *pAddr;
+					
+					if((pStatic = getChildObject(pif, {"inet", "stat"})))
+					{
+						if((pAddr = getChildObject(pStatic, {"ipAddress"})))
+						{
+							vTmp = pAddr->property("addr");
+							if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+							{
+								pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Address", vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+								QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+								pNiTi->appendChild(pTmpTi);
+							}
+						}
+
+						if((pAddr = getChildObject(pStatic, {"netMask"})))
+						{
+							vTmp = pAddr->property("addr");
+							if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+							{
+								pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Netmask", vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+								QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+								pNiTi->appendChild(pTmpTi);
+							}
+						}
+
+						if((pAddr = getChildObject(pStatic, {"gateway"})))
+						{
+							vTmp = pAddr->property("addr");
+							if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+							{
+								pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Gateway", vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+								QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+								pNiTi->appendChild(pTmpTi);
+							}
+						}
+
+						if((pAddr = getChildObject(pStatic, {"bcastAddress"})))
+						{
+							vTmp = pAddr->property("addr");
+							if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+							{
+								pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "Broadcast", vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+								QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+								pNiTi->appendChild(pTmpTi);
+							}
+						}
+
+						if((pAddr = getChildObject(pStatic, {"ptpAddress"})))
+						{
+							vTmp = pAddr->property("addr");
+							if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+							{
+								pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "PointToPoint", vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pNiTi);
+								QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+								pNiTi->appendChild(pTmpTi);
+							}
+						}
+
+						QQmlListProperty<QIPv4Address> dns = qvariant_cast<QQmlListProperty<QIPv4Address>>(pStatic->property("dnsServer"));
+
+						if((nTmp = dns.count(&dns)) > 0)
+						{
+							int nCntDns = 0;
+							QGfaNetInterfacesSchemaTreeItem *pDns = new QGfaNetInterfacesSchemaTreeItem(*this, "DNS Server", QVariant(), NULL, pNiTi);
+
+							for(int i = 0; i < nTmp; ++i)
+							{
+								if((pAddr = static_cast<QObject*>(dns.at(&dns, i))))
+								{
+									vTmp = pAddr->property("addr");
+									if(qVariantUInt(vTmp, nUTmp) && nUTmp != INADDR_ANY)
+									{
+										char szDns[16];
+										sprintf(szDns, "DNS %d", ++nCntDns);
+										pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, szDns, vTmp, &QGfaNetInterfacesSchemaModel::ipV4String, pDns);
+										QObject::connect(pAddr, SIGNAL(addrChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+										pDns->appendChild(pTmpTi);
+									}
+								}
+							}
+
+							if(nCntDns)
+								pNiTi->appendChild(pDns);
+							else
+								delete pDns;
+						}
+					}
+				}
+			}
+			else if(method == QInterface::IM_Manual)
+			{
+				if(af == QInterface::AF_Inet)
+				{
+				}
+			}
+
+			pStats = new QGfaNetInterfacesSchemaTreeItem(*this, "Stats", QVariant(), NULL, pNiTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "RX Packets", pif->property("rxPacket"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(rxPacketChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "TX Packets", pif->property("txPacket"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(txPacketChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "RX Bytes", pif->property("rxByte"), &QGfaNetInterfacesSchemaModel::formatByteSize, pStats);
+			QObject::connect(pif, SIGNAL(rxByteChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "TX Bytes", pif->property("txByte"), &QGfaNetInterfacesSchemaModel::formatByteSize, pStats);
+			QObject::connect(pif, SIGNAL(txByteChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "RX Errors", pif->property("rxErrors"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(rxErrorsChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "TX Errors", pif->property("txErrors"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(txErrorsChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "RX Dropped", pif->property("rxDropped"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(rxDroppedChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pTmpTi = new QGfaNetInterfacesSchemaTreeItem(*this, "TX Dropped", pif->property("txDropped"), NULL, pStats);
+			QObject::connect(pif, SIGNAL(txDroppedChanged(const QVariant&)), pTmpTi, SLOT(onValueChanged(const QVariant&)));
+			pStats->appendChild(pTmpTi);
+
+			pNiTi->appendChild(pStats);
+			m_pRootItem->appendChild(pNiTi);
+		}
+	}
+
+	endResetModel();
+}
+
+QVariant QGfaNetInterfacesSchemaModel::boolToString(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::Bool))
+		return val.toBool() ? "✓" : "-";
+	return "error";
+}
+
+QVariant QGfaNetInterfacesSchemaModel::ipV4String(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::UInt))
+	{
+		struct in_addr addr{::htonl(val.toUInt())};
+		return addr.s_addr ? ::inet_ntoa(addr) : "-";
+	}
+	return "error";
+}
+
+QVariant QGfaNetInterfacesSchemaModel::afToString(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::Int))
+	{
+		const char *pszProto;
+		int proto = val.toInt();
+		switch(proto)
+		{
+		case QInterface::AF_Inet:
+			pszProto = "IPv4";
+			break;
+		case QInterface::AF_Inet6:
+			pszProto = "IPv6";
+			break;
+		default:
+			pszProto = ::GetIfaceProtoStr((IfaceProtos)_ENUM_TO_FLAG(proto));
+			break;
+		}
+		if(pszProto && *pszProto)
+			return pszProto;
+	}
+	return "error";
+}
+
+QVariant QGfaNetInterfacesSchemaModel::methodToString(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::Int))
+	{
+		return ::GetIfaceMethodStr((IfaceMethods)_FLAG_TO_ENUM(val.toInt()));
+	}
+	return "error";
+}
+
+QVariant QGfaNetInterfacesSchemaModel::formatByteSize(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::ULongLong))
+	{
+		return ::FormatByteSize(val.toULongLong(), false, 1);
+	}
+	return "error";
+}
+
+int QGfaNetInterfacesSchemaModel::qVariantStrLen(const QVariant &val)
+{
+	if(val.isValid() && val.canConvert(QMetaType::QString))
+		return val.toString().length();
+	return -1;
+}
+
+bool QGfaNetInterfacesSchemaModel::qVariantInt(const QVariant &val, int &nVal)
+{
+	if(val.isValid() && val.canConvert(QMetaType::Int))
+	{
+		nVal = val.toInt();
+		return true;
+	}
+	return false;
+}
+
+bool QGfaNetInterfacesSchemaModel::qVariantUInt(const QVariant &val, unsigned int &nVal)
+{
+	if(val.isValid() && val.canConvert(QMetaType::UInt))
+	{
+		nVal = val.toUInt();
+		return true;
+	}
+	return false;
+}
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
@@ -610,6 +970,7 @@ void QNetworkInterfaces::componentComplete()
 void QNetworkInterfaces::reset(void)
 {
 	QInterface *pItf;
+	m_netMon.Close();
 
     for(int i = 0; i < m_interfaces.count(); i++)
     {
@@ -636,10 +997,14 @@ bool QNetworkInterfaces::initialize(void)
 			m_interfaces.append(new QInterface(ibl, static_cast<NotificationSink&>(*this), this));
 		}
 
-		m_netInterfacesSchemaModel.setModelData(&m_eni);
+//		m_netInterfacesSchemaModel.setModelData(&m_eni);
+		m_netInterfacesSchemaModel.setModelData(this);
 
 		emit interfacesChanged();
 		emit filteredInterfacesChanged();
+
+		m_netMon.Init();
+		m_netMon.StartMonitor(&QNetworkInterfaces::onStaticNetmonEvent, this);
 	}
 
 	return bRet;
@@ -651,7 +1016,8 @@ bool QNetworkInterfaces::save(void)
 	if(	::WriteEtcNetworkInterfaces(m_eni, NULL) &&
 		initialize())
 	{
-		m_netInterfacesSchemaModel.setModelData(&m_eni);
+//		m_netInterfacesSchemaModel.setModelData(&m_eni);
+		m_netInterfacesSchemaModel.setModelData(this);
 		return true;
 	}
 	return false;
@@ -666,7 +1032,8 @@ bool QNetworkInterfaces::saveAs(const QString &path)
 	if(	::WriteEtcNetworkInterfaces(m_eni, pszPath) &&
 		initialize())
 	{
-		m_netInterfacesSchemaModel.setModelData(&m_eni);
+//		m_netInterfacesSchemaModel.setModelData(&m_eni);
+		m_netInterfacesSchemaModel.setModelData(this);
 		return true;
 	}
 	return false;
@@ -677,7 +1044,8 @@ bool QNetworkInterfaces::reload(void)
     m_netInterfacesSchemaModel.clearAll();
 	if(initialize())
 	{
-		m_netInterfacesSchemaModel.setModelData(&m_eni);
+//		m_netInterfacesSchemaModel.setModelData(&m_eni);
+		m_netInterfacesSchemaModel.setModelData(this);
 	    return true;
 	}
 	return false;
@@ -992,7 +1360,6 @@ bool QNetworkInterfaces::cancelStartStopInterface(void)
 	bool bCancel = GetIfUpDownInProgress() && (pid != -1);
 	if(bCancel)
 	{
-//		bCancel = !kill(-pid, SIGKILL);
 		bCancel = !system("killall -SIGTERM ifup");
 	}
 	m_mutex.Unlock();
@@ -1101,6 +1468,19 @@ int QNetworkInterfaces::getInterfaceSelConfig(QInterface &ri)
 	return mask;
 }
 
+QInterface* QNetworkInterfaces::GetInterfaceByName(const char *pszName)
+{
+	if(pszName && *pszName)
+	{
+		for(QInterface *pif : m_interfaces)
+		{
+			if(!strcmp(pszName, pif->getName()))
+				return pif;
+		}
+	}
+	return NULL;
+}
+
 bool QNetworkInterfaces::ifUpDownInProgress(void) const
 {
 	return m_bIfUpDownInProgress;
@@ -1111,14 +1491,60 @@ QGfaNetInterfacesSchemaModel* QNetworkInterfaces::schemaModel(void)
 	return &m_netInterfacesSchemaModel;
 }
 
+void QNetworkInterfaces::onNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts)
+{
+	QInterface *pif = NULL;
+
+	if(!pData)
+		return;
+
+	switch(nEvtType)
+	{
+	case RTM_NEWLINK:
+	case RTM_DELLINK:
+		if(nMaxAtts > IFLA_IFNAME)
+			pif = GetInterfaceByName((const char*)pAtts[IFLA_IFNAME].pData);
+		break;
+	case RTM_NEWADDR:
+	case RTM_DELADDR:
+		if(nMaxAtts > IFA_LABEL)
+			pif = GetInterfaceByName((const char*)pAtts[IFA_LABEL].pData);
+		break;
+	case RTM_NEWROUTE:
+	case RTM_DELROUTE:
+		// not implemented!
+		break;
+	}
+	
+	if(pif)
+	{
+		pif->onNetmonEvent(nEvtType, pData, pAtts, nMaxAtts);
+	}
+}
+
+void QNetworkInterfaces::onStaticNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts, void *pParam)
+{
+	QNetworkInterfaces *pThis = (QNetworkInterfaces*)pParam;
+	pThis->onNetmonEvent(nEvtType, pData, pAtts, nMaxAtts);
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 QInterface::QInterface(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent) : 	QObject(pParent),
 																								m_ifb(ifb),
 																								m_inet(ifb, notifyer, this),
 																								m_rNotifyer(notifyer),
-																								m_selCfg(notifyer.getInterfaceSelConfig(*this))
-{
+																								m_selCfg(notifyer.getInterfaceSelConfig(*this)),
+																								m_nRxPacket(0ULL),
+																								m_nTxPacket(0ULL),
+																								m_nRxByte(0ULL),
+																								m_nTxByte(0ULL),
+																								m_nRxErrors(0ULL),
+																								m_nTxErrors(0ULL),
+																								m_nRxDropped(0ULL),
+																								m_nTxDropped(0ULL)
+{
+	memset(m_szMacAddr, 0, sizeof(m_szMacAddr));
 	setObjectName("QInterface");
 }
 
@@ -1136,30 +1562,40 @@ QString QInterface::afName(void) const
 	return ::GetIfaceProtoStr(m_ifb.proto);
 }
 
-int QInterface::af(void) const
+QVariant QInterface::af(void) const
 {
 	return (int)_ENUM_TO_FLAG(m_ifb.proto);
 }
 
-void QInterface::setAf(int af)
+void QInterface::setAf(const QVariant &val)
 {
-	if(!_IsPowerOf2(af) || (af < QInterface::AF_Unknown) || (af >= QInterface::AF_Invalid))
+	if(val.canConvert(QMetaType::Int))
 	{
-		m_rNotifyer.reportError("Invalid address family: %d!", af);
-		return;
-	}
+		int af = val.toInt();
+
+		if(!_IsPowerOf2(af) || (af < QInterface::AF_Unknown) || (af >= QInterface::AF_Invalid))
+		{
+			m_rNotifyer.reportError("Invalid address family: %d!", af);
+			return;
+		}
 
-	IfaceProtos proto = (IfaceProtos)_FLAG_TO_ENUM(af);
+		IfaceProtos proto = (IfaceProtos)_FLAG_TO_ENUM(af);
 
-	if(m_ifb.proto != proto)
-	{
-		m_ifb.proto = proto;
-		emit afChanged(af);
-		emit afNameChanged();
-		m_rNotifyer.filterPropertyChanged();
+		if(m_ifb.proto != proto)
+		{
+			m_ifb.proto = proto;
+			emit afChanged(af);
+			emit afNameChanged();
+			m_rNotifyer.filterPropertyChanged();
+		}
 	}
 }
 
+QString QInterface::inherits(void) const
+{
+	return m_ifb.inherits.c_str();
+}
+
 QString QInterface::methodName(void) const
 {
 	return ::GetIfaceMethodStr(m_ifb.method);
@@ -1216,6 +1652,342 @@ QInet* QInterface::inet(void)
 	return &m_inet;
 }
 
+QVariant QInterface::up(void) const
+{
+	return m_ifb.up;
+}
+
+void QInterface::setUp(bool up)
+{
+	if(m_ifb.up != up)
+	{
+		m_ifb.up = up;
+		emit upChanged(m_ifb.up);
+	}
+}
+
+QVariant QInterface::running(void) const
+{
+	return m_ifb.running;
+}
+
+void QInterface::setRunning(bool running)
+{
+	if(m_ifb.running != running)
+	{
+		m_ifb.running = running;
+		emit runningChanged(m_ifb.running);
+	}
+}
+
+QVariant QInterface::txPacket(void) const
+{
+	return m_nTxPacket;
+}
+
+void QInterface::setTxPacket(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nTxPacket != 0)
+		{
+			m_nTxPacket = 0;
+			emit txPacketChanged(m_nTxPacket);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nTxPacket != ll)
+		{
+			m_nTxPacket = ll;
+			emit txPacketChanged(m_nTxPacket);
+		}
+	}
+}
+
+QVariant QInterface::rxPacket(void) const
+{
+	return m_nRxPacket;
+}
+
+void QInterface::setRxPacket(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nRxPacket != 0)
+		{
+			m_nRxPacket = 0;
+			emit rxPacketChanged(m_nRxPacket);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nRxPacket != ll)
+		{
+			m_nRxPacket = ll;
+			emit rxPacketChanged(m_nRxPacket);
+		}
+	}
+}
+
+QVariant QInterface::txByte(void) const
+{
+	return m_nTxByte;
+}
+
+void QInterface::setTxByte(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nTxByte != 0)
+		{
+			m_nTxByte = 0;
+			emit txByteChanged(m_nTxByte);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nTxByte != ll)
+		{
+			m_nTxByte = ll;
+			emit txByteChanged(m_nTxByte);
+		}
+	}
+}
+
+QVariant QInterface::rxByte(void) const
+{
+	return m_nRxByte;
+}
+
+void QInterface::setRxByte(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nRxByte != 0)
+		{
+			m_nRxByte = 0;
+			emit rxByteChanged(m_nRxByte);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nRxByte != ll)
+		{
+			m_nRxByte = ll;
+			emit rxByteChanged(m_nRxByte);
+		}
+	}
+}
+
+QVariant QInterface::rxErrors(void) const
+{
+	return m_nRxErrors;
+}
+
+void QInterface::setRxErrors(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nRxErrors != 0)
+		{
+			m_nRxErrors = 0;
+			emit rxErrorsChanged(m_nRxErrors);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nRxErrors != ll)
+		{
+			m_nRxErrors = ll;
+			emit rxErrorsChanged(m_nRxErrors);
+		}
+	}
+}
+
+QVariant QInterface::txErrors(void) const
+{
+	return m_nTxErrors;
+}
+
+void QInterface::setTxErrors(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nTxErrors != 0)
+		{
+			m_nTxErrors = 0;
+			emit txErrorsChanged(m_nTxErrors);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nTxErrors != ll)
+		{
+			m_nTxErrors = ll;
+			emit txErrorsChanged(m_nTxErrors);
+		}
+	}
+}
+
+QVariant QInterface::rxDropped(void) const
+{
+	return m_nRxDropped;
+}
+
+void QInterface::setRxDropped(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nRxDropped != 0)
+		{
+			m_nRxDropped = 0;
+			emit rxDroppedChanged(m_nRxDropped);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nRxDropped != ll)
+		{
+			m_nRxDropped = ll;
+			emit rxDroppedChanged(m_nRxDropped);
+		}
+	}
+}
+
+QVariant QInterface::txDropped(void) const
+{
+	return m_nTxDropped;
+}
+
+void QInterface::setTxDropped(const QVariant &val, bool bDelete)
+{
+	if(bDelete)
+	{
+		if(m_nTxDropped != 0)
+		{
+			m_nTxDropped = 0;
+			emit txDroppedChanged(m_nTxDropped);
+		}
+	}
+	else if(val.canConvert(QMetaType::LongLong))
+	{
+		qint64 ll = val.toLongLong();
+		if(m_nTxDropped != ll)
+		{
+			m_nTxDropped = ll;
+			emit txDroppedChanged(m_nTxDropped);
+		}
+	}
+}
+
+QVariant QInterface::macAddr(void) const
+{
+	char szMac[32];
+	memset(szMac, 0, sizeof(szMac));
+	sprintf(szMac, "%02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX", m_szMacAddr[0], m_szMacAddr[1], m_szMacAddr[2], m_szMacAddr[3], m_szMacAddr[4], m_szMacAddr[5]);
+	return szMac;
+}
+
+void QInterface::setMacAddr(const unsigned char *mac, size_t nCbMac, bool bDelete)
+{
+	if(bDelete)
+	{
+		char szMac[32];
+		memset(szMac, 0, sizeof(szMac));
+		memset(m_szMacAddr, 0, sizeof(m_szMacAddr));
+		sprintf(szMac, "%02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX", m_szMacAddr[0], m_szMacAddr[1], m_szMacAddr[2], m_szMacAddr[3], m_szMacAddr[4], m_szMacAddr[5]);
+		emit macAddrChanged(szMac);
+	}
+	else if(sizeof(m_szMacAddr) == nCbMac)
+	{
+		if(memcmp(m_szMacAddr, mac, nCbMac))
+		{
+			char szMac[32];
+			memset(szMac, 0, sizeof(szMac));
+			memcpy(m_szMacAddr, mac, nCbMac);
+			sprintf(szMac, "%02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX", m_szMacAddr[0], m_szMacAddr[1], m_szMacAddr[2], m_szMacAddr[3], m_szMacAddr[4], m_szMacAddr[5]);
+			emit macAddrChanged(szMac);
+		}
+	}
+}
+
+void QInterface::onNetmonEvent(unsigned int nEvtType, const void *pData, LPCRT_ATTRIBUTE pAtts, size_t nMaxAtts)
+{
+	bool bDelAddr = false, bDelLink = false;
+
+	switch(nEvtType)
+	{
+	case RTM_DELLINK:
+		bDelLink = true;
+	case RTM_NEWLINK:
+		if(af() == AF_Inet)
+		{
+			const struct ifinfomsg &iim = *(const struct ifinfomsg*)pData;
+			bool bUp		= !!(iim.ifi_flags & IFF_UP);
+			bool bRunning	= !!(iim.ifi_flags & IFF_RUNNING);
+			setUp(bUp);
+			setRunning(bRunning);
+
+			if(nMaxAtts > IFLA_STATS64)
+			{
+				const RT_ATTRIBUTE &stats = pAtts[IFLA_STATS64];
+				if(stats.pat && stats.pat->rta_type == IFLA_STATS64 && RTA_PAYLOAD(stats.pat) == sizeof(struct rtnl_link_stats64) && stats.pData)
+				{
+					const struct rtnl_link_stats64 *pStats = (const struct rtnl_link_stats64*)stats.pData;
+					setRxPacket(pStats->rx_packets, bDelLink);
+					setTxPacket(pStats->tx_packets, bDelLink);
+					setRxByte(pStats->rx_bytes, bDelLink);
+					setTxByte(pStats->tx_bytes, bDelLink);
+					setRxErrors(pStats->rx_errors, bDelLink);
+					setTxErrors(pStats->tx_errors, bDelLink);
+					setRxDropped(pStats->rx_dropped, bDelLink);
+					setTxDropped(pStats->tx_dropped, bDelLink);
+				}
+			}
+
+			if(nMaxAtts > IFLA_ADDRESS)
+			{
+				const RT_ATTRIBUTE &mac = pAtts[IFLA_ADDRESS];
+				if(mac.pat && mac.pat->rta_type == IFLA_ADDRESS && RTA_PAYLOAD(mac.pat) == ETH_ALEN && mac.pData)
+				{
+					setMacAddr((const unsigned char*)mac.pData, ETH_ALEN, bDelLink);
+				}
+			}
+		}
+		break;
+	case RTM_DELADDR:
+		bDelAddr = true;
+	case RTM_NEWADDR:
+		if((af() == AF_Inet))
+		{
+			const struct ifaddrmsg &am = *(const struct ifaddrmsg*)pData;
+
+			if((am.ifa_family == AF_INET) && (nMaxAtts > IFA_LOCAL))
+			{
+				if(method() == IM_Dhcp)
+				{
+					const struct in_addr &addr = *(const struct in_addr*)pAtts[IFA_LOCAL].pData;
+					const struct in_addr mask = {_PREFIX_TO_MASK(am.ifa_prefixlen)};
+					m_inet.dhcp()->setDynamicAddr(addr, mask, bDelAddr);
+				}
+			}
+		}
+		break;
+	case RTM_NEWROUTE:
+	case RTM_DELROUTE:
+		// not implemented!
+		break;
+	}
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 QInet::QInet(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent) :	QObject(pParent),
@@ -1258,7 +2030,7 @@ QStatic::QStatic(IFACE_INET_STATIC &itfs, NotificationSink &notifyer, QObject *p
 		m_dnsList.append(addr);
 	}
 
-	QObject::connect(&m_netmask, SIGNAL(addressChanged(const QString&)), this, SLOT(netmaskChanged(const QString&)));
+	QObject::connect(&m_netmask, SIGNAL(addressChanged(const QVariant&)), this, SLOT(netmaskChanged(const QVariant&)));
 }
 
 QStatic::~QStatic(void)
@@ -1351,13 +2123,12 @@ void QStatic::setNetPrefix(int netprefix)
 	}
 }
 
-void QStatic::netmaskChanged(const QString &mask)
+void QStatic::netmaskChanged(const QVariant &mask)
 {
 	struct in_addr in;
-	std::string sa = mask.toStdString();
+	std::string sa = mask.toString().toStdString();
 
-	if(	inet_aton(sa.c_str(), &in) &&
-		_IsValidNetmask(in))
+	if(inet_aton(sa.c_str(), &in) && _IsValidNetmask(in))
 	{
 		m_itfs.netprefix = _Mask2Prefix(in);
 		emit netPrefixChanged(m_itfs.netprefix);
@@ -1371,7 +2142,11 @@ void QStatic::netmaskChanged(const QString &mask)
 
 /////////////////////////////////////////////////////////////////////////////
 
-QDhcp::QDhcp(IFACE_INET_DHCP &itfd, NotificationSink &notifyer, QObject *pParent) : QObject(pParent), m_itfd(itfd), m_rNotifyer(notifyer)
+QDhcp::QDhcp(IFACE_INET_DHCP &itfd, NotificationSink &notifyer, QObject *pParent) : QObject(pParent),
+																					m_itfd(itfd),
+																					m_ipAddr(itfd.addr, notifyer, this),
+																					m_netmask(itfd.netmask, notifyer, this, _IsValidNetmask),
+																					m_rNotifyer(notifyer)
 {
 	setObjectName("QDhcp");
 }
@@ -1380,6 +2155,22 @@ QDhcp::~QDhcp(void)
 {
 }
 
+void QDhcp::setDynamicAddr(const struct in_addr &addr, const struct in_addr &mask, bool bDelete)
+{
+	m_ipAddr.setAddr(bDelete ? 0.0 : addr.s_addr);
+	m_netmask.setAddr(bDelete ? 0.0 : mask.s_addr);
+}
+
+QIPv4Address* QDhcp::ipAddress(void)
+{
+	return &m_ipAddr;
+}
+
+QIPv4Address* QDhcp::netMask(void)
+{
+	return &m_netmask;
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 QIPv4Address::QIPv4Address(struct in_addr &addr, NotificationSink &notifyer, QObject *pParent, PFN_ADDRESS_VALIDATOR pfnAddrValidator) :	QObject(pParent),
@@ -1394,9 +2185,9 @@ QIPv4Address::~QIPv4Address(void)
 {
 }
 
-QString QIPv4Address::address(void) const
+QVariant QIPv4Address::address(void) const
 {
-	return inet_ntoa(m_addr);
+	return ::inet_ntoa(m_addr);
 }
 
 int QIPv4Address::b0(void) const
@@ -1423,17 +2214,17 @@ int QIPv4Address::b3(void) const
 	return (int)pb[3];
 }
 
-double QIPv4Address::addr(void) const
+QVariant QIPv4Address::addr(void) const
 {
-	return ntohl(m_addr.s_addr);
+	return ::ntohl(m_addr.s_addr);
 }
 
-void QIPv4Address::setAddress(const QString &addr)
+void QIPv4Address::setAddress(const QVariant &addr)
 {
 	struct in_addr newAddr, oldAddr;
-	std::string sa = addr.toStdString();
+	std::string sa = addr.toString().toStdString();
 
-	if(!inet_aton(sa.c_str(), &newAddr))
+	if(!::inet_aton(sa.c_str(), &newAddr))
 	{
 		m_rNotifyer.reportError("Invalid IP address: '%s'!", sa.c_str());
 		return;
@@ -1529,14 +2320,9 @@ void QIPv4Address::setB3(int b)
 	emit addrChanged(m_addr.s_addr);
 }
 
-void QIPv4Address::setAddr(double val)
+void QIPv4Address::setAddr(const QVariant &val)
 {
-	unsigned int addr = htonl((unsigned int)(int)val);
-	if(val > 0xFFFFFFFF)
-	{
-		m_rNotifyer.reportError("Invalid IP address: '%.f'!", val);
-		return;
-	}
+	unsigned int addr = ::htonl(val.toUInt());
 
 	if(m_addr.s_addr != addr)
 	{

src/qnetworkinfo.h

@@ -1,357 +0,0 @@
-// qnetworkinfo.h :
-//
-
-#if !defined(AGD_QNETWORKINFO_H__B4EDEFD4_1301_4926_83C7_289080AC5492__INCLUDED_)
-#define AGD_QNETWORKINFO_H__B4EDEFD4_1301_4926_83C7_289080AC5492__INCLUDED_
-
-#include <vector>
-#include <QObject>
-#include <QList>
-#include <QQmlListProperty>
-#include <qqmlparserstatus.h>
-#include <gfa/mutex.h>
-#include <gfa/gfanet.h>
-
-/////////////////////////////////////////////////////////////////////////////
-// netinterfaces.h - Declarations:
-
-class Interface;
-
-class NotificationSink
-{
-public:
-	virtual void reportError(const char *pszFormatStr, ...)									= 0;
-	virtual void filterPropertyChanged(void) const											= 0;
-	virtual void selConfigChanged(Interface* pi, unsigned int cfgOld, unsigned int cfgNew)	= 0;
-	virtual int getInterfaceSelConfig(Interface &ri)										= 0;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-typedef bool (*PFN_ADDRESS_VALIDATOR)(const struct in_addr &addr);
-
-class IPv4Address : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QString address READ address WRITE setAddress NOTIFY addressChanged)
-    Q_PROPERTY(int b0 READ b0 WRITE setB0 NOTIFY b0Changed)
-    Q_PROPERTY(int b1 READ b1 WRITE setB1 NOTIFY b1Changed)
-    Q_PROPERTY(int b2 READ b2 WRITE setB2 NOTIFY b2Changed)
-    Q_PROPERTY(int b3 READ b3 WRITE setB3 NOTIFY b3Changed)
-
-
-public:
-    explicit IPv4Address(struct in_addr &addr, NotificationSink &notifyer, QObject *pParent = 0, PFN_ADDRESS_VALIDATOR pfnAddrValidator = NULL);
-    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 setAddress(const QString &addr);
-    void setB0(int b);
-    void setB1(int b);
-    void setB2(int b);
-    void setB3(int b);
-
-signals:
-	void addressChanged(const QString&);
-	void b0Changed(int);
-	void b1Changed(int);
-	void b2Changed(int);
-	void b3Changed(int);
-
-private:
-	struct in_addr &m_addr;
-	PFN_ADDRESS_VALIDATOR m_pfnAddrValidator;
-	NotificationSink &m_rNotifyer;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class Static : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(IPv4Address* ipAddress READ ipAddress CONSTANT)
-    Q_PROPERTY(IPv4Address* netMask READ netMask CONSTANT)
-    Q_PROPERTY(IPv4Address* gateway READ gateway CONSTANT)
-    Q_PROPERTY(IPv4Address* bcastAddress READ bcastAddress CONSTANT)
-    Q_PROPERTY(IPv4Address* ptpAddress READ ptpAddress CONSTANT)
-    Q_PROPERTY(QQmlListProperty<IPv4Address> dnsServer READ dnsServer CONSTANT)
-    Q_PROPERTY(int metric READ metric WRITE setMetric NOTIFY metricChanged)
-    Q_PROPERTY(int mtu READ mtu WRITE setMtu NOTIFY mtuChanged)
-    Q_PROPERTY(int netPrefix READ netPrefix WRITE setNetPrefix NOTIFY netPrefixChanged)
-
-public:
-    explicit Static(IFACE_INET_STATIC &itfs, NotificationSink &notifyer, QObject *pParent = 0);
-    virtual ~Static(void);
-
-private:
-    IPv4Address* ipAddress(void);
-    IPv4Address* netMask(void);
-    IPv4Address* gateway(void);
-    IPv4Address* bcastAddress(void);
-    IPv4Address* ptpAddress(void);
-    QQmlListProperty<IPv4Address> dnsServer(void);
-    int metric(void) const;
-    void setMetric(int metric);
-    int mtu(void) const;
-    void setMtu(int mtu);
-    int netPrefix(void) const;
-    void setNetPrefix(int netprefix);
-
-private slots:
-    void netmaskChanged(const QString&);
-
-signals:
-	void metricChanged(int metric);
-	void mtuChanged(int mtu);
-	void netPrefixChanged(unsigned int netprefix);
-
-private:
-	IFACE_INET_STATIC &m_itfs;
-	NotificationSink &m_rNotifyer;
-	IPv4Address m_ipAddr;
-	IPv4Address m_netmask;
-	IPv4Address m_gateway;
-	IPv4Address m_bcastAddr;
-	IPv4Address m_ptpAddr;
-	QList<IPv4Address*> m_dnsList;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class Dhcp : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit Dhcp(IFACE_INET_DHCP &itfd, NotificationSink &notifyer, QObject *pParent = 0);
-    virtual ~Dhcp(void);
-
-private:
-	IFACE_INET_DHCP &m_itfd;
-	NotificationSink &m_rNotifyer;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class Inet : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(Static* stat READ stat CONSTANT)
-    Q_PROPERTY(Dhcp* dhcp READ dhcp CONSTANT)
-
-public:
-    explicit Inet(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent = 0);
-    virtual ~Inet(void);
-
-private:
-    Static* stat(void);
-    Dhcp* dhcp(void);
-
-private:
-    Static m_static;
-    Dhcp m_dhcp;
-	NotificationSink &m_rNotifyer;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class Interface : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(QString name READ name CONSTANT)
-    Q_PROPERTY(QString afName READ afName NOTIFY afNameChanged)
-    Q_PROPERTY(int af READ af WRITE setAf NOTIFY afChanged)
-    Q_PROPERTY(QString methodName READ methodName NOTIFY methodNameChanged)
-    Q_PROPERTY(int method READ method WRITE setMethod NOTIFY methodChanged)
-    Q_PROPERTY(int selCfg READ selCfg WRITE setSelCfg NOTIFY selCfgChanged)
-    Q_PROPERTY(Inet* inet READ inet CONSTANT)
-
-public:
-    explicit Interface(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent = 0);
-    virtual ~Interface(void);
-
-    inline const ITF_IFACE_BLOCK & getIface(void) const {
-    	return m_ifb;}
-
-    inline ITF_IFACE_BLOCK & getIface(void){
-    	return m_ifb;}
-    
-    inline unsigned long getID(void) const {
-    	return m_ifb.id;}
-    
-    inline int getSelCfg(void) const {
-	    return m_selCfg;}
-    
-    inline const char * getName(void) const {
-	    return m_ifb.cfgName.c_str();}
-
-	enum AddressFamily
-	{
-		AF_Unknown	= 0,
-		AF_Inet		= 0x0001,
-		AF_Inet6	= 0x0002,
-		AF_Ipx		= 0x0004,
-		AF_Can		= 0x0008,
-		AF_Invalid	= 0x0010
-	};
-	Q_ENUMS(AddressFamily)
-
-	enum ItfMethod
-	{
-		IM_Unknown	= 0,
-		IM_Static	= 0x0001,
-		IM_Dhcp		= 0x0002,
-		IM_Manual	= 0x0004,
-		IM_BootP	= 0x0008,
-		IM_Tunnel	= 0x0010,
-		IM_Ppp		= 0x0020,
-		IM_WvDial	= 0x0040,
-		IM_IpV4ll	= 0x0080,
-		IM_Loopback	= 0x0100,
-		IM_Auto		= 0x0200,
-		IM_Invalid	= 0x0400
-	};
-	Q_ENUMS(ItfMethod)
-
-	enum SelConfig
-	{
-		SC_None			= 0,
-		SC_Auto			= 0x0001,
-		SC_AllowAuto	= 0x0002,
-		SC_AllowHotplug	= 0x0004,
-		SC_NoAutoDown	= 0x0008,
-		SC_NoScripts	= 0x0010,
-		SC_Invalid		= 0x0020
-	};
-	Q_ENUMS(SelConfig)
-
-private:
-    QString name(void) const;
-    QString afName(void) const;
-    int af(void) const;
-    void setAf(int af);
-    QString methodName(void) const;
-    int method(void) const;
-    void setMethod(int method);
-    int selCfg(void) const;
-    void setSelCfg(int cfg);
-    Inet* inet(void);
-
-signals:
-	void afNameChanged(void);
-	void afChanged(int af);
-	void methodNameChanged(void);
-	void methodChanged(int method);
-	void selCfgChanged(int cfg);
-
-private:
-	ITF_IFACE_BLOCK &m_ifb;
-	Inet m_inet;
-	NotificationSink &m_rNotifyer;
-	int m_selCfg;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class NetInterfaces : public QObject, public QQmlParserStatus, public NotificationSink
-{
-    Q_OBJECT
-    Q_INTERFACES(QQmlParserStatus)
-    Q_PROPERTY(QQmlListProperty<Interface> interfaces READ interfaces NOTIFY interfacesChanged)
-    Q_PROPERTY(QQmlListProperty<Interface> filteredInterfaces READ filteredInterfaces NOTIFY filteredInterfacesChanged)
-    Q_PROPERTY(QString itfFilterName READ itfFilterName WRITE setItfFilterName NOTIFY itfFilterNameChanged)
-    Q_PROPERTY(int itfFilterAF READ itfFilterAF WRITE setItfFilterAF NOTIFY itfFilterAFChanged)
-    Q_PROPERTY(int itfFilterMethod READ itfFilterMethod WRITE setItfFilterMethod NOTIFY itfFilterMethodChanged)
-    Q_PROPERTY(bool ifUpDownInProgress READ ifUpDownInProgress CONSTANT)
-
-public:
-    explicit NetInterfaces(QObject *pParent = 0);
-    virtual ~NetInterfaces(void);
-
-	enum IfUpDownCtx
-	{
-		UDC_Start,
-		UDC_Stop,
-		UDC_Restart
-	};
-	Q_ENUMS(IfUpDownCtx)
-
-public:
-	Q_INVOKABLE void reset(void);
-	Q_INVOKABLE bool initialize(void);
-	Q_INVOKABLE bool save(void);
-	Q_INVOKABLE bool saveAs(const QString &path);
-	Q_INVOKABLE Interface* newInterface(QString name, int af, int method);
-	Q_INVOKABLE void removeInterface(Interface *pi);
-	Q_INVOKABLE bool startInterface(Interface *pi);
-	Q_INVOKABLE bool stopInterface(Interface *pi);
-	Q_INVOKABLE bool restartInterface(Interface *pi);
-	Q_INVOKABLE bool cancelStartStopInterface(void);
-
-	virtual void classBegin();
-	virtual void componentComplete();
-	virtual void reportError(const char *pszFormatStr, ...);
-	virtual void filterPropertyChanged(void) const;
-	virtual void selConfigChanged(Interface* pi, unsigned int cfgOld, unsigned int cfgNew);
-	virtual int getInterfaceSelConfig(Interface &ri);
-	
-	inline pid_t GetIfUpDownPid(void) const {
-		return m_ifUpDownPid;}
-	
-	inline void SetIfUpDownPid(pid_t pid){
-		m_ifUpDownPid = pid;}
-	    
-	inline bool GetIfUpDownInProgress(void) const {
-		return m_bIfUpDownInProgress;}
-	    
-	inline void SetIfUpDownInProgress(bool bVal){
-		m_bIfUpDownInProgress = bVal;}
-	
-	bool SetInterlockedIfUpDownInProgress(void);
-
-signals:
-	void interfacesChanged(void) const;
-	void filteredInterfacesChanged(void) const;
-	void itfFilterNameChanged(const QString &val) const;
-	void itfFilterAFChanged(int af) const;
-	void itfFilterMethodChanged(int method) const;
-	void error(QString msg) const;
-	void ifUpDown(QString msg) const;
-	void ifUpDownCompleted(int ctx, int code) const;
-
-private:
-	QQmlListProperty<Interface> interfaces(void);
-	QQmlListProperty<Interface> filteredInterfaces(void);
-	const QString& itfFilterName(void) const;
-	void setItfFilterName(const QString &val);
-	int itfFilterAF(void) const;
-	void setItfFilterAF(int nval);
-	int itfFilterMethod(void) const;
-	void setItfFilterMethod(int method);
-	bool ifUpDownInProgress(void) const;
-
-    static void onIfUpDown(const char *pszMsg, void *pCtx);
-    static void onIfUpCompleted(int nExitCode, void *pCtx);
-    static void onIfDownCompleted(int nExitCode, void *pCtx);
-    static void onIfRestartCompleted(int nExitCode, void *pCtx);
-
-private:
-	ETC_NETWORK_INTERFACES m_eni;
-	QList<Interface*> m_interfaces;
-	QList<Interface*> m_filteredInterfaces;
-	QString m_itfFilterName;
-	int m_itfFilterAF;
-	int m_itfFilterMethod;
-	bool m_bIfUpDownInProgress;
-	pid_t m_ifUpDownPid;
-	CLocalMutex m_mutex;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-#endif	//	!defined(AGD_QNETWORKINFO_H__B4EDEFD4_1301_4926_83C7_289080AC5492__INCLUDED_)