Added two patches to allow building with gcc-2.95.3. Approved by wiz.

3 files changed, 1036 insertions, 1 deletions

diff --git a/net/gnugk/distinfo b/net/gnugk/distinfo
index 3ad80476bdc..6bc286aba15 100644
--- a/net/gnugk/distinfo
+++ b/net/gnugk/distinfo
@@ -1,6 +1,8 @@
-$NetBSD: distinfo,v 1.3 2005/02/24 12:13:48 agc Exp $
+$NetBSD: distinfo,v 1.4 2005/03/16 12:55:02 rillig Exp $
 
 SHA1 (gnugk-2.2.0.tgz) = 27bf0fe7f2d7952233eb3522d55618269770a6ef
 RMD160 (gnugk-2.2.0.tgz) = 4484786e84bb2af689f7721935951032ab01a5c4
 Size (gnugk-2.2.0.tgz) = 627215 bytes
 SHA1 (patch-aa) = e7f9f1b31bed309224eac1a84db2207c36e3e3f5
+SHA1 (patch-ab) = e6aca39584c895e8e319ce63eeaf30b43cbb688b
+SHA1 (patch-ac) = 8c00f65da52e93bbbcc5f44a9a50a9f0f9272aff
diff --git a/net/gnugk/patches/patch-ab b/net/gnugk/patches/patch-ab
new file mode 100644
index 00000000000..2b0896cc5f4
--- /dev/null
+++ b/net/gnugk/patches/patch-ab
@@ -0,0 +1,887 @@
+$NetBSD: patch-ab,v 1.1 2005/03/16 12:55:02 rillig Exp $
+
+--- radproto.cxx.orig	Tue Aug 10 01:32:11 2004
++++ radproto.cxx	Wed Mar 16 12:38:12 2005
+@@ -238,16 +238,20 @@ unsigned GetRadiusInteger(
+ } // anonymous namespace
+ 
+ 
+-RadiusAttr::RadiusAttr() : m_type(0), m_length(0)
++RadiusAttr::RadiusAttr()
+ {
++	s.m_type = 0;
++	s.m_length = 0;
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	unsigned char attrType, /// type of the attribute
+ 	const void* attrValue, /// actual attribute value data
+ 	PINDEX valueLength /// length for the attribute value
+-	) : m_type(attrType), m_length(FixedHeaderLength)
++	)
+ {
++	s.m_type = attrType;
++	s.m_length = FixedHeaderLength;
+ 	if (valueLength > 0)
+ 		PAssertNULL(attrValue);
+ 
+@@ -259,9 +263,9 @@ RadiusAttr::RadiusAttr( 
+ 		valueLength = MaxValueLength;
+ 
+ 	if (valueLength > 0) {
+-		m_length = m_length + (unsigned char)valueLength;
++		s.m_length = s.m_length + (unsigned char)valueLength;
+ 		if (attrValue != NULL)
+-			memcpy(m_value, attrValue, valueLength);
++			memcpy(s.m_value, attrValue, valueLength);
+ 	}
+ }
+ 
+@@ -270,10 +274,13 @@ RadiusAttr::RadiusAttr(
+ 	PINDEX valueLength, /// data length (bytes)
+ 	int vendorId, /// 32 bit vendor identifier
+ 	unsigned char vendorType /// vendor-specific attribute type
+-	) : m_type(VendorSpecific), m_length(VsaRfc2865FixedHeaderLength),
+-		m_vendorType(vendorType), m_vendorLength(2)
++	)
+ {
+-	SetRadiusInteger(m_vendorId, vendorId);
++	s.m_type = VendorSpecific;
++	s.m_length = VsaRfc2865FixedHeaderLength;
++	s.s.m_vendorType = vendorType;
++	s.s.m_vendorLength = 2;
++	SetRadiusInteger(s.s.m_vendorId, vendorId);
+ 	
+ 	if (valueLength > 0)
+ 		PAssertNULL(attrValue);
+@@ -286,18 +293,20 @@ RadiusAttr::RadiusAttr(
+ 		valueLength = VsaMaxRfc2865ValueLength;
+ 	
+ 	if (valueLength > 0) {
+-		m_length = m_length + (unsigned char)valueLength;
+-		m_vendorLength = m_vendorLength + (unsigned char)valueLength;
++		s.m_length = s.m_length + (unsigned char)valueLength;
++		s.s.m_vendorLength = s.s.m_vendorLength + (unsigned char)valueLength;
+ 		if (attrValue != NULL)
+-			memcpy(m_vendorValue, attrValue, valueLength);
++			memcpy(s.s.m_vendorValue, attrValue, valueLength);
+ 	}
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	unsigned char attrType, /// Attribute Type (see #enum AttrTypes#)
+ 	const PString& stringValue /// string to be stored in the attribute Value data
+-	) : m_type(attrType), m_length(FixedHeaderLength)
++	) 
+ {
++	s.m_type = attrType;
++	s.m_length = FixedHeaderLength;
+ 	if (attrType == VendorSpecific)
+ 		PAssertAlways(PInvalidParameter);
+ 
+@@ -307,46 +316,53 @@ RadiusAttr::RadiusAttr( 
+ 		attrLength = MaxValueLength;
+ 
+ 	if (attrLength > 0) {
+-		m_length = m_length + (unsigned char)attrLength;
+-		memcpy(m_value, (const char*)stringValue, attrLength);
++		s.m_length = s.m_length + (unsigned char)attrLength;
++		memcpy(s.m_value, (const char*)stringValue, attrLength);
+ 	}
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	unsigned char attrType, /// Attribute Type (see #enum AttrTypes#)
+ 	int intValue /// 32 bit integer to be stored in the attribute Value
+-	) : m_type(attrType), m_length(FixedHeaderLength + 4)
++	)
+ {
++	s.m_type = attrType;
++	s.m_length = FixedHeaderLength + 4;
+ 	if (attrType == VendorSpecific)
+ 		PAssertAlways(PInvalidParameter);
+ 
+-	SetRadiusInteger(m_value, intValue);
++	SetRadiusInteger(s.m_value, intValue);
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	unsigned char attrType, /// Attribute Type (see #enum AttrTypes#)
+ 	const PIPSocket::Address& addressValue /// IPv4 address to be stored in the attribute Value
+-	) : m_type(attrType), m_length(FixedHeaderLength + 4)
++	)
+ {
++	s.m_type = attrType;
++	s.m_length = FixedHeaderLength + 4;
+ 	if (attrType == VendorSpecific)
+ 		PAssertAlways(PInvalidParameter);
+ 
+ 	const DWORD addr = (DWORD)addressValue;
+ 	
+-	m_value[0] = ((const BYTE*)&addr)[0];
+-	m_value[1] = ((const BYTE*)&addr)[1];
+-	m_value[2] = ((const BYTE*)&addr)[2];
+-	m_value[3] = ((const BYTE*)&addr)[3];
++	s.m_value[0] = ((const BYTE*)&addr)[0];
++	s.m_value[1] = ((const BYTE*)&addr)[1];
++	s.m_value[2] = ((const BYTE*)&addr)[2];
++	s.m_value[3] = ((const BYTE*)&addr)[3];
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	const PString& stringValue, /// string to be stored in the attribute Value
+ 	int vendorId, /// 32 bit vendor identifier
+ 	unsigned char vendorType /// vendor-specific attribute type
+-	) : m_type(VendorSpecific), m_length(VsaRfc2865FixedHeaderLength),
+-		m_vendorType(vendorType), m_vendorLength(2)
++	)
+ {
+-	SetRadiusInteger(m_vendorId, vendorId);
++	s.m_type = VendorSpecific;
++	s.m_length = VsaRfc2865FixedHeaderLength;
++	s.s.m_vendorType = vendorType;
++	s.s.m_vendorLength = 2;
++	SetRadiusInteger(s.s.m_vendorId, vendorId);
+ 	
+ 	PINDEX vsaLength = stringValue.GetLength();
+ 
+@@ -357,9 +373,9 @@ RadiusAttr::RadiusAttr( 
+ 		vsaLength = VsaMaxRfc2865ValueLength;
+ 
+ 	if (vsaLength > 0) {
+-		m_length = m_length + (unsigned char)vsaLength;
+-		m_vendorLength = m_vendorLength + (unsigned char)vsaLength;
+-		memcpy(m_vendorValue, (const char*)stringValue, vsaLength);
++		s.m_length = s.m_length + (unsigned char)vsaLength;
++		s.s.m_vendorLength = s.s.m_vendorLength + (unsigned char)vsaLength;
++		memcpy(s.s.m_vendorValue, (const char*)stringValue, vsaLength);
+ 	}
+ }
+ 
+@@ -367,71 +383,82 @@ RadiusAttr::RadiusAttr( 
+ 	int intValue, /// 32 bit integer to be stored in the attribute Value
+ 	int vendorId, /// 32 bit vendor identifier
+ 	unsigned char vendorType /// vendor-specific attribute type
+-	) : m_type(VendorSpecific), m_length(VsaRfc2865FixedHeaderLength + 4),
+-		m_vendorType(vendorType), m_vendorLength(2 + 4)
++	)
+ {
+-	SetRadiusInteger(m_vendorId, vendorId);
+-	SetRadiusInteger(m_vendorValue, intValue);
++	s.m_type=VendorSpecific;
++	s.m_length=VsaRfc2865FixedHeaderLength + 4;
++	s.s.m_vendorType=vendorType;
++	s.s.m_vendorLength=2 + 4;
++	SetRadiusInteger(s.s.m_vendorId, vendorId);
++	SetRadiusInteger(s.s.m_vendorValue, intValue);
+ }
+ 
+ RadiusAttr::RadiusAttr( 
+ 	const PIPSocket::Address& addressValue, /// IPv4 address to be stored in the attribute Value
+ 	int vendorId, /// 32 bit vendor identifier
+ 	unsigned char vendorType /// vendor-specific attribute type
+-	) : m_type(VendorSpecific), m_length(VsaRfc2865FixedHeaderLength + 4),
+-		m_vendorType(vendorType), m_vendorLength(2 + 4)
++	)
+ {
+-	SetRadiusInteger(m_vendorId, vendorId);
++	s.m_type = VendorSpecific;
++	s.m_length = VsaRfc2865FixedHeaderLength + 4;
++	s.s.m_vendorType = vendorType;
++	s.s.m_vendorLength = 2 + 4;
++	SetRadiusInteger(s.s.m_vendorId, vendorId);
+ 	
+ 	const DWORD addr = (DWORD)addressValue;
+ 	
+-	m_vendorValue[0] = ((BYTE*)&addr)[0];
+-	m_vendorValue[1] = ((BYTE*)&addr)[1];
+-	m_vendorValue[2] = ((BYTE*)&addr)[2];
+-	m_vendorValue[3] = ((BYTE*)&addr)[3];
++	s.s.m_vendorValue[0] = ((BYTE*)&addr)[0];
++	s.s.m_vendorValue[1] = ((BYTE*)&addr)[1];
++	s.s.m_vendorValue[2] = ((BYTE*)&addr)[2];
++	s.s.m_vendorValue[3] = ((BYTE*)&addr)[3];
+ }
+ 
+ RadiusAttr::RadiusAttr(
+ 	unsigned char type, /// Cisco-specific attribute type
+ 	bool vsaHack, /// true to not prepend attribute name to its value
+ 	const PString& stringValue /// string to be stored in the attribute Value
+-	) : m_type(VendorSpecific), m_length(VsaRfc2865FixedHeaderLength),
+-		m_vendorType(type), m_vendorLength(2)
++	)
+ {
+-	SetRadiusInteger(m_vendorId, CiscoVendorId);
++	s.m_type = VendorSpecific;
++	s.m_length = VsaRfc2865FixedHeaderLength;
++	s.s.m_vendorType = type;
++	s.s.m_vendorLength = 2;
++	SetRadiusInteger(s.s.m_vendorId, CiscoVendorId);
+ 	if (!vsaHack) {
+ 		int i = 0;
+ 		while (CiscoAttrNames[i].m_name != NULL)
+ 			if (CiscoAttrNames[i].m_type == type) {
+-				memcpy(m_vendorValue, CiscoAttrNames[i].m_name, CiscoAttrNames[i].m_nameLen);
+-				m_length = m_length + (unsigned char)CiscoAttrNames[i].m_nameLen;
+-				m_vendorLength = m_vendorLength + (unsigned char)CiscoAttrNames[i].m_nameLen;
+-				m_data[m_length++] = '=';
+-				m_vendorLength++;
++				memcpy(s.s.m_vendorValue, CiscoAttrNames[i].m_name, CiscoAttrNames[i].m_nameLen);
++				s.m_length = s.m_length + (unsigned char)CiscoAttrNames[i].m_nameLen;
++				s.s.m_vendorLength = s.s.m_vendorLength + (unsigned char)CiscoAttrNames[i].m_nameLen;
++				m_data[s.m_length++] = '=';
++				s.s.m_vendorLength++;
+ 				break;
+ 			} else
+ 				i++;
+ 	}
+ 	const PINDEX len = stringValue.GetLength();
+-	if (((PINDEX)m_length + len) > MaxLength)
++	if (((PINDEX)s.m_length + len) > MaxLength)
+ 		return;
+ 
+-	memcpy(m_data + (PINDEX)m_length, (const char*)stringValue, len);
+-	m_length = m_length + (unsigned char)len;
+-	m_vendorLength = m_vendorLength + (unsigned char)len;
++	memcpy(m_data + (PINDEX)s.m_length, (const char*)stringValue, len);
++	s.m_length = s.m_length + (unsigned char)len;
++	s.s.m_vendorLength = s.s.m_vendorLength + (unsigned char)len;
+ }
+ 
+ RadiusAttr::RadiusAttr(
+ 	const void* rawData, /// buffer with the attribute raw data
+ 	PINDEX rawLength /// length (bytes) of the buffer
+-	) : m_type(0), m_length(0)
++	)
+ {
++	s.m_type = 0;
++	s.m_length = 0;
+ 	Read(rawData, rawLength);
+ }
+ 
+ int RadiusAttr::GetVsaVendorId() const 
+ {
+-	return GetRadiusInteger(m_vendorId);
++	return GetRadiusInteger(s.s.m_vendorId);
+ }
+ 
+ bool RadiusAttr::Write(
+@@ -446,7 +473,7 @@ bool RadiusAttr::Write(
+ 	if (offset == P_MAX_INDEX)
+ 		offset = buffer.GetSize();
+ 		
+-	const PINDEX len = m_length;
++	const PINDEX len = s.m_length;
+ 	memcpy(buffer.GetPointer(offset + len) + offset, m_data, len);
+ 	written = len;
+ 
+@@ -455,7 +482,7 @@ bool RadiusAttr::Write(
+ 
+ bool RadiusAttr::Read(const void* rawData, PINDEX rawLength)
+ {
+-	m_type = m_length = 0;
++	s.m_type = s.m_length = 0;
+ 
+ #ifdef _DEBUG	
+ 	PAssertNULL(rawData);
+@@ -483,9 +510,9 @@ void RadiusAttr::PrintOn(
+ 
+ 	if (!IsValid()) {
+ 		strm << "(Invalid) {\n";
+-		if (m_length > 0) {
++		if (s.m_length > 0) {
+ 			const _Ios_Fmtflags flags = strm.flags();
+-			const PBYTEArray value((const BYTE*)m_data, m_length, FALSE);
++			const PBYTEArray value((const BYTE*)m_data, s.m_length, FALSE);
+ 
+ 			strm << hex << setfill('0') << resetiosflags(ios::floatfield)
+ 				<< setprecision(indent) << setw(16);
+@@ -508,12 +535,12 @@ void RadiusAttr::PrintOn(
+ 	strm << "{\n";
+ 		
+ #if PTRACING
+-	strm << setw(indent+7) << "type = " << (unsigned)m_type
+-		<< " (" << PMAP_ATTR_TYPE_TO_NAME(m_type) << ")\n";
++	strm << setw(indent+7) << "type = " << (unsigned)s.m_type
++		<< " (" << PMAP_ATTR_TYPE_TO_NAME(s.m_type) << ")\n";
+ #else
+-	strm << setw(indent+7) << "type = " << (unsigned)m_type << '\n';
++	strm << setw(indent+7) << "type = " << (unsigned)s.m_type << '\n';
+ #endif
+-	const PINDEX totalLen = m_length;
++	const PINDEX totalLen = s.m_length;
+ 	
+ 	strm << setw(indent+9) << "length = " << totalLen << " octets\n";
+ 	
+@@ -521,7 +548,7 @@ void RadiusAttr::PrintOn(
+ 		const _Ios_Fmtflags flags = strm.flags();
+ 		const PINDEX valueLen = (totalLen <= FixedHeaderLength) 
+ 			? 0 : (totalLen - FixedHeaderLength);
+-		const PBYTEArray value((const BYTE*)m_value, valueLen, FALSE);
++		const PBYTEArray value((const BYTE*)s.m_value, valueLen, FALSE);
+ 
+ 		strm << setw(indent+8) << "value = " << value.GetSize() << " octets {\n";
+ 		strm << hex << setfill('0') << resetiosflags(ios::floatfield)
+@@ -552,9 +579,9 @@ void RadiusAttr::PrintOn(
+ 			valueLen -= 2;
+ 			headerLen += 2;
+ 			strm << setw(indent+13) << "vendorType = " 
+-				<< (unsigned)m_vendorType << '\n';
++				<< (unsigned)s.s.m_vendorType << '\n';
+ 			strm << setw(indent+15) << "vendorLength = " 
+-				<< (unsigned)m_vendorLength << '\n';
++				<< (unsigned)s.s.m_vendorLength << '\n';
+ 		}
+ 		
+ 		const PBYTEArray value((const BYTE*)(m_data + headerLen), valueLen, FALSE);
+@@ -582,13 +609,13 @@ void RadiusAttr::PrintOn(
+ 
+ PINDEX RadiusAttr::GetVsaValueLength() const
+ {
+-	PINDEX len = m_length;
++	PINDEX len = s.m_length;
+ 	len = (len <= VsaRfc2865FixedHeaderLength) 
+ 		? 0 : (len - VsaRfc2865FixedHeaderLength);
+ 	
+ 	PINDEX len2 = 0;
+ 	if (len > 0) {
+-		len2 = m_vendorLength;
++		len2 = s.s.m_vendorLength;
+ 		len2 = (len2 <= 2) ? 0 : (len2 - 2);
+ 	}
+ 	if (len2 < len)
+@@ -626,7 +653,7 @@ bool RadiusAttr::GetVsaValue(PBYTEArray&
+ 		offset = buffer.GetSize();
+ 		
+ 	if (len > 0)
+-		memcpy(buffer.GetPointer(len + offset) + offset, m_vendorValue, len);
++		memcpy(buffer.GetPointer(len + offset) + offset, s.s.m_vendorValue, len);
+ 
+ 	return true;
+ }
+@@ -636,8 +663,8 @@ PString RadiusAttr::AsString() const
+ 	if (!IsValid())
+ 		return PString();
+ 
+-	const PINDEX len = m_length;
+-	const PINDEX headerLen = (m_type == VendorSpecific) 
++	const PINDEX len = s.m_length;
++	const PINDEX headerLen = (s.m_type == VendorSpecific) 
+ 			? VsaFixedHeaderLength : FixedHeaderLength;
+ 
+ 	if (len <= headerLen)
+@@ -648,52 +675,52 @@ PString RadiusAttr::AsString() const
+ 
+ int RadiusAttr::AsInteger() const
+ {
+-	if (m_length < (FixedHeaderLength+4) || m_type == VendorSpecific)
++	if (s.m_length < (FixedHeaderLength+4) || s.m_type == VendorSpecific)
+ 		return 0;
+ 	
+-	return GetRadiusInteger(m_value);
++	return GetRadiusInteger(s.m_value);
+ }
+ 
+ PIPSocket::Address RadiusAttr::AsAddress() const
+ {
+-	if (m_length < (FixedHeaderLength+4) || m_type == VendorSpecific)
++	if (s.m_length < (FixedHeaderLength+4) || s.m_type == VendorSpecific)
+ 		return 0;
+ 
+ 	DWORD addr = 0;
+-	
+-	((BYTE*)&addr)[0] = m_value[0];
+-	((BYTE*)&addr)[1] = m_value[1];
+-	((BYTE*)&addr)[2] = m_value[2];
+-	((BYTE*)&addr)[3] = m_value[3];
++
++	((BYTE*)&addr)[0] = s.m_value[0];
++	((BYTE*)&addr)[1] = s.m_value[1];
++	((BYTE*)&addr)[2] = s.m_value[2];
++	((BYTE*)&addr)[3] = s.m_value[3];
+ 	
+ 	return addr;
+ }
+ 
+ PString RadiusAttr::AsVsaString() const
+ {
+-	if (!IsValid() || m_type != VendorSpecific)
++	if (!IsValid() || s.m_type != VendorSpecific)
+ 		return PString();
+ 		
+-	const PINDEX len = m_length;
++	const PINDEX len = s.m_length;
+ 
+ 	if (len <= VsaRfc2865FixedHeaderLength)
+ 		return PString();
+ 	else
+-		return PString((const char*)m_vendorValue, len - VsaRfc2865FixedHeaderLength);
++		return PString((const char*)s.s.m_vendorValue, len - VsaRfc2865FixedHeaderLength);
+ }
+ 
+ PString RadiusAttr::AsCiscoString() const
+ {
+-	if (!IsValid() || m_type != VendorSpecific 
+-			|| GetRadiusInteger(m_vendorId) != CiscoVendorId)
++	if (!IsValid() || s.m_type != VendorSpecific 
++			|| GetRadiusInteger(s.s.m_vendorId) != CiscoVendorId)
+ 		return PString();
+ 		
+-	const PINDEX len = m_length;
++	const PINDEX len = s.m_length;
+ 	PINDEX offset = VsaRfc2865FixedHeaderLength;
+ 
+ 	int i = 0;
+ 	while (CiscoAttrNames[i].m_name != NULL)
+-		if (CiscoAttrNames[i].m_type == m_vendorType) {
++		if (CiscoAttrNames[i].m_type == s.s.m_vendorType) {
+ 			if (CiscoAttrNames[i].m_nameLen < (size_t)(len - offset))
+ 				if (memcmp(m_data + offset, CiscoAttrNames[i].m_name,
+ 						CiscoAttrNames[i].m_nameLen) == 0
+@@ -711,30 +738,32 @@ PString RadiusAttr::AsCiscoString() cons
+ 
+ int RadiusAttr::AsVsaInteger() const
+ {
+-	if (m_length < (VsaRfc2865FixedHeaderLength+4) || m_type != VendorSpecific)
++	if (s.m_length < (VsaRfc2865FixedHeaderLength+4) || s.m_type != VendorSpecific)
+ 		return 0;
+ 		
+-	return GetRadiusInteger(m_vendorValue);
++	return GetRadiusInteger(s.s.m_vendorValue);
+ }
+ 
+ PIPSocket::Address RadiusAttr::AsVsaAddress() const
+ {
+-	if (m_length < (VsaRfc2865FixedHeaderLength+4) || m_type != VendorSpecific)
++	if (s.m_length < (VsaRfc2865FixedHeaderLength+4) || s.m_type != VendorSpecific)
+ 		return 0;
+ 	
+ 	DWORD addr = 0;
+ 	
+-	((BYTE*)&addr)[0] = m_vendorValue[0];
+-	((BYTE*)&addr)[1] = m_vendorValue[1];
+-	((BYTE*)&addr)[2] = m_vendorValue[2];
+-	((BYTE*)&addr)[3] = m_vendorValue[3];
++	((BYTE*)&addr)[0] = s.s.m_vendorValue[0];
++	((BYTE*)&addr)[1] = s.s.m_vendorValue[1];
++	((BYTE*)&addr)[2] = s.s.m_vendorValue[2];
++	((BYTE*)&addr)[3] = s.s.m_vendorValue[3];
+ 	
+ 	return addr;
+ }
+ 
+ 
+-RadiusPDU::RadiusPDU() : m_code(Invalid), m_id(0)
++RadiusPDU::RadiusPDU()
+ {
++	s.m_code = 0;
++	s.m_id = 0;
+ 	SetLength(FixedHeaderLength);
+ }
+ 
+@@ -748,8 +777,10 @@ RadiusPDU::RadiusPDU( 
+ RadiusPDU::RadiusPDU( 
+ 	unsigned char packetCode, /// code - see #Codes enum#
+ 	unsigned char packetId /// packet id (sequence number)
+-	) : m_code(packetCode), m_id(packetId)
++	)
+ {
++	s.m_code = packetCode;
++	s.m_id = packetId;
+ 	SetLength(FixedHeaderLength);
+ }
+ 
+@@ -759,7 +790,7 @@ RadiusPDU::RadiusPDU(
+ 	)
+ {
+ 	if (!Read(rawData, rawLength)) {
+-		m_code = m_id = Invalid;
++		s.m_code = s.m_id = Invalid;
+ 		SetLength(FixedHeaderLength);
+ 	}
+ }
+@@ -773,16 +804,16 @@ void RadiusPDU::PrintOn( 
+ 	strm << ((!IsValid()) ? "(Invalid) {\n" : "{\n");
+ 	
+ #if PTRACING
+-	strm << setw(indent+7) << "code = " << (unsigned)m_code
+-		<< " (" << PMAP_CODE_TO_NAME(m_code) << ")\n";
++	strm << setw(indent+7) << "code = " << (unsigned)s.m_code
++		<< " (" << PMAP_CODE_TO_NAME(s.m_code) << ")\n";
+ #else
+-	strm << setw(indent+7) << "code = " << (unsigned)m_code << '\n';
++	strm << setw(indent+7) << "code = " << (unsigned)s.m_code << '\n';
+ #endif
+-	strm << setw(indent+5) << "id = " << (unsigned)m_id << '\n';
++	strm << setw(indent+5) << "id = " << (unsigned)s.m_id << '\n';
+ 	strm << setw(indent+9) << "length = " << GetLength() << " octets\n";
+ 
+ 	const _Ios_Fmtflags flags = strm.flags();
+-	const PBYTEArray value((const BYTE*)m_authenticator, AuthenticatorLength, FALSE);
++	const PBYTEArray value((const BYTE*)s.m_authenticator, AuthenticatorLength, FALSE);
+ 
+ 	strm << setw(indent+28) << "authenticator = 16 octets {\n";
+ 	strm << hex << setfill('0') << resetiosflags(ios::floatfield)
+@@ -816,7 +847,7 @@ void RadiusPDU::PrintOn( 
+ 
+ bool RadiusPDU::IsValid() const
+ {
+-	if (m_code == Invalid)
++	if (s.m_code == Invalid)
+ 		return false;
+ 
+ 	const PINDEX len = GetLength();
+@@ -842,7 +873,7 @@ void RadiusPDU::GetAuthenticator(PBYTEAr
+ 	if (offset == P_MAX_INDEX)
+ 		offset = vector.GetSize();
+ 	memcpy(vector.GetPointer(offset + AuthenticatorLength) + offset,
+-		m_authenticator, AuthenticatorLength
++		s.m_authenticator, AuthenticatorLength
+ 		);
+ }
+ 
+@@ -855,7 +886,7 @@ bool RadiusPDU::SetAuthenticator(const P
+ 	len -= offset;
+ 
+ 	if (len > 0)
+-		memcpy(m_authenticator, ((const BYTE*)vector)+offset,
++		memcpy(s.m_authenticator, ((const BYTE*)vector)+offset,
+ 			(len < AuthenticatorLength) ? len : AuthenticatorLength
+ 			);
+ 
+@@ -870,32 +901,32 @@ bool RadiusPDU::SetAuthenticator(const v
+ 	if (data == NULL)
+ 		return false;
+ 
+-	memcpy(m_authenticator, data, AuthenticatorLength);
++	memcpy(s.m_authenticator, data, AuthenticatorLength);
+ 	return true;
+ }
+ 
+ void RadiusPDU::SetAuthenticator(PRandom& random)
+ {
+ 	DWORD r = (DWORD)random;
+-	m_authenticator[0] = ((const BYTE*)&r)[0];
+-	m_authenticator[1] = ((const BYTE*)&r)[1];
+-	m_authenticator[2] = ((const BYTE*)&r)[2];
+-	m_authenticator[3] = ((const BYTE*)&r)[3];
++	s.m_authenticator[0] = ((const BYTE*)&r)[0];
++	s.m_authenticator[1] = ((const BYTE*)&r)[1];
++	s.m_authenticator[2] = ((const BYTE*)&r)[2];
++	s.m_authenticator[3] = ((const BYTE*)&r)[3];
+ 	r = (DWORD)random;
+-	m_authenticator[4] = ((const BYTE*)&r)[0];
+-	m_authenticator[5] = ((const BYTE*)&r)[1];
+-	m_authenticator[6] = ((const BYTE*)&r)[2];
+-	m_authenticator[7] = ((const BYTE*)&r)[3];
++	s.m_authenticator[4] = ((const BYTE*)&r)[0];
++	s.m_authenticator[5] = ((const BYTE*)&r)[1];
++	s.m_authenticator[6] = ((const BYTE*)&r)[2];
++	s.m_authenticator[7] = ((const BYTE*)&r)[3];
+ 	r = (DWORD)random;
+-	m_authenticator[8] = ((const BYTE*)&r)[0];
+-	m_authenticator[9] = ((const BYTE*)&r)[1];
+-	m_authenticator[10] = ((const BYTE*)&r)[2];
+-	m_authenticator[11] = ((const BYTE*)&r)[3];
++	s.m_authenticator[8] = ((const BYTE*)&r)[0];
++	s.m_authenticator[9] = ((const BYTE*)&r)[1];
++	s.m_authenticator[10] = ((const BYTE*)&r)[2];
++	s.m_authenticator[11] = ((const BYTE*)&r)[3];
+ 	r = (DWORD)random;
+-	m_authenticator[12] = ((const BYTE*)&r)[0];
+-	m_authenticator[13] = ((const BYTE*)&r)[1];
+-	m_authenticator[14] = ((const BYTE*)&r)[2];
+-	m_authenticator[15] = ((const BYTE*)&r)[3];
++	s.m_authenticator[12] = ((const BYTE*)&r)[0];
++	s.m_authenticator[13] = ((const BYTE*)&r)[1];
++	s.m_authenticator[14] = ((const BYTE*)&r)[2];
++	s.m_authenticator[15] = ((const BYTE*)&r)[3];
+ }
+ 
+ void RadiusPDU::SetAuthenticator( 
+@@ -903,11 +934,11 @@ void RadiusPDU::SetAuthenticator( 
+ 	PMessageDigest5& md5 
+ 	)
+ {
+-	if (m_code == AccountingRequest) {
++	if (s.m_code == AccountingRequest) {
+ 		const PINDEX pduLength = GetLength();
+ 		const PINDEX secretLength = secret.GetLength();
+ 		
+-		memset(m_authenticator, 0, AuthenticatorLength);
++		memset(s.m_authenticator, 0, AuthenticatorLength);
+ 
+ 		md5.Start();
+ 		md5.Process(m_data, pduLength);
+@@ -916,7 +947,7 @@ void RadiusPDU::SetAuthenticator( 
+ 			
+ 		PMessageDigest::Result digest;
+ 		md5.CompleteDigest(digest);
+-		memcpy(m_authenticator, digest.GetPointer(), AuthenticatorLength);
++		memcpy(s.m_authenticator, digest.GetPointer(), AuthenticatorLength);
+ 	} else {
+ 		PRandom random;
+ 		SetAuthenticator(random);
+@@ -950,9 +981,9 @@ bool RadiusPDU::AppendAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = attrType;
+-	attr->m_length = attrLen;
+-	memcpy(attr->m_value, attrValue, valueLength);
++	attr->s.m_type = attrType;
++	attr->s.m_length = attrLen;
++	memcpy(attr->s.m_value, attrValue, valueLength);
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -969,9 +1000,9 @@ bool RadiusPDU::AppendAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = attrType;
+-	attr->m_length = attrLen;
+-	memcpy(attr->m_value, (const char*)stringValue, stringValue.GetLength());
++	attr->s.m_type = attrType;
++	attr->s.m_length = attrLen;
++	memcpy(attr->s.m_value, (const char*)stringValue, stringValue.GetLength());
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -988,9 +1019,9 @@ bool RadiusPDU::AppendAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = attrType;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_value, intValue);
++	attr->s.m_type = attrType;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.m_value, intValue);
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1008,12 +1039,12 @@ bool RadiusPDU::AppendAttr( 
+ 		
+ 	const DWORD addr = (DWORD)addressValue;
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = attrType;
+-	attr->m_length = attrLen;
+-	attr->m_value[0] = ((const BYTE*)&addr)[0];
+-	attr->m_value[1] = ((const BYTE*)&addr)[1];
+-	attr->m_value[2] = ((const BYTE*)&addr)[2];
+-	attr->m_value[3] = ((const BYTE*)&addr)[3];
++	attr->s.m_type = attrType;
++	attr->s.m_length = attrLen;
++	attr->s.m_value[0] = ((const BYTE*)&addr)[0];
++	attr->s.m_value[1] = ((const BYTE*)&addr)[1];
++	attr->s.m_value[2] = ((const BYTE*)&addr)[2];
++	attr->s.m_value[3] = ((const BYTE*)&addr)[3];
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1032,12 +1063,12 @@ bool RadiusPDU::AppendVsaAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = RadiusAttr::VendorSpecific;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_vendorId, vendorId);
+-	attr->m_vendorType = vendorType;
+-	attr->m_vendorLength = valueLength + 2;
+-	memcpy(attr->m_vendorValue, attrValue, valueLength);
++	attr->s.m_type = RadiusAttr::VendorSpecific;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.s.m_vendorId, vendorId);
++	attr->s.s.m_vendorType = vendorType;
++	attr->s.s.m_vendorLength = valueLength + 2;
++	memcpy(attr->s.s.m_vendorValue, attrValue, valueLength);
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1056,12 +1087,12 @@ bool RadiusPDU::AppendVsaAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = RadiusAttr::VendorSpecific;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_vendorId, vendorId);
+-	attr->m_vendorType = vendorType;
+-	attr->m_vendorLength = valueLen + 2;
+-	memcpy(attr->m_vendorValue, (const char*)stringValue, valueLen);
++	attr->s.m_type = RadiusAttr::VendorSpecific;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.s.m_vendorId, vendorId);
++	attr->s.s.m_vendorType = vendorType;
++	attr->s.s.m_vendorLength = valueLen + 2;
++	memcpy(attr->s.s.m_vendorValue, (const char*)stringValue, valueLen);
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1079,12 +1110,12 @@ bool RadiusPDU::AppendVsaAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = RadiusAttr::VendorSpecific;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_vendorId, vendorId);
+-	attr->m_vendorType = vendorType;
+-	attr->m_vendorLength = 4 + 2;
+-	SetRadiusInteger(attr->m_vendorValue, intValue);
++	attr->s.m_type = RadiusAttr::VendorSpecific;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.s.m_vendorId, vendorId);
++	attr->s.s.m_vendorType = vendorType;
++	attr->s.s.m_vendorLength = 4 + 2;
++	SetRadiusInteger(attr->s.s.m_vendorValue, intValue);
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1103,15 +1134,15 @@ bool RadiusPDU::AppendVsaAttr( 
+ 		
+ 	const DWORD addr = (DWORD)addressValue;
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = RadiusAttr::VendorSpecific;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_vendorId, vendorId);
+-	attr->m_vendorType = vendorType;
+-	attr->m_vendorLength = 4 + 2;
+-	attr->m_vendorValue[0] = ((const BYTE*)&addr)[0];
+-	attr->m_vendorValue[1] = ((const BYTE*)&addr)[1];
+-	attr->m_vendorValue[2] = ((const BYTE*)&addr)[2];
+-	attr->m_vendorValue[3] = ((const BYTE*)&addr)[3];
++	attr->s.m_type = RadiusAttr::VendorSpecific;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.s.m_vendorId, vendorId);
++	attr->s.s.m_vendorType = vendorType;
++	attr->s.s.m_vendorLength = 4 + 2;
++	attr->s.s.m_vendorValue[0] = ((const BYTE*)&addr)[0];
++	attr->s.s.m_vendorValue[1] = ((const BYTE*)&addr)[1];
++	attr->s.s.m_vendorValue[2] = ((const BYTE*)&addr)[2];
++	attr->s.s.m_vendorValue[3] = ((const BYTE*)&addr)[3];
+ 	SetLength(len + attrLen);
+ 	
+ 	return true;
+@@ -1130,11 +1161,11 @@ bool RadiusPDU::AppendCiscoAttr( 
+ 		return false;
+ 		
+ 	RadiusAttr* const attr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	attr->m_type = RadiusAttr::VendorSpecific;
+-	attr->m_length = attrLen;
+-	SetRadiusInteger(attr->m_vendorId, RadiusAttr::CiscoVendorId);
+-	attr->m_vendorType = vendorType;
+-	attr->m_vendorLength = 2;
++	attr->s.m_type = RadiusAttr::VendorSpecific;
++	attr->s.m_length = attrLen;
++	SetRadiusInteger(attr->s.s.m_vendorId, RadiusAttr::CiscoVendorId);
++	attr->s.s.m_vendorType = vendorType;
++	attr->s.s.m_vendorLength = 2;
+ 
+ 	if (!vsaHack) {
+ 		int i = 0;
+@@ -1143,26 +1174,26 @@ bool RadiusPDU::AppendCiscoAttr( 
+ 				attrLen += CiscoAttrNames[i].m_nameLen + 1;
+ 				if ((len + attrLen) > MaxPduLength)
+ 					return false;
+-				memcpy(attr->m_vendorValue, CiscoAttrNames[i].m_name, CiscoAttrNames[i].m_nameLen);
+-				attr->m_length = attr->m_length 
++				memcpy(attr->s.s.m_vendorValue, CiscoAttrNames[i].m_name, CiscoAttrNames[i].m_nameLen);
++				attr->s.m_length = attr->s.m_length 
+ 					+ (unsigned char)CiscoAttrNames[i].m_nameLen;
+-				attr->m_vendorLength = attr->m_vendorLength 
++				attr->s.s.m_vendorLength = attr->s.s.m_vendorLength 
+ 					+ (unsigned char)CiscoAttrNames[i].m_nameLen;
+-				attr->m_data[attr->m_length++] = '=';
+-				attr->m_vendorLength++;
++				attr->m_data[attr->s.m_length++] = '=';
++				attr->s.s.m_vendorLength++;
+ 				break;
+ 			} else
+ 				i++;
+ 	}
+ 	const PINDEX strLen = stringValue.GetLength();
+ 	attrLen += strLen;
+-	if (((PINDEX)attr->m_length + strLen) > RadiusAttr::MaxLength
++	if (((PINDEX)attr->s.m_length + strLen) > RadiusAttr::MaxLength
+ 		|| (len + attrLen) > MaxPduLength)
+ 		return false;
+ 
+-	memcpy(attr->m_data + (PINDEX)attr->m_length, (const char*)stringValue, strLen);
+-	attr->m_length = attr->m_length + (unsigned char)strLen;
+-	attr->m_vendorLength = attr->m_vendorLength + (unsigned char)strLen;
++	memcpy(attr->m_data + (PINDEX)attr->s.m_length, (const char*)stringValue, strLen);
++	attr->s.m_length = attr->s.m_length + (unsigned char)strLen;
++	attr->s.s.m_vendorLength = attr->s.s.m_vendorLength + (unsigned char)strLen;
+ 
+ 	SetLength(len + attrLen);
+ 	return true;
+@@ -1247,7 +1278,7 @@ bool RadiusPDU::Read(const void* rawData
+ 	PAssert(rawLength >= MinPduLength, PInvalidParameter);
+ #endif
+ 
+-	m_code = m_id = Invalid;
++	s.m_code = s.m_id = Invalid;
+ 	SetLength(FixedHeaderLength);
+ 
+ 	if (rawData == NULL || rawLength < MinPduLength)
+@@ -1260,13 +1291,13 @@ bool RadiusPDU::Read(const void* rawData
+ 
+ 	const PINDEX length = GetLength();
+ 	if (length > rawLength || length < MinPduLength || length > MaxPduLength) {
+-		m_code = m_id = Invalid;
++		s.m_code = s.m_id = Invalid;
+ 		SetLength(FixedHeaderLength);
+ 		return false;
+ 	}
+ 
+ 	if (length > FixedHeaderLength) {
+-		memcpy(m_attributes, buffptr, length - FixedHeaderLength);
++		memcpy(s.m_attributes, buffptr, length - FixedHeaderLength);
+ 	}
+ 
+ 	return true;
+@@ -1291,13 +1322,13 @@ void RadiusPDU::CopyContents(const Radiu
+ 
+ 	const PINDEX len = GetLength();
+ 	if (len < MinPduLength || len > MaxPduLength) {
+-		m_code = m_id = Invalid;
++		s.m_code = s.m_id = Invalid;
+ 		SetLength(FixedHeaderLength);
+ 		return;
+ 	}
+ 
+ 	if (len > FixedHeaderLength)
+-		memcpy(m_attributes, pdu.m_attributes, len - FixedHeaderLength);
++		memcpy(s.m_attributes, pdu.s.m_attributes, len - FixedHeaderLength);
+ }
+ 
+ bool RadiusPDU::EncryptPasswords( 
+@@ -1316,7 +1347,7 @@ bool RadiusPDU::EncryptPasswords( 
+ 	md5.Start();
+ 	if (secretLength > 0)
+ 		md5.Process((const char*)secret, secretLength);
+-	md5.Process(m_authenticator, AuthenticatorLength);
++	md5.Process(s.m_authenticator, AuthenticatorLength);
+ 	md5.CompleteDigest(digest);
+ 
+ 	// calculate length of the new and the old User-Password value	
+@@ -1330,14 +1361,14 @@ bool RadiusPDU::EncryptPasswords( 
+ 
+ 	// the encrypted password attribute will be appended as the last attribute
+ 	RadiusAttr* const encPwdAttr = reinterpret_cast<RadiusAttr*>(m_data + len);
+-	encPwdAttr->m_type = RadiusAttr::UserPassword;
+-	encPwdAttr->m_length = encPwdLength + RadiusAttr::FixedHeaderLength;
+-	memset(encPwdAttr->m_value, 0, encPwdLength);
++	encPwdAttr->s.m_type = RadiusAttr::UserPassword;
++	encPwdAttr->s.m_length = encPwdLength + RadiusAttr::FixedHeaderLength;
++	memset(encPwdAttr->s.m_value, 0, encPwdLength);
+ 	if (origPwdLength > 0)
+-		memcpy(encPwdAttr->m_value, pwdAttr->m_value, origPwdLength);
++		memcpy(encPwdAttr->s.m_value, pwdAttr->s.m_value, origPwdLength);
+ 
+ 	// encrypt first 16 bytes of the password
+-	DWORD* buf1ptr = reinterpret_cast<DWORD*>(encPwdAttr->m_value);
++	DWORD* buf1ptr = reinterpret_cast<DWORD*>(encPwdAttr->s.m_value);
+ 	const DWORD* buf2ptr = reinterpret_cast<const DWORD*>(digest.GetPointer());
+ 
+ 	// XOR either byte-wise or dword-wise (if the memory block is aligned properly)
diff --git a/net/gnugk/patches/patch-ac b/net/gnugk/patches/patch-ac
new file mode 100644
index 00000000000..f1a243bb09c
--- /dev/null
+++ b/net/gnugk/patches/patch-ac
@@ -0,0 +1,146 @@
+$NetBSD: patch-ac,v 1.1 2005/03/16 12:55:02 rillig Exp $
+
+--- radproto.h.orig	Mon Jul 26 14:19:42 2004
++++ radproto.h	Wed Mar 16 10:19:08 2005
+@@ -225,7 +225,7 @@ public:
+ 	*/
+ 	RadiusAttr(
+ 		const RadiusAttr& attr /// atrribute to copy from
+-		) { memcpy(m_data, attr.m_data, attr.m_length); }
++		) { memcpy(m_data, attr.m_data, attr.s.m_length); }
+ 		
+ 	/** Create TLV RADIUS attribute of a given type,
+ 		initializing #value# field with 'stringValue.GetLength()' bytes
+@@ -329,7 +329,7 @@ public:
+ 	/** @return
+ 		Type of this attribute (see #enum AttrTypes#).
+ 	*/
+-	unsigned char GetType() const { return m_type; }
++	unsigned char GetType() const { return s.m_type; }
+ 
+ 	/** @return
+ 		Vendor-specific type for this attribute, assuming this
+@@ -337,19 +337,19 @@ public:
+ 		(has vendorId, vendorType and vendorLength fields).
+ 	*/
+ 	unsigned char GetVsaType() const
+-		{ return (m_length < VsaRfc2865FixedHeaderLength) ? 0 : m_vendorType; }
++		{ return (s.m_length < VsaRfc2865FixedHeaderLength) ? 0 : s.s.m_vendorType; }
+ 
+ 	/** @return
+ 		Total length (bytes) of this attribute.
+ 	*/
+-	PINDEX GetLength() const { return m_length; }
++	PINDEX GetLength() const { return s.m_length; }
+ 	
+ 	/** @return
+ 		Length of the Value field for this attribute.
+ 	*/
+ 	PINDEX GetValueLength() const 
+ 	{ 
+-		const PINDEX len = m_length;
++		const PINDEX len = s.m_length;
+ 		const PINDEX headerLen = IsVsa() ? VsaFixedHeaderLength : FixedHeaderLength;
+ 		
+ 		return (len <= headerLen) ? 0 : (len - headerLen);
+@@ -386,7 +386,7 @@ public:
+ 	/** @return
+ 		True if this is a vendor-specific attribute (VSA).
+ 	*/
+-	bool IsVsa() const { return (m_type == VendorSpecific); }
++	bool IsVsa() const { return (s.m_type == VendorSpecific); }
+ 
+ 	/** @return
+ 		32 bit vendor identifier for VSA. This call is valid only
+@@ -510,7 +510,7 @@ public:
+ 	*/
+ 	RadiusAttr& operator=( 
+ 		const RadiusAttr& attr /// the attribute that contents will be assigned from
+-		) { memcpy(m_data, attr.m_data, attr.m_length); return *this; }
++		) { memcpy(m_data, attr.m_data, attr.s.m_length); return *this; }
+ 
+ 	/** Check whether this attribute contains valid data.
+ 	
+@@ -519,7 +519,7 @@ public:
+ 	*/
+ 	bool IsValid() const
+ 	{
+-		return ((PINDEX)m_length) >= ((m_type == VendorSpecific) 
++		return ((PINDEX)s.m_length) >= ((s.m_type == VendorSpecific) 
+ 			? VsaFixedHeaderLength : FixedHeaderLength
+ 			);
+ 	}
+@@ -579,9 +579,9 @@ protected:
+ 					unsigned char m_vendorType;
+ 					unsigned char m_vendorLength;
+ 					unsigned char m_vendorValue[MaxLength - VsaRfc2865FixedHeaderLength];
+-				};
++				} s;
+ 			};
+-		};
++		} s;
+ 	};
+ };
+ 
+@@ -655,35 +655,35 @@ public:
+ 	/** @return
+ 		Code for this RADIUS packet (see #enum Codes#)
+ 	*/
+-	unsigned char GetCode() const { return m_code; }
++	unsigned char GetCode() const { return s.m_code; }
+ 	
+ 	/** Set new type (Code filed) for this PDU.
+ 	*/
+ 	void SetCode( 
+ 		unsigned char newCode /// new PDU type
+-		) { m_code = newCode; }
++		) { s.m_code = newCode; }
+ 	
+ 	/** @return
+ 		Identifier (Id field) of this RADIUS packet
+ 	*/
+-	unsigned char GetId() const { return m_id; }
++	unsigned char GetId() const { return s.m_id; }
+ 
+ 	/**	Set new identifier for this RADIUS packet.
+ 	*/
+ 	void SetId( 
+ 		unsigned char newId /// new packet identifier
+-		) { m_id = newId; }
++		) { s.m_id = newId; }
+ 
+ 	/** @return
+ 		Length of this RADIUS packet (bytes)
+ 	*/
+ 	PINDEX GetLength() const 
+-		{ return (((PINDEX)(m_length[0]) & 0xff) << 8) | ((PINDEX)(m_length[1]) & 0xff); }
++		{ return (((PINDEX)(s.m_length[0]) & 0xff) << 8) | ((PINDEX)(s.m_length[1]) & 0xff); }
+ 
+ 	/** @return
+ 	    A pointer to a memory block that holds 16 bytes authenticator.
+ 	*/
+-	const unsigned char* GetAuthenticator() const { return m_authenticator; }
++	const unsigned char* GetAuthenticator() const { return s.m_authenticator; }
+ 
+ 	/** Fill the array with 16 bytes #authenticator# vector
+ 		associated with this RADIUS packet.
+@@ -911,8 +911,8 @@ private:
+ 		PINDEX newLen /// new packet length in bytes
+ 		)
+ 	{
+-		m_length[0] = (unsigned char)((newLen >> 8) & 0xff);
+-		m_length[1] = (unsigned char)(newLen & 0xff);
++		s.m_length[0] = (unsigned char)((newLen >> 8) & 0xff);
++		s.m_length[1] = (unsigned char)(newLen & 0xff);
+ 	}
+ 	
+ protected:
+@@ -929,7 +929,7 @@ protected:
+ 			/// RADIUS authenticator vector
+ 			unsigned char m_authenticator[AuthenticatorLength];
+ 			unsigned char m_attributes[MaxPduLength - FixedHeaderLength];
+-		};
++		} s;
+ 	};
+ };
+