More renaming & cleanup.

git-svn-id: https://svn.kvirc.de/svn/trunk/kvirc@5233 17fca916-40b9-46aa-a4ea-0a15b648b75c

1 files changed, 797 insertions, 0 deletions

diff --git a/src/kvilib/net/KviNetUtils.cpp b/src/kvilib/net/KviNetUtils.cpp
new file mode 100644
index 000000000..4e4edcfa2
--- /dev/null
+++ b/src/kvilib/net/KviNetUtils.cpp
@@ -0,0 +1,797 @@
+//=============================================================================
+//
+//   File : KviNetUtils.cpp
+//   Creation date : Sun Jun 18 2000 18:37:27 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2000-2010 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define _KVI_NETUTILS_CPP_
+
+#define NTDDI_VERSION NTDDI_WINXP
+
+#ifndef _WIN32_WINNT
+	#define _WIN32_WINNT _WIN32_WINNT_WINXP
+#endif
+
+#include "KviNetUtils.h"
+#include "kvi_memmove.h"
+
+#include <QStringList>
+
+#if !defined(COMPILE_ON_WINDOWS) && !defined(COMPILE_ON_MINGW)
+	#include <sys/time.h> // struct timeval
+	#include <unistd.h>
+	#include <netdb.h>
+#endif
+
+#ifdef COMPILE_ON_WINDOWS
+	#include <Ws2tcpip.h>
+#endif
+
+#include <sys/types.h>
+#include "KviQString.h"
+
+#ifdef COMPILE_GET_INTERFACE_ADDRESS
+	#include <sys/ioctl.h>
+	#include <net/if.h>
+#endif //COMPILE_GET_INTERFACE_ADDRESS
+
+#ifndef HAVE_INET_ATON
+
+
+// FIXME: #warning "Your system lacks the inet_aton function,"
+// FIXME: #warning "you're trying to compile this file without"
+// FIXME: #warning "the kvi_sysconfig.h created by the cmake script,"
+// FIXME: #warning "Using own internal implementation of inet_aton."
+
+#include <ctype.h>
+
+// Need own inet_aton implementation
+//
+// Check whether "cp" is a valid ascii representation
+// of an Internet address and convert to a binary address.
+// Returns 1 if the address is valid, 0 if not.
+// This replaces inet_addr, the return value from which
+// cannot distinguish between failure and a local broadcast address.
+//
+// Original code comes from the ircd source.
+//
+
+bool kvi_stringIpToBinaryIp(const char *szIp,struct in_addr *address)
+{
+	register unsigned long val;
+	register int base, n;
+	register char c;
+	unsigned int parts[4];
+	register unsigned int *pp = parts;
+	if(!szIp)return false;
+	c = *szIp;
+	for(;;){
+		// Collect number up to ``.''.
+		// Values are specified as for C:
+		// 0x=hex, 0=octal, isdigit=decimal.
+		if(!isdigit(c))return false;
+		val  = 0;
+		base = 10;
+
+		if(c == '0'){
+			c = *++szIp;
+			if((c == 'x')||(c == 'X'))base = 16, c = *++szIp;
+			else base = 8;
+		}
+
+		for (;;) {
+			if(isascii(c) && isdigit(c)) {
+				val = (val * base) + (c - '0');
+				c   = *++szIp;
+			} else if (base == 16 && isascii(c) && isxdigit(c)) {
+				val = (val << 4) | (c + 10 - (islower(c) ? 'a' : 'A'));
+				c   = *++szIp;
+			} else break;
+		}
+
+		if(c == '.'){
+			// Internet format:
+			//	a.b.c.d
+			//	a.b.c	(with c treated as 16 bits)
+			//	a.b	(with b treated as 24 bits)
+
+			if(pp >= (parts + 3)) return false;
+			*pp++ = val;
+			c     = *++szIp;
+		} else break;
+	}
+
+	// Check for trailing characters.
+	if ((c != '\0') && (!isascii(c) || !isspace(c)))return false;
+
+	// Concact the address according to
+	// the number of parts specified.
+	n = pp - parts + 1;
+
+	switch (n) {
+		case 0: return false; // initial nondigit
+		case 1:	break;        // a -- 32 bits
+		case 2:               // a.b -- 8.24 bits
+			if(val > 0xffffff) return false;
+			val |= parts[0] << 24;
+			break;
+		case 3:               // a.b.c -- 8.8.16 bits
+			if(val > 0xffff)return false;
+			val |= (parts[0] << 24) | (parts[1] << 16);
+			break;
+		case 4:               // a.b.c.d -- 8.8.8.8 bits
+			if(val > 0xff)return false;
+			val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+			break;
+	}
+
+	if(address)address->s_addr = htonl(val);
+	return true;
+
+}
+
+#else //!HAVE_INET_ATON
+
+bool kvi_stringIpToBinaryIp(const char *szIp,struct in_addr *address)
+{
+	if(!szIp)return false;
+	return (inet_aton(szIp,address) != 0);
+}
+#endif //!HAVE_INET_ATON
+
+
+
+#ifndef HAVE_INET_NTOA
+
+// FIXME: #warning "Your system lacks the inet_ntoa function,"
+// FIXME: #warning "you're trying to compile this file without"
+// FIXME: #warning "the config.h created by the configure script,"
+// FIXME: #warning "Using own internal implementation of inet_ntoa."
+
+//
+// Original code comes from the ircd source.
+//
+
+
+bool kvi_binaryIpToStringIp(struct in_addr in,QString &szBuffer)
+{
+	unsigned char *s = (unsigned char *)&in;
+	int	a,b,c,d;
+	a = (int)*s++;
+	b = (int)*s++;
+	c = (int)*s++;
+	d = (int)*s;
+
+	szBuffer.sprintf("%d.%d.%d.%d", a,b,c,d );
+	return true;
+}
+
+#else //HAVE_INET_NTOA
+
+bool kvi_binaryIpToStringIp(struct in_addr in,QString &szBuffer)
+{
+// FIXME: #warning "This is NOT thread safe!"
+
+	char * ptr = inet_ntoa(in);
+	if(!ptr)return false;
+	szBuffer = ptr;
+	return true;
+}
+
+#endif //HAVE_INET_NTOA
+
+bool kvi_isValidStringIp(const char *szIp)
+{
+	struct in_addr address;
+	if(!szIp)return false;
+	if(!isdigit(*szIp))return false;
+	return kvi_stringIpToBinaryIp(szIp,&address);
+}
+
+#ifdef COMPILE_IPV6_SUPPORT
+
+#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
+
+static unsigned int scan_ip6(const char *s,char ip[16])
+{
+	unsigned int i;
+	unsigned int len=0;
+	unsigned long u;
+
+	char suffix[16];
+	unsigned int prefixlen=0;
+	unsigned int suffixlen=0;
+
+	for (i=0; i<16; i++) ip[i]=0;
+
+	for (;;) {
+		if (*s == ':') {
+			len++;
+			if (s[1] == ':') {    /* Found "::", skip to part 2 */
+				s+=2;
+				len++;
+				break;
+			}
+			s++;
+		}
+
+		{
+			char *tmp;
+			u=strtoul(s,&tmp,16);
+			i=tmp-s;
+		}
+
+		if (!i) return 0;
+		if (prefixlen==12 && s[i]=='.') {
+			/* the last 4 bytes may be written as IPv4 address */
+			if (kvi_stringIpToBinaryIp(s,(struct in_addr*)(ip+12)))
+				return i+len;
+			else
+				return 0;
+		}
+
+		ip[prefixlen++] = (u >> 8);
+		ip[prefixlen++] = (u & 255);
+
+		s += i; len += i;
+
+		if (prefixlen==16) return len;
+	}
+
+	/* part 2, after "::" */
+
+	for (;;) {
+		if (*s == ':') {
+			if (suffixlen==0) break;
+			s++;
+			len++;
+		} else if (suffixlen!=0) break;
+
+		{
+			char *tmp;
+			u=strtol(s,&tmp,16);
+			i=tmp-s;
+		}
+
+		if (!i) {
+			if (*s) len--;
+			break;
+		}
+
+		if (suffixlen+prefixlen<=12 && s[i]=='.') {
+
+			if (kvi_stringIpToBinaryIp(s,(struct in_addr*)(suffix+suffixlen))) {
+				suffixlen+=4;
+				len+=(unsigned int)strlen(s);
+				break;
+			} else prefixlen=12-suffixlen;        /* make end-of-loop test true */
+		}
+
+		suffix[suffixlen++] = (u >> 8);
+		suffix[suffixlen++] = (u & 255);
+		s += i; len += i;
+		if (prefixlen+suffixlen==16) break;
+	}
+
+	for (i=0; i<suffixlen; i++)
+		ip[16-suffixlen+i] = suffix[i];
+
+	return len;
+}
+
+int inet_pton(int AF, const char *CP, void *BUF) {
+	int len;
+	if (AF==AF_INET) {
+		if (!kvi_stringIpToBinaryIp(CP,(struct in_addr*)BUF))
+		return 0;
+	} else if (AF==AF_INET6) {
+		if (CP[len=scan_ip6(CP,(char *)BUF)])
+		return 0;
+	} else {
+		errno=WSAEPFNOSUPPORT;
+		return -1;
+	}
+	return 1;
+}
+
+static const unsigned char V4mappedprefix[12]={0,0,0,0,0,0,0,0,0,0,0xff,0xff};
+
+static char tohex(char hexdigit) {
+	return hexdigit>9?hexdigit+'a'-10:hexdigit+'0';
+}
+
+static int fmt_xlong(char* s,unsigned int i)
+{
+	char* bak=s;
+	*s=tohex((i>>12)&0xf); if (s!=bak || *s!='0') ++s;
+	*s=tohex((i>>8)&0xf); if (s!=bak || *s!='0') ++s;
+	*s=tohex((i>>4)&0xf); if (s!=bak || *s!='0') ++s;
+	*s=tohex(i&0xf);
+	return s-bak+1;
+}
+
+static unsigned int i2a(char* dest,unsigned int x)
+{
+	register unsigned int tmp=x;
+	register unsigned int len=0;
+
+	if (x>=100) { *dest++=tmp/100+'0'; tmp=tmp%100; ++len; }
+	if (x>=10) { *dest++=tmp/10+'0'; tmp=tmp%10; ++len; }
+	*dest++=tmp+'0';
+	return len+1;
+}
+
+char *inet_ntoa_r(struct in_addr in,char* buf)
+{
+	unsigned int len;
+	unsigned char *ip=(unsigned char*)&in;
+
+	len=i2a(buf,ip[0]); buf[len]='.'; ++len;
+	len+=i2a(buf+ len,ip[1]); buf[len]='.'; ++len;
+	len+=i2a(buf+ len,ip[2]); buf[len]='.'; ++len;
+	len+=i2a(buf+ len,ip[3]); buf[len]=0;
+	return buf;
+}
+
+unsigned int fmt_ip6(char *s,const char ip[16])
+{
+	unsigned int len;
+	unsigned int i;
+	unsigned int temp;
+	unsigned int compressing; // 0 not compressing, 1 compressing now, 2 already compressed once
+
+	len = 0;
+	compressing = 0;
+
+	for(int j=0;j<16;j+=2)
+	{
+		if (j==12 && !memcmp(ip,V4mappedprefix,12))
+		{
+			inet_ntoa_r(*(struct in_addr*)(ip+12),s);
+			temp=(unsigned int)strlen(s);
+			return len+temp;
+		}
+
+		temp = ((unsigned long) (unsigned char) ip[j] << 8) + (unsigned long) (unsigned char) ip[j+1];
+
+		if(temp == 0)
+		{
+			if(compressing == 0)
+			{
+				compressing=1;
+				if (j==0)
+				{
+					*s++=':';
+					++len;
+				}
+			}
+		} else {
+			if(compressing == 1)
+			{
+				compressing=2; // don't do it again
+				*s++=':'; ++len;
+			}
+
+			i = fmt_xlong(s,temp);
+			len += i;
+			s += i;
+
+			if (j<14)
+			{
+				*s++ = ':';
+				++len;
+			}
+		}
+	}
+
+	if(compressing == 1)
+	{
+		*s++=':';
+		++len;
+	}
+
+	*s=0;
+	return len;
+}
+
+const char* inet_ntop(int AF, const void *CP, char *BUF, size_t LEN)
+{
+	char buf[100];
+	size_t len;
+
+	if (AF==AF_INET)
+	{
+		inet_ntoa_r(*(struct in_addr*)CP,buf);
+		len=strlen(buf);
+	} else if (AF==AF_INET6)
+
+	{
+		len=fmt_ip6(buf,(char *)CP);
+	} else return 0;
+
+	if (len<LEN)
+	{
+		strcpy(BUF,buf);
+		return BUF;
+	}
+	return 0;
+}
+#endif
+
+bool kvi_binaryIpToStringIp_V6(struct in6_addr in,QString &szBuffer)
+{
+	char buf[46];
+	bool bRet =  inet_ntop(AF_INET6,(void *)&in,buf,46);
+
+	szBuffer= buf;
+	return bRet;
+}
+
+#endif
+
+#include <errno.h>
+
+bool kvi_select(int fd,bool * bCanRead,bool * bCanWrite,int iUSecs)
+{
+	// FIXME: This stuff should DIE!
+	fd_set rs;
+	fd_set ws;
+	FD_ZERO(&rs);
+	FD_ZERO(&ws);
+	FD_SET(fd,&rs);
+	FD_SET(fd,&ws);
+	struct timeval tv;
+
+	tv.tv_sec = 0;
+	tv.tv_usec = iUSecs;
+
+	int ret = select(fd + 1,&rs,&ws,0,&tv);
+	if(ret < 1)return false; // EINTR or ENOSTUFFATALL
+
+	*bCanRead = FD_ISSET(fd,&rs);
+	*bCanWrite = FD_ISSET(fd,&ws);
+
+	return true;
+}
+
+namespace KviNetUtils
+{
+	bool stringIpToBinaryIp(const QString &szStringIp,struct in_addr * address)
+	{
+#ifndef HAVE_INET_ATON
+		QString szAddr = szStringIp.simplified();
+		quint32 iAddr=0;
+		QStringList ipv4 = szAddr.split(".", QString::KeepEmptyParts, Qt::CaseInsensitive);
+		if (ipv4.count() == 4) {
+			int i = 0;
+			bool ok = TRUE;
+			while(ok && i < 4) {
+				uint byteValue = ipv4[i].toUInt(&ok);
+				if ( (byteValue > 255) && ok )
+					ok = FALSE;
+				if (ok)
+					iAddr = (iAddr << 8) + byteValue;
+				++i;
+			}
+			if (ok)
+			{
+				if(address)address->s_addr = htonl(iAddr);
+				return true;
+			}
+		}
+		return FALSE;
+#else //HAVE_INET_ATON
+		if(szStringIp.isEmpty())return false;
+		return (inet_aton(KviQString::toUtf8(szStringIp).data(),address) != 0);
+#endif //HAVE_INET_ATON
+	}
+
+
+	bool isValidStringIp(const QString &szIp)
+	{
+		struct in_addr address;
+		if(szIp.isEmpty())return false;
+		if(!szIp[0].isNumber())return false;
+		return stringIpToBinaryIp(szIp,&address);
+	}
+
+
+#ifdef COMPILE_IPV6_SUPPORT
+	bool stringIpToBinaryIp_V6(const QString &szStringIp,struct in6_addr * address)
+	{
+		return (inet_pton(AF_INET6,KviQString::toUtf8(szStringIp).data(),(void *)address) == 1);
+	}
+
+	bool isValidStringIPv6(const QString &szIp)
+	{
+		struct in6_addr address;
+		if(szIp.isEmpty())return false;
+		return stringIpToBinaryIp_V6(szIp,&address);
+	}
+
+	bool binaryIpToStringIp_V6(struct in6_addr in,QString &szBuffer)
+	{
+		char buf[46];
+		bool bRet =  inet_ntop(AF_INET6,(void *)&in,buf,46);
+		szBuffer= buf;
+		return bRet;
+	}
+
+#endif //COMPILE_IPV6_SUPPORT
+
+	bool binaryIpToStringIp(struct in_addr in,QString &szBuffer)
+	{
+		char * ptr = inet_ntoa(in);
+		if(!ptr)return false;
+		szBuffer = ptr;
+		return true;
+	}
+
+	bool isRoutableIpString(const QString &szIpString)
+	{
+		struct in_addr a;
+		if(szIpString.isEmpty())return false;
+		stringIpToBinaryIp(szIpString,&a);
+		return isRoutableIp((const char *)&a);
+	}
+
+	bool isRoutableIp(const char * ipaddr)
+	{
+		if(!ipaddr)return false;
+		const unsigned char * ip = (const unsigned char *)ipaddr;
+		if(ip[0] == 0)return false;    // old-style broadcast
+		if(ip[0] == 10)return false;   // Class A VPN
+		if(ip[0] == 127)return false;   // loopback
+		if((ip[0] == 172) && (ip[1] >= 16) && (ip[1] <= 31))return false; // Class B VPN
+		if((ip[0] == 192) && (ip[1] == 168))return false; // Class C VPN
+		if((ip[0] == 169) && (ip[1] == 254))return false; // APIPA
+		if((ip[0] == 192) && (ip[1] == 0) && (ip[2] == 2))return false; // Class B VPN
+		if(ip[0] >= 224)return false; // class D multicast and class E reserved
+
+		return true;
+	}
+
+#ifdef COMPILE_GET_INTERFACE_ADDRESS
+	union sockaddr_union {
+		struct sockaddr sa;
+		struct sockaddr_in sin;
+	};
+
+	bool getInterfaceAddress(const QString &szInterfaceName,QString &szBuffer)
+	{
+		union sockaddr_union *su;
+		struct ifreq ifr;
+		int len = szInterfaceName.length();
+		if(len > (IFNAMSIZ - 1))return false; // invalid interface anyway
+
+		kvi_memmove(ifr.ifr_name,KviQString::toUtf8(szInterfaceName).data(),len + 1);
+
+		int fd = socket(AF_INET,SOCK_STREAM,0);
+		if(fd < 0)return false;
+
+		if(ioctl(fd,SIOCGIFADDR,&ifr) == -1)return false; // supports only IPV4 ?
+
+		close(fd);
+
+		su = (union sockaddr_union *)&(ifr.ifr_addr);
+
+		if (su->sa.sa_family != AF_INET) return false;
+
+		return binaryIpToStringIp((struct in_addr)su->sin.sin_addr,szBuffer);
+
+		// (this seems to work for AF_INET only anyway)
+#else //!COMPILE_GET_INTERFACE_ADDRESS
+	bool getInterfaceAddress(const QString &,QString &)
+	{
+		return false;
+#endif //!COMPILE_GET_INTERFACE_ADDRESS
+	}
+
+	void formatNetworkBandwidthString(QString &szBuffer,unsigned int uBytesPerSec)
+	{
+		if(uBytesPerSec > (1024 * 1024))
+		{
+			unsigned int uMB = uBytesPerSec / (1024 * 1024);
+			unsigned int uRem = ((uBytesPerSec % (1024 * 1024)) * 100) / (1024 * 1024);
+
+			KviQString::sprintf(szBuffer,"%u.%u%u MiB/s",uMB,uRem / 10,uRem % 10);
+
+			return;
+		}
+
+		if(uBytesPerSec >= 1024)
+		{
+			unsigned int uKB = uBytesPerSec / 1024;
+			unsigned int uRem = ((uBytesPerSec % 1024) * 100) / 1024;
+
+			KviQString::sprintf(szBuffer,"%u.%u%u KiB/s",uKB,uRem / 10,uRem % 10);
+
+			return;
+		}
+
+		KviQString::sprintf(szBuffer,"%u B/s",uBytesPerSec);
+
+	}
+}
+
+bool kvi_isRoutableIpString(const char * ipstring)
+{
+	struct in_addr a;
+	if(!ipstring)return false;
+	kvi_stringIpToBinaryIp(ipstring,&a);
+	return kvi_isRoutableIp((const char *)&a);
+}
+
+bool kvi_isRoutableIp(const char * ipaddr)
+{
+	if(!ipaddr)return false;
+	const unsigned char * ip = (const unsigned char *)ipaddr;
+
+	if(ip[0] == 0)return false;    // old-style broadcast
+	if(ip[0] == 10)return false;   // Class A VPN
+	if(ip[0] == 127)return false;   // loopback
+	if((ip[0] == 172) && (ip[1] >= 16) && (ip[1] <= 31))return false; // Class B VPN
+	if((ip[0] == 192) && (ip[1] == 168))return false; // Class C VPN
+	if((ip[0] == 169) && (ip[1] == 254))return false; // APIPA
+	if((ip[0] == 192) && (ip[1] == 0) && (ip[2] == 2))return false; // Class B VPN
+	if(ip[0] >= 224)return false; // class D multicast and class E reserved
+
+	return true;
+}
+
+bool kvi_getLocalHostAddress(QString &buffer)
+{
+	// This will work only on windoze...
+	char buf[1024];
+	if(gethostname(buf,1024) != 0)return false;
+	struct hostent * h = gethostbyname(buf);
+	if(!h)return false;
+	QString tmp;
+	int i=0;
+	while(h->h_addr_list[i])
+	{
+		if(kvi_binaryIpToStringIp(*((struct in_addr *)(h->h_addr_list[i])),tmp))
+		{
+			if(kvi_isRoutableIp(h->h_addr_list[i]))
+			{
+				buffer = tmp;
+				return true;
+			}
+		}
+		i++;
+	}
+
+	buffer = tmp;
+	return true;
+}
+
+KviSockaddr::KviSockaddr(const char * szIpAddress,kvi_u32_t uPort,bool bIPv6,bool bUdp)
+{
+	struct addrinfo hints;
+	kvi_memset((void *)&hints,0,sizeof(hints));
+	hints.ai_flags = AI_NUMERICHOST;
+#ifdef COMPILE_IPV6_SUPPORT
+	hints.ai_family = bIPv6 ? PF_INET6 : PF_INET;
+#else
+	hints.ai_family = PF_INET;
+#endif
+
+	hints.ai_socktype = bUdp ? SOCK_DGRAM : SOCK_STREAM;
+
+	hints.ai_protocol = 0;
+	m_pData = 0;
+	KviCString szPort(KviCString::Format,"%u",uPort);
+	getaddrinfo(szIpAddress,szPort.ptr(),&hints,&m_pData);
+}
+
+KviSockaddr::KviSockaddr(kvi_u32_t uPort,bool bIPv6,bool bUdp) // passive sockaddr
+
+{
+	struct addrinfo hints;
+	kvi_memset((void *)&hints,0,sizeof(hints));
+	hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
+#ifdef COMPILE_IPV6_SUPPORT
+	hints.ai_family = bIPv6 ? PF_INET6 : PF_INET;
+#else
+	hints.ai_family = PF_INET;
+#endif
+	hints.ai_socktype = bUdp ? SOCK_DGRAM : SOCK_STREAM;
+	hints.ai_protocol = 0;
+	m_pData = 0;
+	KviCString szPort(KviCString::Format,"%u",uPort);
+	getaddrinfo(0,szPort.ptr(),&hints,&m_pData);
+}
+
+KviSockaddr::~KviSockaddr()
+{
+	if(m_pData)
+	{
+		freeaddrinfo(m_pData);
+		m_pData = 0;
+	}
+}
+
+struct sockaddr * KviSockaddr::socketAddress()
+{
+	if(!m_pData)return 0;
+	return (m_pData)->ai_addr;
+}
+
+size_t KviSockaddr::addressLength()
+{
+	if(!m_pData)return 0;
+	return (m_pData)->ai_addrlen;
+}
+
+int KviSockaddr::addressFamily()
+{
+	if(!m_pData)return 0;
+	return (m_pData)->ai_family;
+}
+
+bool KviSockaddr::isIPv6()
+{
+	if(!m_pData)return false;
+#ifdef COMPILE_IPV6_SUPPORT
+	return false;
+#else
+	return (addressFamily() == AF_INET6);
+#endif
+}
+
+kvi_u32_t KviSockaddr::port()
+{
+	if(!m_pData)return 0;
+#ifdef COMPILE_IPV6_SUPPORT
+	switch(m_pData->ai_family)
+	{
+		case AF_INET:
+			return ntohs(((struct sockaddr_in *)(m_pData->ai_addr))->sin_port);
+			break;
+		case AF_INET6:
+			return ntohs(((struct sockaddr_in6 *)(m_pData->ai_addr))->sin6_port);
+			break;
+	}
+	return 0;
+#else
+	return ntohs(((struct sockaddr_in *)(m_pData->ai_addr))->sin_port);
+#endif
+}
+
+bool KviSockaddr::getStringAddress(QString &szBuffer)
+{
+	if(!m_pData)return 0;
+#ifdef COMPILE_IPV6_SUPPORT
+	switch(((struct addrinfo *)m_pData)->ai_family)
+	{
+		case AF_INET:
+			return kvi_binaryIpToStringIp(((struct sockaddr_in *)(m_pData->ai_addr))->sin_addr,szBuffer);
+			break;
+		case AF_INET6:
+			return kvi_binaryIpToStringIp_V6(((struct sockaddr_in6 *)(m_pData->ai_addr))->sin6_addr,szBuffer);
+			break;
+	}
+
+	return false;
+#else
+	return kvi_binaryIpToStringIp(((struct sockaddr_in *)(m_pData->ai_addr))->sin_addr,szBuffer);
+#endif
+}