#include <signal.h>
#include "netinterfaces.h"
#include "debug.h"

#ifndef _countof
#define _countof(a)					(sizeof(a) / sizeof(*a))
#endif	//	_countof

#define _IS_VALID_BYTE_VALUE(b)		(((b) >= 0) && ((b) <= 255))


template<typename T>
static bool _IsPowerOf2(T x)
{
	return x && !(x & (x - 1));
}

template<typename T>
static unsigned int _BitCount(T n)
{
	unsigned int count = 0;
	while(n)
	{
		count++;
		n &= (n - 1);
	}
	return count;
}

template<typename T>
static int _BitNumber(T n)
{
	if(!n || !_IsPowerOf2(n))
		return -1;
	int count = 0;
	while(n)
	{
		count++;
		n >>= 1;
	}
	return count - 1;
}

static int _Mask2Prefix(const struct in_addr &in)
{
	return _BitCount(in.s_addr);
}

static in_addr_t _Prefix2Mask(int prefix)
{
	return htonl(~((1 << (32 - prefix)) - 1));
}

static bool _IsValidNetmask(const struct in_addr &in)
{
	return _IsPowerOf2(~ntohl(in.s_addr) + 1);
}

/////////////////////////////////////////////////////////////////////////////

#define _FLAG_TO_ENUM(f)		(_BitNumber(f))
#define _ENUM_TO_FLAG(e)		(0x00000001 << e)

/////////////////////////////////////////////////////////////////////////////

NetInterfaces::NetInterfaces(QObject *pParent) :	QObject(pParent),
													m_itfFilterAF(Interface::AF_Unknown),
													m_itfFilterMethod(Interface::IM_Unknown),
													m_bIfUpDownInProgress(false),
													m_ifUpDownPid(-1)
{
	setObjectName("NetInterfaces");
	m_mutex.Create(true);
	m_itfFilterName.clear();
}

NetInterfaces::~NetInterfaces(void)
{
	reset();
	m_mutex.Release();
}

void NetInterfaces::classBegin()
{
	if(!initialize())
	{
		reportError("NetInterfaces::initialize failed!");
	}
}

void NetInterfaces::componentComplete()
{
}

void NetInterfaces::reset(void)
{
	Interface *pItf;

    for(int i = 0; i < m_interfaces.count(); i++)
    {
        if((pItf = m_interfaces.at(i)))
        	delete pItf;
    }
    m_interfaces.clear();
	emit interfacesChanged();
	emit filteredInterfacesChanged();
	m_eni._reset();
}

bool NetInterfaces::initialize(void)
{
	bool bRet;
	reset();

    if((bRet = ::ParseEtcNetworkInterfaces(m_eni)))
	{
		for(auto it = m_eni.ibl.begin(); it != m_eni.ibl.end(); it++)
		{
			ITF_IFACE_BLOCK &ibl = *it;
			m_interfaces.append(new Interface(ibl, static_cast<NotificationSink&>(*this), this));
		}

		emit interfacesChanged();
		emit filteredInterfacesChanged();
	}

	return bRet;
}

bool NetInterfaces::save(void)
{
	return ::WriteEtcNetworkInterfaces(m_eni, NULL);
}

bool NetInterfaces::saveAs(const QString &path)
{
	if(!path.length())
		return false;
	std::string p = path.toStdString();
	const char *pszPath = p.c_str();
	return ::WriteEtcNetworkInterfaces(m_eni, pszPath);
}

void NetInterfaces::reportError(const char *pszFormatStr, ...)
{
	va_list args;
	va_start(args, pszFormatStr);
	QString qs = QString::vasprintf(pszFormatStr, args);
	va_end (args);
	m_mutex.Lock();
    emit error(qs);
	m_mutex.Unlock();
}

void NetInterfaces::filterPropertyChanged(void) const
{
	emit filteredInterfacesChanged();
}

void NetInterfaces::selConfigChanged(Interface* pi, unsigned int cfgOld, unsigned int cfgNew)
{
	unsigned long id	= pi->getID();
	unsigned int diff	= cfgOld ^ cfgNew;
	unsigned int add	= cfgNew & diff;
	unsigned int rem	= cfgOld & diff;

	for(int mask = Interface::SC_Auto; mask < Interface::SC_Invalid; mask <<= 1)
	{
		if(add & mask)
			::AddInterfaceToCfgGroup(m_eni, id, (CfgGroup)_FLAG_TO_ENUM(mask));

		if(rem & mask)
			::RemoveInterfaceFromCfgGroup(m_eni, id, (CfgGroup)_FLAG_TO_ENUM(mask));
	}
}

