rvaddress.c

基于h323协议的软phone

		if (*++src != ':')
			return RV_FALSE;
	curtok = src;
	saw_xdigit = 0;
	val = 0;
	while ((ch = *src++) != '\0') {
		RvChar *pch;

		if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
			pch = strchr((xdigits = xdigits_u), ch);
		if (pch != NULL) {
			val <<= 4;
			val |= (pch - xdigits);
			if (val > 0xffff)
				return RV_FALSE;
			saw_xdigit = 1;
			continue;
		}
		if (ch == ':') {
			curtok = src;
			if (!saw_xdigit) {
				if (colonp)
					return RV_FALSE;
				colonp = tp;
				continue;
			} else if (*src == '\0') {
				return RV_FALSE;
			}
			if (tp + 2 > endp)
				return RV_FALSE;
			*tp++ = (RvUint8)((val >> 8) & 0xff);
			*tp++ = (RvUint8)(val & 0xff);
			saw_xdigit = 0;
			val = 0;
			continue;
		}
		if (ch == '.' && ((tp + RV_ADDRESS_IPV4_ADDRSIZE) <= endp) &&
			  (Rv_inet_pton4(curtok, tp) == RV_TRUE)) {
			tp += RV_ADDRESS_IPV4_ADDRSIZE;
			saw_xdigit = 0;
			break;	/* '\0' was seen by inet_pton4(). */
		}
		return RV_FALSE;
	}
	if (saw_xdigit) {
		if (tp + 2 > endp)
			return (0);
		*tp++ = (RvUint8)((val >> 8) & 0xff);
		*tp++ = (RvUint8)(val & 0xff);
	}
	if (colonp != NULL) {
		/*
		 * Since some memmove()'s erroneously fail to handle
		 * overlapping regions, we'll do the shift by hand.
		 */
		RvInt n = tp - colonp;
		RvInt i;

		if (tp == endp)
			return RV_FALSE;
		for (i = 1; i <= n; i++) {
			endp[- i] = colonp[n - i];
			colonp[n - i] = 0;
		}
		tp = endp;
	}
	if (tp != endp)
		return RV_FALSE;
	memcpy(dst, tmp, RV_ADDRESS_IPV6_ADDRSIZE);
	return RV_TRUE;
}
/*********************************************************************************/
/* End of code from Internet Software Consortium */


#if defined(RV_TEST_CODE)
#include "rvstdio.h"

typedef struct {
	RvInt addrtype;
	RvChar address[RV_ADDRESS_IPV6_STRINGSIZE];
	RvUint16 port;
} RvAddressTestAddr;

#define RV_ADDRESS_NUMTESTADDR 18
static RvAddressTestAddr testaddresses[] = {
	{ RV_ADDRESS_TYPE_IPV4, "192.168.216.63", RV_ADDRESS_IPV4_ANYPORT },
	{ RV_ADDRESS_TYPE_IPV4, "12.18.216.163", 65000},
	{ RV_ADDRESS_TYPE_IPV4, "0.0.0.0", 0},
	{ RV_ADDRESS_TYPE_IPV6, "1080::8:800:200C:417A", 100},
	{ RV_ADDRESS_TYPE_IPV6, "1080::8:800:200c:417A", 0},
	{ RV_ADDRESS_TYPE_IPV6, "::", 25},
	{ RV_ADDRESS_TYPE_IPV6, "FF01:0:0:0:0:0:0:43", 0},
	{ RV_ADDRESS_TYPE_IPV6, "ff01::43", 10000},
	{ RV_ADDRESS_TYPE_IPV6, "::1", 65535},
	{ RV_ADDRESS_TYPE_IPV4, "245.200.1.1", 1000},
	{ RV_ADDRESS_TYPE_IPV6, "0:0:0:0:0:0:13.1.68.3", 49000},
	{ RV_ADDRESS_TYPE_IPV6, "0:0:0:0:0:ffff:129.144.52.38", 200},
	{ RV_ADDRESS_TYPE_IPV4, "230.0.1.1", 75},
	{ RV_ADDRESS_TYPE_IPV6, "::13.1.68.3", 1},
	{ RV_ADDRESS_TYPE_IPV6, "::FFFF:129.144.52.38", 0},
	{ RV_ADDRESS_TYPE_IPV6, "::FFFF:8190:3426", 15},
	{ RV_ADDRESS_TYPE_IPV6, "12ab:0:0:cd30::", 2},
	{ RV_ADDRESS_TYPE_IPV4, "255.255.255.255", 4545}
};

