diff --git a/src/org/ice4j/ice/Agent.java b/src/org/ice4j/ice/Agent.java index 014bba8..b0d48e9 100644 --- a/src/org/ice4j/ice/Agent.java +++ b/src/org/ice4j/ice/Agent.java @@ -58,6 +58,18 @@ public class Agent private final List harvesters = new ArrayList(); + /** + * The name of the System property that allows us to set a custom maximum + * for check list sizes. + */ + public static final String PNAME_MAX_CHECK_LIST_SIZE + = "org.ice4j.MAX_CHECK_LIST_SIZE"; + + /** + * The default maximum size for check lists. + */ + public static final int DEFAULT_MAX_CHECK_LIST_SIZE = 100; + /** * We use the FoundationsRegistry to keep track of the foundations * we assign within a session (i.e. the entire life time of an @@ -65,6 +77,17 @@ public class Agent */ private FoundationsRegistry foundationsRegistry = new FoundationsRegistry(); + /** + * The CHECK-LIST for this agent described in the ICE specification. Note + * that even though this may sound a bit unclear in the spec, + * checkLists are supposed to be created on a per-agent basis so + * that we could, for example, freeze candidates with common foundations + * across streams and not only across components, and so that we could + * limit the total number of candidate pairs for all streams. + */ + private final List checkList + = new LinkedList(); + /** * The user fragment that we should use for the ice-ufrag attribute. */ @@ -220,13 +243,90 @@ public class Agent */ public void startChecks() { - List streams = getStreams(); - - for(IceMediaStream stream : streams) + //first init the check list. + synchronized(checkList) { - stream.initCheckList(); + checkList.clear(); + List streams = getStreams(); + + for(IceMediaStream stream : streams) + { + stream.createCheckList(checkList); + } + + orderCheckList(); + pruneCheckList(); } } + + /** + * Orders this stream's pair check list in decreasing order of pair + * priority. If two pairs have identical priority, the ordering amongst + * them is arbitrary. + */ + private void orderCheckList() + { + Collections.sort(checkList, CandidatePair.comparator); + } + + /** + * Removes or, as per the ICE spec, "prunes" pairs that we don't need to + * run checks for. For example, since we cannot send requests directly + * from a reflexive candidate, but only from its base, we go through the + * sorted list of candidate pairs and in every pair where the local + * candidate is server reflexive, we replace the local server reflexive + * candidate with its base. Once this has been done, we remove each pair + * where the local and remote candidates are identical to the local and + * remote candidates of a pair higher up on the priority list. + *

+ * In addition, in order to limit the attacks described in Section 18.5.2 + * of the ICE spec, we limit the total number of pairs and hence + * (connectivity checks) to a specific value, (100 by default). + */ + private void pruneCheckList() + { + //a list that we only use for storing pairs that we've already gone + //through. The list is destroyed at the end of this method. + List tmpCheckList + = new ArrayList(checkList.size()); + + Iterator ckListIter = checkList.iterator(); + + int maxCheckListSize = Integer.getInteger( + PNAME_MAX_CHECK_LIST_SIZE, DEFAULT_MAX_CHECK_LIST_SIZE); + + while(ckListIter.hasNext()) + { + CandidatePair pair = ckListIter.next(); + + //drop all pairs above MAX_CHECK_LIST_SIZE. + if(tmpCheckList.size() > maxCheckListSize) + { + ckListIter.remove(); + continue; + } + + //replace local server reflexive candidates with their base. + LocalCandidate localCnd = pair.getLocalCandidate(); + if( localCnd.getType() + == CandidateType.SERVER_REFLEXIVE_CANDIDATE) + { + pair.setLocalCandidate(localCnd.getBase()); + + //if the new pair corresponds to another one with a higher + //priority, then remove it. + if(tmpCheckList.contains(pair)) + { + ckListIter.remove(); + continue; + } + } + + tmpCheckList.add(pair); + } + } + + /** * Computes and sets the foundations foundation for all Candidates * currently found in component. diff --git a/src/org/ice4j/ice/CandidatePair.java b/src/org/ice4j/ice/CandidatePair.java index 8b4d8b5..948c1b4 100644 --- a/src/org/ice4j/ice/CandidatePair.java +++ b/src/org/ice4j/ice/CandidatePair.java @@ -52,12 +52,15 @@ public class CandidatePair public static final PairComparator comparator = new PairComparator(); /** - * Each candidate pair has a a state that is assigned once the check list + * Each candidate pair has a state that is assigned once the check list * for each media stream has been computed. The ICE RFC defines five * potential values that the state can have and they are all represented - * in the CandidatePairState enumeration. + * in the CandidatePairState enumeration. The ICE spec stipulates + * that the first step of the state initialization process is: The agent + * sets all of the pairs in each check list to the Frozen state, and hence + * our default state. */ - private CandidatePairState state = CandidatePairState.WAITING; + private CandidatePairState state = CandidatePairState.FROZEN; /** * Creates a CandidatePair instance mapping localCandidate diff --git a/src/org/ice4j/ice/IceMediaStream.java b/src/org/ice4j/ice/IceMediaStream.java index 8b05fcd..1c54113 100644 --- a/src/org/ice4j/ice/IceMediaStream.java +++ b/src/org/ice4j/ice/IceMediaStream.java @@ -48,24 +48,6 @@ public class IceMediaStream */ private int lastComponentID = 0; - /** - * The CHECK-LIST for this stream as described in the ICE specification. - */ - private final List checkList - = new LinkedList(); - - /** - * The name of the System property that allows us to set a custom maximum - * for check list sizes. - */ - public static final String PNAME_MAX_CHECK_LIST_SIZE - = "org.ice4j.MAX_CHECK_LIST_SIZE"; - - /** - * The default maximum size for check lists. - */ - public static final int DEFAULT_MAX_CHECK_LIST_SIZE = 100; - /** * The agent that this media stream belongs to. */ @@ -265,19 +247,17 @@ public class IceMediaStream /** * Creates, initializes and orders the list of candidate pairs that would * be used for the connectivity checks for all components in this stream. + * + * @param checkList the list that we need to update with the new pairs. */ - protected void initCheckList() + protected void createCheckList(List checkList) { - synchronized(checkList) - { - checkList.clear(); List componentsList = getComponents(); for(Component cmp : componentsList) { createCheckList(cmp, checkList); } - } } /** @@ -306,83 +286,6 @@ public class IceMediaStream checkList.add(pair); } } - - orderCheckList(); - pruneCheckList(); - } - - /** - * Orders this stream's pair check list in decreasing order of pair - * priority. If two pairs have identical priority, the ordering amongst - * them is arbitrary. - */ - private void orderCheckList() - { - synchronized(checkList) - { - Collections.sort(checkList, CandidatePair.comparator); - } - } - - - /** - * Removes or, as per the ICE spec, "prunes" pairs that we don't need to - * run checks for. For example, since we cannot send requests directly - * from a reflexive candidate, but only from its base, we go through the - * sorted list of candidate pairs and in every pair where the local - * candidate is server reflexive, we replace the local server reflexive - * candidate with its base. Once this has been done, we remove each pair - * where the local and remote candidates are identical to the local and - * remote candidates of a pair higher up on the priority list. - *

- * In addition, in order to limit the attacks described in Section 18.5.2 - * of the ICE spec, we limit the total number of pairs and hence - * (connectivity checks) to a specific value, (100 by default). - */ - private void pruneCheckList() - { - synchronized(checkList) - { - //a list that we only use for storing pairs that we've already gone - //through. The list is destroyed at the end of this method. - List tmpCheckList - = new ArrayList(checkList.size()); - - Iterator ckListIter = checkList.iterator(); - - int maxCheckListSize = Integer.getInteger( - PNAME_MAX_CHECK_LIST_SIZE, DEFAULT_MAX_CHECK_LIST_SIZE); - - while(ckListIter.hasNext()) - { - CandidatePair pair = ckListIter.next(); - - //drop all pairs above MAX_CHECK_LIST_SIZE. - if(tmpCheckList.size() > maxCheckListSize) - { - ckListIter.remove(); - continue; - } - - //replace local server reflexive candidates with their base. - LocalCandidate localCnd = pair.getLocalCandidate(); - if( localCnd.getType() - == CandidateType.SERVER_REFLEXIVE_CANDIDATE) - { - pair.setLocalCandidate(localCnd.getBase()); - - //if the new pair corresponds to another one with a higher - //priority, then remove it. - if(tmpCheckList.contains(pair)) - { - ckListIter.remove(); - continue; - } - } - - tmpCheckList.add(pair); - } - } } /** diff --git a/src/org/ice4j/ice/NetworkUtils.java b/src/org/ice4j/ice/NetworkUtils.java index d2fbd1f..1c15857 100644 --- a/src/org/ice4j/ice/NetworkUtils.java +++ b/src/org/ice4j/ice/NetworkUtils.java @@ -33,11 +33,28 @@ public class NetworkUtils */ public static final String IN6_ADDR_ANY = "::0"; + /** + * The length of IPv6 addresses. + */ + private final static int IN6_ADDR_SIZE = 16; + + /** + * The size of the tokens in a String representation of IPv6 + * addresses. + */ + //private final static int IN6_ADDR_TOKEN_SIZE = 16; + private final static int IN6_ADDR_TOKEN_SIZE = 2; + /** * A string containing the "any" local address for IPv4. */ public static final String IN4_ADDR_ANY = "0.0.0.0"; + /** + * The length of IPv4 addresses. + */ + private final static int IN4_ADDR_SIZE = 4; + /** * A string containing the "any" local address. */ @@ -162,7 +179,7 @@ public class NetworkUtils */ public static boolean isIPv4Address(String address) { - return sun.net.util.IPAddressUtil.isIPv4LiteralAddress(address); + return strToIPv4(address) != null; } /** @@ -175,7 +192,7 @@ public class NetworkUtils */ public static boolean isIPv6Address(String address) { - return sun.net.util.IPAddressUtil.isIPv6LiteralAddress(address); + return strToIPv6(address) != null; } /** @@ -217,12 +234,11 @@ public class NetworkUtils byte[] addr = null; // see if it is IPv4 address - addr = sun.net.util.IPAddressUtil.textToNumericFormatV4(address); + addr = strToIPv4(address); // if not, see if it is IPv6 address if (addr == null) { - addr = sun.net.util.IPAddressUtil - .textToNumericFormatV6(address); + addr = strToIPv6(address); } // if IPv4 is found when IPv6 is expected else if (ipv6Expected) @@ -241,6 +257,308 @@ public class NetworkUtils return false; } + /** + * Creates a byte array containing the specified ipv4AddStr. + * + * @param ipv4AddrStr a String containing an IPv4 address. + * + * @return a byte array containing the four bytes of the address represented + * by ipv4AddrStr or null if ipv4AddrStr does not contain + * a valid IPv4 address string. + */ + public static byte[] strToIPv4(String ipv4AddrStr) + { + if (ipv4AddrStr.length() == 0) + return null; + + byte[] address = new byte[IN4_ADDR_SIZE]; + String[] tokens = ipv4AddrStr.split("\\.", -1); + long currentTkn; + try + { + switch(tokens.length) + { + case 1: + //If the address was specified as a single String we can + //directly copy it into the byte array. + currentTkn = Long.parseLong(tokens[0]); + if (currentTkn < 0 || currentTkn > 0xffffffffL) + return null; + address[0] = (byte) ((currentTkn >> 24) & 0xff); + address[1] = (byte) (((currentTkn & 0xffffff) >> 16) & 0xff); + address[2] = (byte) (((currentTkn & 0xffff) >> 8) & 0xff); + address[3] = (byte) (currentTkn & 0xff); + break; + case 2: + // If the address was passed in two parts (e.g. when dealing + // with a Class A address representation), we place the + // first one in the leftmost byte and the rest in the three + // remaining bytes of the address array. + currentTkn = Integer.parseInt(tokens[0]); + + if (currentTkn < 0 || currentTkn > 0xff) + return null; + + address[0] = (byte) (currentTkn & 0xff); + currentTkn = Integer.parseInt(tokens[1]); + + if (currentTkn < 0 || currentTkn > 0xffffff) + return null; + + address[1] = (byte) ((currentTkn >> 16) & 0xff); + address[2] = (byte) (((currentTkn & 0xffff) >> 8) &0xff); + address[3] = (byte) (currentTkn & 0xff); + break; + case 3: + // If the address was passed in three parts (e.g. when + // dealing with a Class B address representation), we place + // the first two parts in the two leftmost bytes and the + // rest in the two remaining bytes of the address array. + for (int i = 0; i < 2; i++) + { + currentTkn = Integer.parseInt(tokens[i]); + + if (currentTkn < 0 || currentTkn > 0xff) + return null; + + address[i] = (byte) (currentTkn & 0xff); + } + + currentTkn = Integer.parseInt(tokens[2]); + + if (currentTkn < 0 || currentTkn > 0xffff) + return null; + + address[2] = (byte) ((currentTkn >> 8) & 0xff); + address[3] = (byte) (currentTkn & 0xff); + break; + case 4: + // And now for the most common - four part case. This time + // there's a byte for every part :). Yuppiee! :) + for (int i = 0; i < 4; i++) + { + currentTkn = Integer.parseInt(tokens[i]); + + if (currentTkn < 0 || currentTkn > 0xff) + return null; + + address[i] = (byte) (currentTkn & 0xff); + } + break; + default: + return null; + } + } + catch(NumberFormatException e) + { + return null; + } + + return address; + } + + /** + * Creates a byte array containing the specified ipv6AddStr. + * + * @param ipv6AddrStr a String containing an IPv6 address. + * + * @return a byte array containing the four bytes of the address represented + * by ipv6AddrStr or null if ipv6AddrStr does + * not contain a valid IPv6 address string. + */ + public static byte[] strToIPv6(String ipv6AddrStr) + { + // Bail out if the string is shorter than "::" + if (ipv6AddrStr.length() < 2) + return null; + + int colonIndex; + char currentChar; + boolean sawtDigit; + int currentTkn; + char[] addrBuff = ipv6AddrStr.toCharArray(); + byte[] dst = new byte[IN6_ADDR_SIZE]; + + int srcb_length = addrBuff.length; + int scopeID = ipv6AddrStr.indexOf ("%"); + + if (scopeID == srcb_length -1) + return null; + + if (scopeID != -1) + srcb_length = scopeID; + + colonIndex = -1; + int i = 0, j = 0; + // Starting : mean we need to have at least one more. + if (addrBuff[i] == ':') + if (addrBuff[++i] != ':') + return null; + + int curtok = i; + sawtDigit = false; + currentTkn = 0; + while (i < srcb_length) + { + currentChar = addrBuff[i++]; + int chval = Character.digit(currentChar, 16); + if (chval != -1) + { + currentTkn <<= 4; + currentTkn |= chval; + if (currentTkn > 0xffff) + return null; + sawtDigit = true; + continue; + } + + if (currentChar == ':') + { + curtok = i; + + if (!sawtDigit) + { + if (colonIndex != -1) + return null; + colonIndex = j; + continue; + } + else if (i == srcb_length) + { + return null; + } + + if (j + IN6_ADDR_TOKEN_SIZE > IN6_ADDR_SIZE) + return null; + + dst[j++] = (byte) ((currentTkn >> 8) & 0xff); + dst[j++] = (byte) (currentTkn & 0xff); + sawtDigit = false; + currentTkn = 0; + continue; + } + + if (currentChar == '.' && ((j + IN4_ADDR_SIZE) <= IN6_ADDR_SIZE)) + { + String ia4 = ipv6AddrStr.substring(curtok, srcb_length); + // check this IPv4 address has 3 dots, ie. A.B.C.D + int dot_count = 0, index=0; + while ((index = ia4.indexOf ('.', index)) != -1) + { + dot_count ++; + index ++; + } + + if (dot_count != 3) + return null; + + byte[] v4addr = strToIPv4(ia4); + if (v4addr == null) + return null; + + for (int k = 0; k < IN4_ADDR_SIZE; k++) + { + dst[j++] = v4addr[k]; + } + + sawtDigit = false; + break; /* '\0' was seen by inet_pton4(). */ + } + return null; + } + + if (sawtDigit) + { + if (j + IN6_ADDR_TOKEN_SIZE > IN6_ADDR_SIZE) + return null; + + dst[j++] = (byte) ((currentTkn >> 8) & 0xff); + dst[j++] = (byte) (currentTkn & 0xff); + } + + if (colonIndex != -1) + { + int n = j - colonIndex; + + if (j == IN6_ADDR_SIZE) + return null; + + for (i = 1; i <= n; i++) + { + dst[IN6_ADDR_SIZE - i] = dst[colonIndex + n - i]; + dst[colonIndex + n - i] = 0; + } + + j = IN6_ADDR_SIZE; + } + + if (j != IN6_ADDR_SIZE) + return null; + + byte[] newdst = mappedIPv4ToRealIPv4(dst); + + if (newdst != null) + { + return newdst; + } + else + { + return dst; + } + } + + /** + * Returns an IPv4 address matching the one mapped in the IPv6 + * addr. Both input and returned value are in network order. + * + * @param addr a String representing an IPv4-Mapped address in textual + * format + * + * @return a byte array numerically representing the IPv4 address + */ + public static byte[] mappedIPv4ToRealIPv4(byte[] addr) + { + if (isMappedIPv4Addr(addr)) + { + byte[] newAddr = new byte[IN4_ADDR_SIZE]; + System.arraycopy(addr, 12, newAddr, 0, IN6_ADDR_SIZE); + return newAddr; + } + + return null; + } + + /** + * Utility method to check if the specified address is an IPv4 + * mapped IPv6 address. + * + * @param address the address that we'd like to determine as an IPv4 mapped + * one or not. + * + * @return true if address is an IPv4 mapped IPv6 address and + * false otherwise. + */ + private static boolean isMappedIPv4Addr(byte[] address) + { + if (address.length < IN6_ADDR_SIZE) + { + return false; + } + + if ((address[0] == 0x00) && (address[1] == 0x00) + && (address[2] == 0x00) && (address[3] == 0x00) + && (address[4] == 0x00) && (address[5] == 0x00) + && (address[6] == 0x00) && (address[7] == 0x00) + && (address[8] == 0x00) && (address[9] == 0x00) + && (address[10] == (byte)0xff) + && (address[11] == (byte)0xff)) + { + return true; + } + + return false; + } + /** * Creates an InetAddress from the specified hostAddress. The point * of using the method rather than creating the address by yourself is that @@ -293,14 +611,12 @@ public class NetworkUtils byte[] addr = null; // attempt parse as IPv4 address - addr = sun.net.util.IPAddressUtil - .textToNumericFormatV4(hostAddress); + addr = strToIPv4(hostAddress); // if not IPv4, parse as IPv6 address if (addr == null) { - addr = sun.net.util.IPAddressUtil - .textToNumericFormatV6(hostAddress); + addr = strToIPv6(hostAddress); } return InetAddress.getByAddress(hostAddress, addr); }