Interface* NetInterfaces::newInterface(QString name, int af, int method)
{
	if(name.isNull() || name.isEmpty())
	{
		reportError("Invalid or empty interface name!");
		return NULL;
	}

	if(!_IsPowerOf2(af) || (af <= Interface::AF_Unknown) || (af >= Interface::AF_Invalid))
	{
		reportError("Invalid address family: %d!", af);
		return NULL;
	}

	if(!_IsPowerOf2(method) || (method <= Interface::IM_Unknown) || (method >= Interface::IM_Invalid))
	{
		reportError("Invalid method: %d!", method);
		return NULL;
	}

	m_eni.ibl.emplace_back();
	ITF_IFACE_BLOCK &rib = m_eni.ibl.back();
    rib.cfgName = name.toStdString();
	rib.proto = (IfaceProtos)_FLAG_TO_ENUM(af);
	rib.method = (IfaceMethods)_FLAG_TO_ENUM(method);
	Interface *pi = new Interface(rib, static_cast<NotificationSink&>(*this), this);
	m_interfaces.append(pi);
	emit interfacesChanged();
	emit filteredInterfacesChanged();
	return pi;
}

void NetInterfaces::removeInterface(Interface *pi)
{
	if(!pi)
	{
		reportError("NetInterfaces::removeInterface: An attempt was made to remove an invalid interface!");
		return;
	}

	m_mutex.Lock();
	if(GetIfUpDownInProgress())
	{
		m_mutex.Unlock();
		reportError("NetInterfaces::removeInterface: Interface start/stop in progress! Please try again later!");
		return;
	}
	m_mutex.Unlock();

    unsigned long id	= pi->getID();
    int selCfg			= pi->getSelCfg();

    for(int i = 0; i < m_interfaces.count(); i++)
	{
        Interface *pil = m_interfaces.at(i);

        if(pil->getID() == id)
        {
        	m_interfaces.removeAt(i);
			emit interfacesChanged();
			emit filteredInterfacesChanged();
			delete pil;

			for(int mask = Interface::SC_Auto; mask < Interface::SC_Invalid; mask <<= 1)
			{
				if(selCfg & mask)
					::RemoveInterfaceFromCfgGroup(m_eni, id, (CfgGroup)_FLAG_TO_ENUM(mask));
			}

			::RemoveInterfaceBlock(m_eni, id);
			break;
        }
    }
}

bool NetInterfaces::SetInterlockedIfUpDownInProgress(void)
{
	m_mutex.Lock();
	if(m_bIfUpDownInProgress)
	{
		m_mutex.Unlock();
		return false;
	}
	m_bIfUpDownInProgress = true;
	m_mutex.Unlock();
	return true;
}

void NetInterfaces::onIfUpDown(const char *pszMsg, void *pCtx)
{
	if(pCtx)
	{
		NetInterfaces *pThis = static_cast<NetInterfaces*>(pCtx);
		pThis->m_mutex.Lock();
		emit pThis->ifUpDown(pszMsg);
		pThis->m_mutex.Unlock();
	}
}

void NetInterfaces::onIfUpCompleted(int nExitCode, void *pCtx)
{
	if(pCtx)
	{
		LPIF_UPDOWN_CONTEXT piudc = static_cast<LPIF_UPDOWN_CONTEXT>(pCtx);
		piudc->pThis->m_mutex.Lock();
		emit piudc->pThis->ifUpDownCompleted(piudc->ctx, nExitCode);
		piudc->pThis->SetIfUpDownInProgress(false);
		piudc->pThis->SetIfUpDownPid(-1);
		piudc->pThis->m_mutex.Unlock();
		delete piudc;
	}
}

void NetInterfaces::onIfDownCompleted(int nExitCode, void *pCtx)
{
	if(pCtx)
	{
		LPIF_UPDOWN_CONTEXT piudc = static_cast<LPIF_UPDOWN_CONTEXT>(pCtx);
		piudc->pThis->m_mutex.Lock();
		emit piudc->pThis->ifUpDownCompleted(piudc->ctx, nExitCode);
		piudc->pThis->SetIfUpDownInProgress(false);
		piudc->pThis->SetIfUpDownPid(-1);
		piudc->pThis->m_mutex.Unlock();
		delete piudc;
	}
}