static char *addresstypenames[] = {
	"None",
	"IPV4",
	"IPV6"
};

void RvAddressTest(void)
{
	int i, count;
	RvAddressTestAddr *testaddr;
	RvAddress addr1, addr2, addr3, addrcopy, *aresult;
	RvUint32 ip4ip, ip4ip2;
	RvUint8 ip6ip[RV_ADDRESS_IPV6_ADDRSIZE], *ip6ip2;
	RvBool bresult;
	RvInt iresult;
	RvChar *cresult, addrbuf[RV_ADDRESS_IPV6_STRINGSIZE];
	RvUint16 port;
	RvAddressIpv4 *ipv4addr;
	RvAddressIpv6 *ipv6addr;

	RvPrintf("Starting test of rvaddress.\n");

	ip4ip = 0; /* prevent warnings. */
	for(i = 0; i < RV_ADDRESS_NUMTESTADDR; i++) {
		testaddr = &testaddresses[i];
		RvPrintf("Testing Address: %s, Port:%u, Type:%s\n", testaddr->address, testaddr->port, addresstypenames[testaddr->addrtype]);

		RvPrintf("RvAddressConstruct: ");
		aresult = RvAddressConstruct(&addr1, testaddr->addrtype);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressSetString: ");
		aresult = RvAddressSetString(&addr1, testaddr->address);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressIsMulticastIp: ");
		bresult = RvAddressIsMulticastIp(&addr1);
		if(bresult == RV_TRUE) {
			RvPrintf("YES\n");
		} else RvPrintf("NO\n");

		RvPrintf("RvAddressConstruct: ");
		aresult = RvAddressConstruct(&addr3, testaddr->addrtype);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		switch(testaddr->addrtype) {
			case RV_ADDRESS_TYPE_IPV4: RvPrintf("RvAddressStringToIpv4: ");
									   bresult = RvAddressStringToIpv4(&ip4ip, testaddr->address);
									   if(bresult == RV_TRUE) {
										   RvPrintf("OK. Result = %08x\n", ip4ip);
										   RvPrintf("RvAddressIpv4ToString: ");
										   cresult = RvAddressIpv4ToString(addrbuf, RV_ADDRESS_IPV4_STRINGSIZE, ip4ip);
										   if(cresult != NULL) {
											   RvPrintf("OK, result = '%s'\n", addrbuf);
										   } else RvPrintf("ERROR\n");
										   RvPrintf("RvAddressConstructIpv4: ");
										   aresult = RvAddressConstructIpv4(&addr2, ip4ip, testaddr->port);
										   if(aresult != NULL) {
											   RvPrintf("OK\n");
										   } else RvPrintf("ERROR\n");
									   } else RvPrintf("ERROR\n");
									   RvPrintf("RvAddressGetIpv4: ");
									   ipv4addr = (RvAddressIpv4*)RvAddressGetIpv4(&addr3);
									   if(ipv4addr == &addr3.data.ipv4) {
										   RvPrintf("OK\n");
										   RvPrintf("RvAddressIpv4SetIp: ");
										   if(RvAddressIpv4SetIp(ipv4addr, ip4ip) != NULL) {
											   RvPrintf("OK\n");
											   RvPrintf("RvAddressIpv4GetIp: ");
											   ip4ip2 = RvAddressIpv4GetIp(ipv4addr);
											   if(ip4ip2 == ip4ip) {
												   RvPrintf("OK\n");
											   } else RvPrintf("ERROR, result = %u\n", ip4ip2);
										   } else RvPrintf("ERROR\n");
									   } else RvPrintf("ERROR\n");
									   break;
			case RV_ADDRESS_TYPE_IPV6: RvPrintf("RvAddressStringToIpv6: ");
									   bresult = RvAddressStringToIpv6(ip6ip, testaddr->address);
									   if(bresult == RV_TRUE) {
										   RvPrintf("OK. Result = ");
										   for(count = 0; count < RV_ADDRESS_IPV6_ADDRSIZE; count++)
											   RvPrintf("%02x", ip6ip[count]);
										   RvPrintf("\n");
										   RvPrintf("RvAddressIpv6ToString: ");
										   cresult = RvAddressIpv6ToString(addrbuf, RV_ADDRESS_IPV6_STRINGSIZE, ip6ip);
										   if(cresult != NULL) {
											   RvPrintf("OK, result = '%s'\n", addrbuf);
										   } else RvPrintf("ERROR\n");
										   RvPrintf("RvAddressConstructIpv6: ");
										   aresult = RvAddressConstructIpv6(&addr2, ip6ip, testaddr->port);
										   if(aresult != NULL) {
											   RvPrintf("OK\n");
										   } else RvPrintf("ERROR\n");
									   } else RvPrintf("ERROR\n");
									   RvPrintf("RvAddressGetIpv6: ");
									   RvPrintf("RvAddressGetIpv4: ");
									   ipv6addr = (RvAddressIpv6*)RvAddressGetIpv6(&addr3);
									   if(ipv6addr == &addr3.data.ipv6) {
										   RvPrintf("OK\n");
										   RvPrintf("RvAddressIpv6SetIp: ");
										   if(RvAddressIpv6SetIp(ipv6addr, ip6ip) != NULL) {
											   RvPrintf("OK\n");
											   RvPrintf("RvAddressIpv6GetIp: ");
											   ip6ip2 = (RvUint8*)RvAddressIpv6GetIp(ipv6addr);
											   if(ip6ip2 == ip6ip) {
												   RvPrintf("OK\n");
											   } else RvPrintf("ERROR, result = %p\n", ip6ip2);
										   } else RvPrintf("ERROR\n");
									   } else RvPrintf("ERROR\n");
									   break;
		}
		
		RvPrintf("RvAddressGetType: ");
		iresult = RvAddressGetType(&addr2);
		if(iresult == testaddr->addrtype) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR, returned %d\n", iresult);

		RvPrintf("RvAddressIsMulticastIp: ");
		bresult = RvAddressIsMulticastIp(&addr2);
		if(bresult == RV_TRUE) {
			RvPrintf("YES\n");
		} else RvPrintf("NO\n");

		RvPrintf("RvAddressCompare(FULLADDRESS) ");
		bresult = RvAddressCompare(&addr1, &addr2, RV_ADDRESS_FULLADDRESS);
		if(testaddr->port != 0) {
			RvPrintf("Should be FALSE: ");
			if(bresult == RV_FALSE) {
				RvPrintf("FALSE, OK\n");
			} else RvPrintf("ERROR, returned TRUE\n");
		} else {
			RvPrintf("Should be TRUE: ");
			if(bresult == RV_TRUE) {
				RvPrintf("TRUE, OK\n");
			} else RvPrintf("ERROR, returned FALSE\n");
		}

		RvPrintf("RvAddressCompare(BASEADDRESS) Should be TRUE: ");
		bresult = RvAddressCompare(&addr1, &addr2, RV_ADDRESS_BASEADDRESS);
		if(bresult == RV_TRUE) {
			RvPrintf("TRUE, OK\n");
		} else RvPrintf("ERROR, returned FALSE\n");

		RvPrintf("RvAddressGetString: ");
		cresult = RvAddressGetString(&addr2, addrbuf, RV_ADDRESS_IPV6_STRINGSIZE);
		if(cresult != NULL) {
			RvPrintf("OK. Result = '%s'\n", addrbuf);
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressCopy: ");
		aresult = RvAddressCopy(&addrcopy, &addr2);
		if(aresult != NULL) {
			RvPrintf("OK\n");
			RvPrintf("Checking copy (RvAddressCompare FULL): ");
			bresult = RvAddressCompare(&addr2, &addrcopy, RV_ADDRESS_FULLADDRESS);
			if(bresult == RV_TRUE) {
				RvPrintf("OK\n");
			} else RvPrintf("ERROR\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressGetIpPort: ");
		port = RvAddressGetIpPort(&addr2);
		if(port == testaddr->port) {
			RvPrintf("OK, result = %u\n", port);
			RvPrintf("RvAddressSetIpPort: ");
			aresult = RvAddressSetIpPort(&addr1, port);
			if(aresult != NULL) {
				RvPrintf("OK\n");
				RvPrintf("Checking result with Compare(FULL): ");
				bresult = RvAddressCompare(&addr1, &addr2, RV_ADDRESS_FULLADDRESS);
				if(bresult == RV_TRUE) {
					RvPrintf("OK\n");
				} else RvPrintf("ERROR\n");
			} else RvPrintf("ERROR\n");
		} else RvPrintf("ERROR, result = %u\n", port);

		RvPrintf("Destructing addresses...\n");
		RvAddressDestruct(&addr1);
		RvAddressDestruct(&addr2);
		RvAddressDestruct(&addr3);
		RvAddressDestruct(&addrcopy);

		RvPrintf("RvAddressConstruct(NONE): ");
		aresult = RvAddressConstruct(&addr1, RV_ADDRESS_TYPE_NONE);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressChangeType(%s): ", addresstypenames[testaddr->addrtype]);
		aresult = RvAddressChangeType(&addr1, testaddr->addrtype);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressSetString: ");
		aresult = RvAddressSetString(&addr1, testaddr->address);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");
		
		RvPrintf("RvAddressSetIpPort: ");
		aresult = RvAddressSetIpPort(&addr1, testaddr->port);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("RvAddressConstruct(NONE): ");
		aresult = RvAddressConstruct(&addr2, RV_ADDRESS_TYPE_NONE);
		if(aresult != NULL) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		switch(testaddr->addrtype) {
			case RV_ADDRESS_TYPE_IPV4: RvPrintf("RvAddressChangeTypeIpv4: ");
									   aresult = RvAddressChangeTypeIpv4(&addr2, ip4ip, testaddr->port);
									   if(aresult != NULL) {
										   RvPrintf("OK\n");
									   } else RvPrintf("ERROR\n");
									   break;
			case RV_ADDRESS_TYPE_IPV6: RvPrintf("RvAddressChangeTypeIpv6: ");
									   aresult = RvAddressChangeTypeIpv6(&addr2, ip6ip, testaddr->port);
									   if(aresult != NULL) {
										   RvPrintf("OK\n");
									   } else RvPrintf("ERROR\n");
									   break;
		}
		RvPrintf("Comparing addresses with RvAddressCompare(FULL): ");
		bresult = RvAddressCompare(&addr1, &addr2, RV_ADDRESS_FULLADDRESS);
		if(bresult == RV_TRUE) {
			RvPrintf("OK\n");
		} else RvPrintf("ERROR\n");

		RvPrintf("Destructing addresses...\n");
		RvAddressDestruct(&addr1);
		RvAddressDestruct(&addr2);

		RvPrintf("Address Test Completed: %s, Port:%u, Type:%s\n", testaddr->address, testaddr->port, addresstypenames[testaddr->addrtype]);
	} /* for loop */
}

#endif /* RV_TEST_CODE */