addressattributetest.java

stun的java实现

/*
 * Stun4j, the OpenSource Java Solution for NAT and Firewall Traversal.
 *
 * Distributable under LGPL license.
 * See terms of license at gnu.org.
 */
package net.java.stun4j.attribute;

import junit.framework.*;
import net.java.stun4j.*;
import java.util.Arrays;

/**
 *
 * <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);
    }

    /**
     * Verifies that xorred address-es are properly xor-ed for IPv4 addresses.
     */
    public void testXorMappedAddressXoring_v4()
    {
        XorMappedAddressAttribute addressAttribute = new XorMappedAddressAttribute();
        StunAddress testAddress =
            new StunAddress("130.79.95.53", 12120);

        addressAttribute.setAddress(testAddress);

        //do a xor with an id equal to the v4 address itself so that we get 0000..,
        StunAddress 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();
        StunAddress testAddress =
            new StunAddress("2001:660:4701:1001:202:8aff:febe:130b", 12120);

        addressAttribute.setAddress(testAddress);

        //do a xor with an id equal to the v4 address itself so that we get 0000..,
        StunAddress 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(),