void NetInterfaces::onIfRestartCompleted(int nExitCode, void *pCtx)
{
	if(pCtx)
	{
		LPIF_UPDOWN_CONTEXT piudc = static_cast<LPIF_UPDOWN_CONTEXT>(pCtx);

		if(piudc->ctx == UDC_Stop && !nExitCode) // ifdown succeeded
		{
			int nRet;
			piudc->ctx = UDC_Start;

			if((nRet = ::IfUpAsync(piudc->pi->getName(), piudc->pThis->m_ifUpDownPid, &NetInterfaces::onIfRestartCompleted, static_cast<void*>(piudc), &NetInterfaces::onIfUpDown, static_cast<void*>(piudc->pThis))))
			{
				piudc->pThis->m_mutex.Lock();
				piudc->pThis->reportError("NetInterfaces::onIfRestartCompleted: IfUpAsync failed with code: %d", nRet);
				emit piudc->pThis->ifUpDownCompleted(UDC_Restart, nRet);
				piudc->pThis->SetIfUpDownPid(-1);
				piudc->pThis->SetIfUpDownInProgress(false);
				piudc->pThis->m_mutex.Unlock();
				delete piudc;
			}

			return;
		}

		piudc->pThis->m_mutex.Lock();
		emit piudc->pThis->ifUpDownCompleted(UDC_Restart, nExitCode);
		piudc->pThis->SetIfUpDownPid(-1);
		piudc->pThis->SetIfUpDownInProgress(false);
		piudc->pThis->m_mutex.Unlock();
		delete piudc;
	}
}

bool NetInterfaces::startInterface(Interface *pi)
{
	if(!pi)
	{
		reportError("NetInterfaces::stopInterface: Invalid interface!");
		return false;
	}

	int nRet;

	if(!SetInterlockedIfUpDownInProgress())
	{
		reportError("NetInterfaces::startInterface: IfUp/Down already in progress!");
		return false;
	}

	LPIF_UPDOWN_CONTEXT piudc = new IF_UPDOWN_CONTEXT;
	piudc->pThis		= this;
	piudc->pi			= pi;
	piudc->ctx			= UDC_Start;

	if((nRet = ::IfUpAsync(pi->getName(), m_ifUpDownPid, &NetInterfaces::onIfUpCompleted, static_cast<void*>(piudc), &NetInterfaces::onIfUpDown, static_cast<void*>(this))))
	{
		m_mutex.Lock();
		reportError("NetInterfaces::startInterface: IfUpAsync failed with code: %d", nRet);
		emit ifUpDownCompleted(UDC_Start, -3);
		SetIfUpDownInProgress(false);
		SetIfUpDownPid(-1);
		m_mutex.Unlock();
		delete piudc;
		return false;
	}

	return true;
}

bool NetInterfaces::stopInterface(Interface *pi)
{
	if(!pi)
	{
		reportError("NetInterfaces::stopInterface: Invalid interface!");
		return false;
	}

	int nRet;

	if(!SetInterlockedIfUpDownInProgress())
	{
		reportError("NetInterfaces::stopInterface: IfUp/Down already in progress!");
		return false;
	}

	LPIF_UPDOWN_CONTEXT piudc = new IF_UPDOWN_CONTEXT;
	piudc->pThis		= this;
	piudc->pi			= pi;
	piudc->ctx			= UDC_Stop;

	if((nRet = ::IfDownAsync(pi->getName(), m_ifUpDownPid, &NetInterfaces::onIfDownCompleted, static_cast<void*>(piudc), &NetInterfaces::onIfUpDown, static_cast<void*>(this))))
	{
		m_mutex.Lock();
		reportError("NetInterfaces::stopInterface: IfDownAsync failed with code: %d", nRet);
		emit ifUpDownCompleted(UDC_Stop, -3);
		SetIfUpDownInProgress(false);
		SetIfUpDownPid(-1);
		m_mutex.Unlock();
		delete piudc;
		return false;
	}

	return true;
}

bool NetInterfaces::restartInterface(Interface *pi)
{
	if(!pi)
	{
		reportError("NetInterfaces::restartInterface: Invalid interface!");
		return false;
	}

	int nRet;

	if(!SetInterlockedIfUpDownInProgress())
	{
		reportError("NetInterfaces::restartInterface: IfUp/Down already in progress!");
		return false;
	}

	LPIF_UPDOWN_CONTEXT piudc = new IF_UPDOWN_CONTEXT;
	piudc->pThis		= this;
	piudc->pi			= pi;
	piudc->ctx			= UDC_Stop;

	if((nRet = ::IfDownAsync(pi->getName(), m_ifUpDownPid, &NetInterfaces::onIfRestartCompleted, static_cast<void*>(piudc), &NetInterfaces::onIfUpDown, static_cast<void*>(this))))
	{
		m_mutex.Lock();
		reportError("NetInterfaces::restartInterface: IfDownAsync failed with code: %d", nRet);
		emit ifUpDownCompleted(UDC_Restart, -3);
		SetIfUpDownInProgress(false);
		SetIfUpDownPid(-1);
		m_mutex.Unlock();
		delete piudc;
		return false;
	}

	return true;
}

