520 lines
18 KiB
Java
520 lines
18 KiB
Java
/*
|
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
|
* Maintained by the SIP Communicator community (http://sip-communicator.org).
|
|
*
|
|
* Distributable under LGPL license. See terms of license at gnu.org.
|
|
*/
|
|
package org.ice4j.attribute;
|
|
|
|
import java.util.*;
|
|
|
|
import junit.framework.*;
|
|
|
|
import org.ice4j.*;
|
|
|
|
/**
|
|
*
|
|
* <p>Title: Stun4J.</p>
|
|
* <p>Description: Simple Traversal of UDP Through NAT</p>
|
|
* <p>Copyright: Copyright (c) 2003</p>
|
|
* <p>Organisation: <p> Organisation: Louis Pasteur University, Strasbourg, France</p>
|
|
* <p> Network Research Team (http://www-r2.u-strasbg.fr)</p></p>
|
|
* @author Emil Ivov
|
|
* @version 0.1
|
|
*/
|
|
public class AddressAttributeTest extends TestCase {
|
|
private AddressAttribute addressAttribute = null;
|
|
private MsgFixture msgFixture;
|
|
|
|
public AddressAttributeTest(String name) {
|
|
super(name);
|
|
}
|
|
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
|
|
addressAttribute = new MappedAddressAttribute();
|
|
msgFixture = new MsgFixture();
|
|
|
|
msgFixture.setUp();
|
|
}
|
|
|
|
protected void tearDown() throws Exception {
|
|
addressAttribute = null;
|
|
msgFixture.tearDown();
|
|
|
|
msgFixture = null;
|
|
super.tearDown();
|
|
}
|
|
|
|
/**
|
|
* Verify that AddressAttribute descendants have correctly set types and
|
|
* names.
|
|
*/
|
|
public void testAddressAttributeDescendants() {
|
|
char expectedType;
|
|
char actualType;
|
|
String expectedName;
|
|
String actualName;
|
|
|
|
//MAPPED-ADDRESS
|
|
addressAttribute = new MappedAddressAttribute();
|
|
|
|
expectedType = Attribute.MAPPED_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "MAPPED-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("MappedAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("MappedAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
|
|
//SOURCE-ADDRESS
|
|
addressAttribute = new SourceAddressAttribute();
|
|
|
|
expectedType = Attribute.SOURCE_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "SOURCE-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("SourceAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("SourceAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
|
|
//CHANGED-ADDRESS
|
|
addressAttribute = new ChangedAddressAttribute();
|
|
|
|
expectedType = Attribute.CHANGED_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "CHANGED-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("ChangedAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("ChangedAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
|
|
//RESPONSE-ADDRESS
|
|
addressAttribute = new ResponseAddressAttribute();
|
|
|
|
expectedType = Attribute.RESPONSE_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "RESPONSE-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("ResponseAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("ResponseAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
|
|
//REFLECTED-FROM
|
|
addressAttribute = new ReflectedFromAttribute();
|
|
|
|
expectedType = Attribute.REFLECTED_FROM;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "REFLECTED-FROM";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("ReflectedFromAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("ReflectedFromAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
//REFLECTED-FROM
|
|
addressAttribute = new ReflectedFromAttribute();
|
|
|
|
expectedType = Attribute.REFLECTED_FROM;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "REFLECTED-FROM";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("ReflectedFromAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("ReflectedFromAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
//XOR-MAPPED-ADDRESS
|
|
addressAttribute = new XorMappedAddressAttribute();
|
|
|
|
expectedType = Attribute.XOR_MAPPED_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "XOR-MAPPED-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("XorMappedAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("XorMappedAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
/* ALTERNATE-SERVER */
|
|
addressAttribute = new AlternateServerAttribute();
|
|
|
|
expectedType = Attribute.ALTERNATE_SERVER;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "ALTERNATE-SERVER";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("AlternateServerAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("AlternateAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
|
|
/* XOR-PEER-ADDRESS */
|
|
addressAttribute = new XorPeerAddressAttribute();
|
|
|
|
expectedType = Attribute.XOR_PEER_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "XOR-PEER-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("XorPeerAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("XorPeerAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
|
|
/* XOR-RELAYED-ADDRESS */
|
|
addressAttribute = new XorRelayedAddressAttribute();
|
|
|
|
expectedType = Attribute.XOR_RELAYED_ADDRESS;
|
|
actualType = addressAttribute.getAttributeType();
|
|
|
|
expectedName = "XOR-RELAYED-ADDRESS";
|
|
actualName = addressAttribute.getName();
|
|
|
|
assertEquals("XorRelayedAddressAttribute does not the right type.",
|
|
expectedType, actualType);
|
|
assertEquals("XorRelayedAddressAttribute does not the right name.",
|
|
expectedName, actualName);
|
|
}
|
|
|
|
/**
|
|
* Verifies that xorred address-es are properly xor-ed for IPv4 addresses.
|
|
*/
|
|
public void testXorMappedAddressXoring_v4()
|
|
{
|
|
XorMappedAddressAttribute addressAttribute = new XorMappedAddressAttribute();
|
|
TransportAddress testAddress =
|
|
new TransportAddress("130.79.95.53", 12120, Transport.UDP);
|
|
|
|
addressAttribute.setAddress(testAddress);
|
|
|
|
//do a xor with an id equal to the v4 address itself so that we get 0000..,
|
|
TransportAddress xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{(byte)130,79,95,53,0,0,0,0,0,0,0,0,0,0,0,0,0});
|
|
|
|
assertTrue("Xorring the address with itself didn't return 00000...",
|
|
Arrays.equals(xorredAddr.getAddressBytes(), new byte[]{0,0,0,0}));
|
|
|
|
assertTrue("Port was not xorred",
|
|
testAddress.getPort() != xorredAddr.getPort());
|
|
|
|
//Test xor-ing the original with the xored - should get the xor code
|
|
addressAttribute.setAddress(testAddress);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
xorredAddr =
|
|
addressAttribute.applyXor(xorredAddr.getAddressBytes());
|
|
|
|
assertTrue("Xorring the original with the xor-ed didn't "
|
|
+"return the code..",
|
|
Arrays.equals( xorredAddr.getAddressBytes(),
|
|
new byte[]{21,22,23,24}));
|
|
|
|
assertTrue("Port was not xorred",
|
|
testAddress.getPort() != 0xFFFF);
|
|
|
|
//Test double xor-ing - should get the original
|
|
addressAttribute.setAddress(testAddress);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
addressAttribute.setAddress(xorredAddr);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
assertEquals("Double xorring didn't give the original ...",
|
|
testAddress, xorredAddr);
|
|
}
|
|
|
|
/**
|
|
* Verifies that xorred address-es are properly xor-ed for IPv6 addresses.
|
|
*/
|
|
public void testXorMappedAddressXoring_v6()
|
|
{
|
|
XorMappedAddressAttribute addressAttribute
|
|
= new XorMappedAddressAttribute();
|
|
TransportAddress testAddress = new TransportAddress(
|
|
"2001:660:4701:1001:202:8aff:febe:130b", 12120, Transport.UDP);
|
|
|
|
addressAttribute.setAddress(testAddress);
|
|
|
|
//do a xor with an id equal to the v4 address itself so that we get 0000..,
|
|
TransportAddress xorredAddr =
|
|
addressAttribute.applyXor(
|
|
new byte[]{(byte)0x20, (byte)0x01, (byte)0x06, (byte)0x60,
|
|
(byte)0x47, (byte)0x01, (byte)0x10, (byte)0x01,
|
|
(byte)0x02, (byte)0x02, (byte)0x8a, (byte)0xff,
|
|
(byte)0xfe, (byte)0xbe, (byte)0x13, (byte)0x0b});
|
|
|
|
assertTrue("Xorring the address with itself didn't return 00000...",
|
|
Arrays.equals(xorredAddr.getAddressBytes(),
|
|
new byte[]{0,0,0,0,
|
|
0,0,0,0,
|
|
0,0,0,0,
|
|
0,0,0,0}));
|
|
|
|
assertTrue("Port was not xorred",
|
|
testAddress.getPort() != xorredAddr.getPort());
|
|
|
|
//Test xor-ing the original with the xored - should get the xor code
|
|
addressAttribute.setAddress(testAddress);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
xorredAddr = addressAttribute.applyXor(xorredAddr.getAddressBytes());
|
|
|
|
assertTrue("Xorring the original with the xor-ed didn't return the code..",
|
|
Arrays.equals(
|
|
xorredAddr.getAddressBytes(),
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36}));
|
|
|
|
assertTrue("Port was not xorred",
|
|
testAddress.getPort() != 0xFFFF);
|
|
|
|
//Test double xor-ing - should get the original
|
|
addressAttribute.setAddress(testAddress);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
addressAttribute.setAddress(xorredAddr);
|
|
xorredAddr = addressAttribute.applyXor(
|
|
new byte[]{21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36});
|
|
|
|
assertEquals("Double xorring didn't give the original ...",
|
|
testAddress, xorredAddr);
|
|
}
|
|
|
|
/**
|
|
* Test whether sample binary arrays are correctly decoded.
|
|
*
|
|
* @throws StunException if something goes wrong
|
|
*/
|
|
public void testDecodeAttributeBody() throws StunException {
|
|
byte[] attributeValue = msgFixture.mappedAddress;
|
|
char offset = Attribute.HEADER_LENGTH;
|
|
char length = (char)(attributeValue.length - offset);
|
|
|
|
addressAttribute.decodeAttributeBody(attributeValue, offset, length);
|
|
|
|
|
|
assertEquals(
|
|
"AddressAttribute.decode() did not properly decode the port field.",
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, addressAttribute.getPort());
|
|
assertTrue(
|
|
"AddressAttribute.decode() did not properly decode the address field.",
|
|
Arrays.equals( msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
addressAttribute.getAddressBytes()));
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Test whetner sample binary arrays are correctly decoded.
|
|
* @throws StunException if something goes wrong
|
|
*/
|
|
public void testDecodeAttributeBodyv6() throws StunException {
|
|
byte[] attributeValue = msgFixture.mappedAddressv6;
|
|
char offset = Attribute.HEADER_LENGTH;
|
|
char length = (char)(attributeValue.length - offset);
|
|
|
|
addressAttribute.decodeAttributeBody(attributeValue, offset, length);
|
|
|
|
|
|
assertEquals("decode() failed for an IPv6 Addr's port.",
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT,
|
|
addressAttribute.getPort());
|
|
assertTrue("AddressAttribute.decode() failed for an IPv6 address.",
|
|
Arrays.equals( msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
addressAttribute.getAddressBytes()));
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Test whether attributes are properly encoded.
|
|
*
|
|
* @throws StunException java.lang.Exception if we fail
|
|
*/
|
|
public void testEncode()
|
|
throws Exception
|
|
{
|
|
byte[] expectedReturn = msgFixture.mappedAddress;
|
|
|
|
addressAttribute.setAddress(
|
|
new TransportAddress(msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT,
|
|
Transport.UDP));
|
|
|
|
byte[] actualReturn = addressAttribute.encode();
|
|
assertTrue("AddressAttribute.encode() did not "
|
|
+"properly encode a sample attribute",
|
|
Arrays.equals( expectedReturn, actualReturn));
|
|
}
|
|
|
|
/**
|
|
* Test whether attributes are properly encoded.
|
|
*
|
|
* @throws StunException java.lang.Exception if we fail
|
|
*/
|
|
public void testEncodev6()
|
|
throws Exception
|
|
{
|
|
byte[] expectedReturn = msgFixture.mappedAddressv6;
|
|
|
|
addressAttribute.setAddress(
|
|
new TransportAddress(msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP));
|
|
|
|
byte[] actualReturn = addressAttribute.encode();
|
|
assertTrue("An AddressAttribute did not properly encode an IPv6 addr.",
|
|
Arrays.equals( expectedReturn, actualReturn));
|
|
}
|
|
|
|
|
|
/**
|
|
* Tests the equals method against a null, a different and an identical
|
|
* object.
|
|
*
|
|
* @throws StunException java.lang.Exception if we fail
|
|
*/
|
|
public void testEquals()
|
|
throws Exception
|
|
{
|
|
//null test
|
|
AddressAttribute target = null;
|
|
boolean expectedReturn = false;
|
|
boolean actualReturn = addressAttribute.equals(target);
|
|
|
|
assertEquals("AddressAttribute.equals() failed against a null target.",
|
|
expectedReturn, actualReturn);
|
|
|
|
//difference test
|
|
target = new MappedAddressAttribute();
|
|
|
|
char port = (char)(msgFixture.ADDRESS_ATTRIBUTE_PORT + 1 );
|
|
target.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS, port, Transport.UDP));
|
|
|
|
addressAttribute.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT,
|
|
Transport.UDP));
|
|
|
|
expectedReturn = false;
|
|
actualReturn = addressAttribute.equals(target);
|
|
assertEquals(
|
|
"AddressAttribute.equals() failed against a different target.",
|
|
expectedReturn, actualReturn);
|
|
|
|
//equality test
|
|
target.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP ));
|
|
|
|
expectedReturn = true;
|
|
actualReturn = addressAttribute.equals(target);
|
|
assertEquals(
|
|
"AddressAttribute.equals() failed against an equal target.",
|
|
expectedReturn, actualReturn);
|
|
|
|
//ipv6 equality test
|
|
target.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP));
|
|
|
|
addressAttribute.setAddress(new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT,
|
|
Transport.UDP));
|
|
|
|
expectedReturn = true;
|
|
actualReturn = addressAttribute.equals(target);
|
|
assertEquals("AddressAttribute.equals() failed for IPv6 addresses.",
|
|
expectedReturn, actualReturn);
|
|
}
|
|
|
|
/**
|
|
* Tests whether data length is properly calculated.
|
|
*
|
|
* @throws StunException java.lang.Exception if we fail
|
|
*/
|
|
public void testGetDataLength()
|
|
throws Exception
|
|
{
|
|
char expectedReturn = 8;//1-padding + 1-family + 2-port + 4-address
|
|
|
|
addressAttribute.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT,
|
|
Transport.UDP));
|
|
|
|
char actualReturn = addressAttribute.getDataLength();
|
|
|
|
assertEquals("Datalength is not propoerly calculated",
|
|
expectedReturn, actualReturn);
|
|
|
|
expectedReturn = 20;//1-padding + 1-family + 2-port + 16-address
|
|
addressAttribute.setAddress( new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP));
|
|
|
|
actualReturn = addressAttribute.getDataLength();
|
|
|
|
assertEquals("Datalength is not propoerly calculated",
|
|
expectedReturn, actualReturn);
|
|
}
|
|
|
|
/**
|
|
* Tests that the address family is always 1.
|
|
*/
|
|
public void testGetFamily()
|
|
throws Exception
|
|
{
|
|
byte expectedReturn = 1;
|
|
addressAttribute.setAddress(new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP));
|
|
byte actualReturn = addressAttribute.getFamily();
|
|
assertEquals("Address family was not 1 for an IPv4",
|
|
expectedReturn, actualReturn);
|
|
|
|
//ipv6
|
|
expectedReturn = 2;
|
|
addressAttribute.setAddress(new TransportAddress(
|
|
msgFixture.ADDRESS_ATTRIBUTE_ADDRESS_V6,
|
|
msgFixture.ADDRESS_ATTRIBUTE_PORT, Transport.UDP));
|
|
actualReturn = addressAttribute.getFamily();
|
|
assertEquals("Address family was not 2 for an IPv6 address",
|
|
expectedReturn, actualReturn);
|
|
|
|
}
|
|
|
|
}
|