bool NetInterfaces::cancelStartStopInterface(void)
{
	m_mutex.Lock();
	pid_t pid = GetIfUpDownPid();
	bool bCancel = GetIfUpDownInProgress() && (pid != -1);
	if(bCancel)
	{
//		bCancel = !kill(-pid, SIGKILL);
		bCancel = !system("killall -SIGTERM ifup");
	}
	m_mutex.Unlock();
	return bCancel;
}

QQmlListProperty<Interface> NetInterfaces::interfaces(void)
{
	return QQmlListProperty<Interface>(this, m_interfaces);
}

QQmlListProperty<Interface> NetInterfaces::filteredInterfaces(void)
{
	m_filteredInterfaces.clear();

    for(int i = 0; i < m_interfaces.count(); i++)
	{
        Interface *pi = m_interfaces.at(i);
		const ITF_IFACE_BLOCK &ibl = pi->getIface();

		if(	(m_itfFilterName.isNull() || m_itfFilterName.isEmpty() || (m_itfFilterName == ibl.cfgName.c_str())) &&
			(_ENUM_TO_FLAG(ibl.proto) & m_itfFilterAF) &&
			(_ENUM_TO_FLAG(ibl.method) & m_itfFilterMethod))
		{
			m_filteredInterfaces.append(pi);
		}
	}

	return QQmlListProperty<Interface>(this, m_filteredInterfaces);
}

const QString& NetInterfaces::itfFilterName(void) const
{
	return m_itfFilterName;
}

void NetInterfaces::setItfFilterName(const QString &val)
{
	if(val != m_itfFilterName)
	{
		m_itfFilterName = val;
		emit itfFilterNameChanged(m_itfFilterName);
		emit filteredInterfacesChanged();
	}

}

int NetInterfaces::itfFilterAF(void) const
{
	return m_itfFilterAF;
}

void NetInterfaces::setItfFilterAF(int af)
{


	if(af < Interface::AF_Unknown || af >= Interface::AF_Invalid)
	{
		reportError("Invalid address family filter: %d!", af);
		return;
	}

	if(m_itfFilterAF != af)
	{
		m_itfFilterAF = af;
		emit itfFilterAFChanged(af);
		emit filteredInterfacesChanged();
	}
}

int NetInterfaces::itfFilterMethod(void) const
{
	return m_itfFilterMethod;
}

void NetInterfaces::setItfFilterMethod(int method)
{
	if(method < Interface::IM_Unknown || method >= Interface::IM_Invalid)
	{
		reportError("Invalid method filter: %d!", method);
		return;
	}

	if(m_itfFilterMethod != method)
	{
		m_itfFilterMethod = method;
		emit itfFilterMethodChanged(method);
		emit filteredInterfacesChanged();
	}
}

int NetInterfaces::getInterfaceSelConfig(Interface &ri)
{
	int mask = 0;

	::EnumInterfaceCfgGroups(m_eni, ri.getID(),
		[] (CfgGroup cg, void *pCtx) -> void
		{
			if(cg > CG_Unknown)
			{
				int *m = (int*)pCtx;
				*m |= _ENUM_TO_FLAG(cg);
			}
		}, &mask);

	return mask;
}

bool NetInterfaces::ifUpDownInProgress(void) const
{
	return m_bIfUpDownInProgress;
}

/////////////////////////////////////////////////////////////////////////////

Interface::Interface(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))
{
	setObjectName("Interface");
}

Interface::~Interface(void)
{
}

QString Interface::name(void) const
{
	return QString::fromStdString(m_ifb.cfgName);
}

QString Interface::afName(void) const
{
	return ::GetIfaceProtoStr(m_ifb.proto);
}

int Interface::af(void) const
{
	return (int)_ENUM_TO_FLAG(m_ifb.proto);
}

void Interface::setAf(int af)
{
	if(!_IsPowerOf2(af) || (af < Interface::AF_Unknown) || (af >= Interface::AF_Invalid))
	{
		m_rNotifyer.reportError("Invalid address family: %d!", af);
		return;
	}

	IfaceProtos proto = (IfaceProtos)_FLAG_TO_ENUM(af);

	if(m_ifb.proto != proto)
	{
		m_ifb.proto = proto;
		emit afChanged(af);
		emit afNameChanged();
		m_rNotifyer.filterPropertyChanged();
	}
}

QString Interface::methodName(void) const
{
	return ::GetIfaceMethodStr(m_ifb.method);
}

int Interface::method(void) const
{
	return (int)_ENUM_TO_FLAG(m_ifb.method);
}

void Interface::setMethod(int method)
{
	if(!_IsPowerOf2(method) || (method < Interface::IM_Unknown) || (method >= Interface::IM_Invalid))
	{
		m_rNotifyer.reportError("Invalid interface method: %d!", method);
		return;
	}

	IfaceMethods meth = (IfaceMethods)_FLAG_TO_ENUM(method);

	if(m_ifb.method != meth)
	{
		m_ifb.method = meth;
		emit methodChanged(meth);
		emit methodNameChanged();
		m_rNotifyer.filterPropertyChanged();
	}
}

int Interface::selCfg(void) const
{
	return m_selCfg;
}

void Interface::setSelCfg(int cfg)
{
	if(cfg < SC_None || cfg >= SC_Invalid)
	{
		m_rNotifyer.reportError("Invalid start/selection configuration: 0x%X!", cfg);
		return;
	}

	if(m_selCfg != cfg)
	{
		m_rNotifyer.selConfigChanged(this, m_selCfg, cfg);
		m_selCfg = cfg;
		emit selCfgChanged(cfg);
	}

}

Inet* Interface::inet(void)
{
	return &m_inet;
}

/////////////////////////////////////////////////////////////////////////////

Inet::Inet(ITF_IFACE_BLOCK &ifb, NotificationSink &notifyer, QObject *pParent) :	QObject(pParent),
																					m_static(ifb.inet4s, notifyer, this),
																					m_dhcp(ifb.inet4d, notifyer, this),
																					m_rNotifyer(notifyer)
{
	setObjectName("Inet");
}

Inet::~Inet(void)
{
}

Static* Inet::stat(void)
{
	return &m_static;
}

Dhcp* Inet::dhcp(void)
{
	return &m_dhcp;
}

/////////////////////////////////////////////////////////////////////////////

Static::Static(IFACE_INET_STATIC &itfs, NotificationSink &notifyer, QObject *pParent) :	QObject(pParent),
																						m_itfs(itfs),
																						m_rNotifyer(notifyer),
																						m_ipAddr(itfs.addr, notifyer, this),
																						m_netmask(itfs.netmask, notifyer, this, _IsValidNetmask),
																						m_gateway(itfs.gate, notifyer, this),
																						m_bcastAddr(itfs.bcast, notifyer, this),
																						m_ptpAddr(itfs.pointopoint, notifyer, this)
{
	setObjectName("Static");
	for(size_t i = 0; i < _countof(m_itfs.namesvr); i++)
	{
		IPv4Address *addr = new IPv4Address(m_itfs.namesvr[i], notifyer, this);
		m_dnsList.append(addr);
	}

	QObject::connect(&m_netmask, SIGNAL(addressChanged(const QString&)), this, SLOT(netmaskChanged(const QString&)));
}

Static::~Static(void)
{
	IPv4Address *addr;

    for(int i = 0; i < m_dnsList.count(); i++)
    {
        if((addr = m_dnsList.at(i)))
        	delete addr;
    }
}

IPv4Address* Static::ipAddress(void)
{
	return &m_ipAddr;
}

IPv4Address* Static::netMask(void)
{
	return &m_netmask;
}

IPv4Address* Static::gateway(void)
{
	return &m_gateway;
}

IPv4Address* Static::bcastAddress(void)
{
	return &m_bcastAddr;
}

IPv4Address* Static::ptpAddress(void)
{
	return &m_ptpAddr;
}

QQmlListProperty<IPv4Address> Static::dnsServer(void)
{
	return QQmlListProperty<IPv4Address>(this, m_dnsList);
}

int Static::metric(void) const
{
	return m_itfs.metric;
}

void Static::setMetric(int metric)
{
	if(m_itfs.metric != metric)
	{
		m_itfs.metric = metric;
		emit metricChanged(metric);
	}
}

int Static::mtu(void) const
{
	return m_itfs.mtu;
}

void Static::setMtu(int mtu)
{
	if(m_itfs.mtu != mtu)
	{
		m_itfs.mtu = mtu;
		emit mtuChanged(mtu);
	}
}

int Static::netPrefix(void) const
{
	return m_itfs.netprefix;
}

void Static::setNetPrefix(int netprefix)
{
	if(netprefix < 0 || netprefix > 32)
	{
		m_rNotifyer.reportError("Invalid net prefix: %d!", netprefix);
		return;
	}

	if(m_itfs.netprefix != (unsigned int)netprefix)
	{
		struct in_addr in;
		in.s_addr = _Prefix2Mask(netprefix);
        m_netmask.setProperty("address", QVariant(inet_ntoa(in)));
	}
}

void Static::netmaskChanged(const QString &mask)
{
	struct in_addr in;
	std::string sa = mask.toStdString();

	if(	inet_aton(sa.c_str(), &in) &&
		_IsValidNetmask(in))
	{
		m_itfs.netprefix = _Mask2Prefix(in);
		emit netPrefixChanged(m_itfs.netprefix);
	}
	else
	{
		m_rNotifyer.reportError("Invalid net mask: %s!", sa.c_str());
        m_netmask.setProperty("address", QVariant("255.255.255.0"));
	}
}

/////////////////////////////////////////////////////////////////////////////

Dhcp::Dhcp(IFACE_INET_DHCP &itfd, NotificationSink &notifyer, QObject *pParent) : QObject(pParent), m_itfd(itfd), m_rNotifyer(notifyer)
{
	setObjectName("Dhcp");
}

Dhcp::~Dhcp(void)
{
}

/////////////////////////////////////////////////////////////////////////////

IPv4Address::IPv4Address(struct in_addr &addr, NotificationSink &notifyer, QObject *pParent, PFN_ADDRESS_VALIDATOR pfnAddrValidator) :	QObject(pParent),
																																		m_addr(addr),
																																		m_pfnAddrValidator(pfnAddrValidator),
																																		m_rNotifyer(notifyer)
{
	setObjectName("IPv4Address");
}

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::setAddress(const QString &addr)
{
	struct in_addr newAddr, oldAddr;
	std::string sa = addr.toStdString();

	if(!inet_aton(sa.c_str(), &newAddr))
	{
		m_rNotifyer.reportError("Invalid IP address: '%s'!", sa.c_str());
		return;
	}

	if(m_pfnAddrValidator && !(*m_pfnAddrValidator)(newAddr))
	{
		m_rNotifyer.reportError("Invalid 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 b0Changed(pb2[0]);
		if(pb1[1] != pb2[1])
			emit b1Changed(pb2[1]);
		if(pb1[2] != pb2[2])
			emit b2Changed(pb2[2]);
		if(pb1[3] != pb2[3])
			emit b3Changed(pb2[3]);
		emit addressChanged(address());
	}
}

void IPv4Address::setB0(int b)
{
	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
	if(!_IS_VALID_BYTE_VALUE(b))
	{
		m_rNotifyer.reportError("Invalid IP address byte 0: '%d'!", b);
		return;
	}
	if(b == (int)pb[0])
		return;
	pb[0] = (unsigned char)b;
	emit b0Changed(b);
	emit addressChanged(address());
}

void IPv4Address::setB1(int b)
{
	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
	if(!_IS_VALID_BYTE_VALUE(b))
	{
		m_rNotifyer.reportError("Invalid IP address byte 1: '%d'!", b);
		return;
	}
	if(b == (int)pb[1])
		return;
	pb[1] = (unsigned char)b;
	emit b1Changed(b);
	emit addressChanged(address());
}

void IPv4Address::setB2(int b)
{
	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
	if(!_IS_VALID_BYTE_VALUE(b))
	{
		m_rNotifyer.reportError("Invalid IP address byte 2: '%d'!", b);
		return;
	}
	if(b == (int)pb[2])
		return;
	pb[2] = (unsigned char)b;
	emit b2Changed(b);
	emit addressChanged(address());
}

void IPv4Address::setB3(int b)
{
	unsigned char *pb = (unsigned char*)&m_addr.s_addr;
	if(!_IS_VALID_BYTE_VALUE(b))
	{
		m_rNotifyer.reportError("Invalid IP address byte 3: '%d'!", b);
		return;
	}
	if(b == (int)pb[3])
		return;
	pb[3] = (unsigned char)b;
	emit b3Changed(b);
	emit addressChanged(address());
}