diff --git a/src/org/ice4j/attribute/AttributeDecoder.java b/src/org/ice4j/attribute/AttributeDecoder.java
index 7a3abd9..a4a563b 100644
--- a/src/org/ice4j/attribute/AttributeDecoder.java
+++ b/src/org/ice4j/attribute/AttributeDecoder.java
@@ -24,30 +24,22 @@ public class AttributeDecoder
* @param bytes the binary array that should be decoded.
* @param offset the index where the message starts.
* @param length the number of bytes that the message is long.
- * @param messageHeadBytes the binary array that contains the all the bytes
- * of the message that brought this attribute up until the beginning of the
- * attribute (at least).
- * @param messageHeadOffset the start of the container message in the
- * messageHeadBytes array.
- * @param messageHeadLen the length of the message head in the
- * messageHeadBytes array, up until the beginning of the attribute.
*
* @return An object representing the attribute encoded in bytes or null if
* the attribute was not recognized.
*
- * @throws StunException if bytes does is not a valid STUN attribute.
+ * @throws StunException if bytes is not a valid STUN attribute.
*/
public static Attribute decode(byte[] bytes,
- char offset,
- char length,
- byte[] messageHeadBytes,
- char messageHeadOffset,
- char messageHeadLen)
+ char offset,
+ char length)
throws StunException
{
if(bytes == null || bytes.length < Attribute.HEADER_LENGTH)
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
+ {
+ throw new StunException( StunException.ILLEGAL_ARGUMENT,
"Could not decode the specified binary array.");
+ }
//Discover attribute type
char attributeType = (char)((bytes[offset]<<8)|bytes[offset + 1]);
@@ -59,9 +51,8 @@ public class AttributeDecoder
}
if(attributeLength > bytes.length - offset )
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
- "The indicated attribute length ("+attributeLength+") "
- +"does not match the length of the passed binary array");
+ throw new StunException( StunException.ILLEGAL_ARGUMENT,
+ "Could not decode the specified binary array.");
Attribute decodedAttribute = null;
@@ -78,9 +69,7 @@ public class AttributeDecoder
decodedAttribute = new ErrorCodeAttribute(); break;
case Attribute.MESSAGE_INTEGRITY:
decodedAttribute = new MessageIntegrityAttribute(); break;
- case Attribute.PASSWORD:
- throw new UnsupportedOperationException(
- "The PASSWORD Attribute is not yet implemented.");
+ //case Attribute.PASSWORD: //handle as an unknown attribute
case Attribute.REFLECTED_FROM:
decodedAttribute = new ReflectedFromAttribute(); break;
case Attribute.RESPONSE_ADDRESS:
@@ -128,15 +117,14 @@ public class AttributeDecoder
//According to rfc3489 we should silently ignore unknown attributes.
default: decodedAttribute
- = new OptionalAttribute(Attribute.UNKNOWN_OPTIONAL_ATTRIBUTE);
+ = new OptionalAttribute( Attribute.UNKNOWN_OPTIONAL_ATTRIBUTE);
break;
}
decodedAttribute.setAttributeType(attributeType);
decodedAttribute.decodeAttributeBody(bytes,
- (char)(Attribute.HEADER_LENGTH + offset),
- attributeLength);
+ (char)(Attribute.HEADER_LENGTH + offset), attributeLength);
return decodedAttribute;
}
diff --git a/src/org/ice4j/ice/checks/ConnectivityCheckClient.java b/src/org/ice4j/ice/checks/ConnectivityCheckClient.java
index e3771b8..6db44ef 100644
--- a/src/org/ice4j/ice/checks/ConnectivityCheckClient.java
+++ b/src/org/ice4j/ice/checks/ConnectivityCheckClient.java
@@ -250,8 +250,6 @@ public class ConnectivityCheckClient
if(pairToCheck != null)
transactionID = parentClient.startCheckForPair(pairToCheck);
-
-
if(pairToCheck == null)
{
//we are done sending checks for this list. we'll send its
diff --git a/src/org/ice4j/message/Message.java b/src/org/ice4j/message/Message.java
index 8d40dbc..1067942 100644
--- a/src/org/ice4j/message/Message.java
+++ b/src/org/ice4j/message/Message.java
@@ -618,6 +618,7 @@ public abstract class Message
* @param offset the index where the message starts.
* @param arrayLen the length of the message
* @return a Message object constructed from the binMessage array
+ *
* @throws StunException ILLEGAL_ARGUMENT if one or more of the arguments
* have invalid values.
*/
@@ -626,12 +627,10 @@ public abstract class Message
{
int originalOffset = offset;
arrayLen = (char)Math.min(binMessage.length, arrayLen);
- char initialOffset = offset;
-
if(binMessage == null || arrayLen - offset < Message.HEADER_LENGTH)
{
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
+ throw new StunException( StunException.ILLEGAL_ARGUMENT,
"The given binary array is not a valid StunMessage");
}
@@ -648,7 +647,7 @@ public abstract class Message
}
else /* indication */
{
- message = new Indication();
+ message = new Indication();
}
message.setMessageType(messageType);
@@ -662,24 +661,31 @@ public abstract class Message
offset+=4;
if(arrayLen - offset - TRANSACTION_ID_LENGTH < length)
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
- "The given binary array does not seem to "
- +"contain a whole StunMessage");
+ {
+ throw new StunException( StunException.ILLEGAL_ARGUMENT,
+ "The given binary array does not seem to "
+ + "contain a whole StunMessage");
+ }
byte tranID[] = new byte[TRANSACTION_ID_LENGTH];
System.arraycopy(binMessage, offset, tranID, 0, TRANSACTION_ID_LENGTH);
- message.setTransactionID(tranID);
+ try
+ {
+ message.setTransactionID(tranID);
+ }
+ catch (StunException exc)
+ {
+ throw new StunException( StunException.ILLEGAL_ARGUMENT,
+ "The given binary array does not seem to "
+ + "contain a whole StunMessage", exc);
+ }
+
offset+=TRANSACTION_ID_LENGTH;
while(offset - Message.HEADER_LENGTH< length)
{
Attribute att = AttributeDecoder.decode(
- binMessage, offset, (char)(length - offset), //attribute
- binMessage, (char)initialOffset,
- (char)(offset - initialOffset)); // message head
-
- performAttributeSpecificActions(att, binMessage, message,
- originalOffset, offset);
+ binMessage, offset, (char)(length - offset));
message.addAttribute(att);
offset += att.getDataLength() + Attribute.HEADER_LENGTH;
@@ -688,219 +694,6 @@ public abstract class Message
return message;
}
- /**
- * Executes actions related specific attributes like asserting proper
- * checksums or verifying the validity of user names.
- *
- * @param attribute the Attribute we'd like to process.
- * @param binMessage the byte array that the message arrived with.
- * @param message the Message that we're parsing
- * binMessage into.
- * @param offset the index where data starts in binMessage.
- * @param msgLen the number of message bytes in binMessage.
- *
- * @throws StunException if there's something in the attribute
- * that caused us to discard the whole message (e.g. an invalid checksum
- * or username)
- */
- private static void performAttributeSpecificActions(Attribute attribute,
- byte[] binMessage,
- Message message,
- int offset,
- int msgLen)
- throws StunException
- {
- //assert valid username
- if (attribute instanceof UsernameAttribute)
- {
- if (!validateUsername( (UsernameAttribute)attribute))
- {
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
- "Non-recognized username: "
- + new String(((UsernameAttribute)attribute)
- .getUsername()) );
- }
-
- }
-
- //assert Message Integrity
- if (attribute instanceof MessageIntegrityAttribute)
- {
- if (!message.validateMessageIntegrity(
- (MessageIntegrityAttribute)attribute,
- binMessage, offset, msgLen))
- {
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
- "Wrong value in MESSAGE-INTEGRITY");
- }
-
- }
-
- //check finger print CRC
- if (attribute instanceof FingerprintAttribute)
- {
- if (!validateFingerprint((FingerprintAttribute)attribute,
- binMessage, offset, msgLen))
- {
- throw new StunException(StunException.ILLEGAL_ARGUMENT,
- "Wrong value in FINGERPRINT");
- }
-
- }
- }
-
- /**
- * Recalculates the fingerprint CRC32 checksum of the message
- * array so that we could compare it with the value brought by the
- * {@link FingerprintAttribute}.
- *
- * @param fingerprint the attribute that we need to validate.
- * @param message the message whose CRC32 checksum we'd need to recalculate.
- * @param offset the index in message where data starts.
- * @param length the number of bytes in message that the CRC32
- * would need to be calculated over.
- *
- * @return true if fingerprint contains a valid CRC32
- * value and false otherwise.
- */
- private static boolean validateFingerprint(FingerprintAttribute fingerprint,
- byte[] message,
- int offset,
- int length)
- {
-
- byte[] incomingCrcBytes = fingerprint.getChecksum();
-
- //now check whether the CRC really is what it's supposed to be.
- //re calculate the check sum
- byte[] realCrcBytes = FingerprintAttribute.calculateXorCRC32(
- message, offset, length);
-
- //CRC validation.
- if ( ! Arrays.equals(incomingCrcBytes, realCrcBytes))
- {
- if (logger.isLoggable(Level.FINE))
- {
- logger.fine(
- "An incoming message arrived with a wrong FINGERPRINT "
- +"attribute value. "
- +"CRC Was:" + Arrays.toString(incomingCrcBytes)
- + ". Should have been:" + Arrays.toString(realCrcBytes)
- +". Will ignore.");
- }
-
- return false;
- }
-
- return true;
- }
-
- /**
- * Recalculates the HMAC-SHA1 signature of the message array so
- * that we could compare it with the value brought by the
- * {@link MessageIntegrityAttribute}.
- *
- * @param msgInt the attribute that we need to validate.
- * @param message the message whose SHA1 checksum we'd need to recalculate.
- * @param offset the index in message where data starts.
- * @param length the number of bytes in message that the SHA1 would
- * need to be calculated over.
- *
- * @return true if msgInt contains a valid SHA1 value and
- * false otherwise.
- */
- private boolean validateMessageIntegrity(MessageIntegrityAttribute msgInt,
- byte[] message,
- int offset,
- int length)
- {
- //first get a password for the username specified with this message.
- UsernameAttribute unameAttr
- = (UsernameAttribute)getAttribute(Attribute.USERNAME);
-
- if (unameAttr == null)
- {
- logger.info( "Received a message containing a "
- +" MESSAGE-INTEGRITY attribute and no USERNAME");
- return false;
- }
-
-
- String username = new String(unameAttr.getUsername());
-
- int colon = username.indexOf(":");
-
- if( username.length() < 1
- || colon < 1)
- {
- if(logger.isLoggable(Level.FINE))
- {
- logger.log(Level.FINE, "Received a message with an improperly "
- +"formatted username");
- }
- return false;
- }
-
- String lfrag = username.substring(0, colon);
-
- byte[] key = StunStack.getInstance()
- .getCredentialsManager().getLocalKey(lfrag);
-
- if(key == null)
- return false;
-
- //now check whether the SHA1 matches.
- byte[] expectedSha1 = MessageIntegrityAttribute
- .calculateHmacSha1(message, offset, length, key);
-
- if (!Arrays.equals(expectedSha1, msgInt.getHmacSha1Content()))
- {
- if(logger.isLoggable(Level.FINE))
- {
- logger.log(Level.FINE, "Received a message with a wrong "
- +"MESSAGE-INTEGRITY HMAC-SHA1 signature");
- }
- return false;
- }
-
- if (logger.isLoggable(Level.FINEST))
- logger.finest("Successfully verified msg integrity");
-
- return true;
- }
-
- /**
- * Asserts the validity of the user name we've received in
- * unameAttr.
- *
- * @param unameAttr the attribute that we need to validate.
- *
- * @return true if unameAttr contains a valid user name
- * and false otherwise.
- */
- private static boolean validateUsername(UsernameAttribute unameAttr)
- {
- String username = new String(unameAttr.getUsername());
-
- int colon = username.indexOf(":");
-
- if( username.length() < 1
- || colon < 1)
- {
- if(logger.isLoggable(Level.FINE))
- {
- logger.log(Level.FINE, "Received a message with an improperly "
- +"formatted username");
- }
- return false;
- }
-
- String lfrag = username.substring(0, colon);
-
- return StunStack.getInstance()
- .getCredentialsManager().checkLocalUserName(lfrag);
- }
-
/**
* Verify that the message has all obligatory attributes and throw an
* exception if this is not the case.
diff --git a/src/org/ice4j/message/MessageDecodeException.java b/src/org/ice4j/message/MessageDecodeException.java
new file mode 100644
index 0000000..0a11ed0
--- /dev/null
+++ b/src/org/ice4j/message/MessageDecodeException.java
@@ -0,0 +1,148 @@
+/*
+ * 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.message;
+
+import org.ice4j.attribute.*;
+
+/**
+ * The {@link MessageDecodeException} is thrown during decoding in order
+ * to indicate what problems there might have been with a particular incoming
+ * message. The exception is particularly useful when decoding incoming requests
+ * so that the stack could generate an appropriate error response.
+ *
+ * @author Emil Ivov
+ */
+public class MessageDecodeException
+ extends Exception
+{
+ /**
+ * Dummy version UID
+ */
+ static final long serialVersionUID = -1L;
+
+ /**
+ * The error code to use in case we do not want this exception to cause a
+ * response and would prefer to discard instead.
+ */
+ public static int NO_RESPONSE = -1;
+
+ /**
+ * A STUN Error Response code to use if the message that caused the
+ * exception was a {@link Request} and we could send an error response.
+ */
+ private int stunResponseCode = NO_RESPONSE;
+
+ /**
+ * An attribute to include in the error response.
+ */
+ private Attribute responseAttribute = null;
+
+ /**
+ * The ID of the transaction to use in case the exception allows for
+ * sending an error response.
+ */
+ private byte[] transactionID = null;
+
+ /**
+ * Creates a new MessageDecodeException instance.
+ *
+ * @param message a text message explaining the exception
+ */
+ public MessageDecodeException(String message)
+ {
+ super(message);
+ }
+
+ /**
+ * Creates a new MessageDecodeException instance.
+ *
+ * @param message a text message explaining the exception
+ * @param cause A reference to a {@link Throwable} instance in case this
+ * exception was caused by another, unexpected exception.
+ */
+ public MessageDecodeException(String message,
+ Throwable cause)
+ {
+ super(message, cause);
+ }
+
+ /**
+ * Creates a new MessageDecodeException instance.
+ *
+ * @param message a text message explaining the exception
+ * @param stunResponseCode a STUN Error Response code to use if the message
+ * that caused the exception was a {@link Request} and we could send an
+ * error response, or -1 in case we should not reply.
+ * @param transactionID the id of the transaction to use in an error
+ * response.
+ */
+ public MessageDecodeException(String message,
+ int stunResponseCode,
+ byte[] transactionID)
+ {
+ super(message);
+ this.stunResponseCode = stunResponseCode;
+ this.transactionID = transactionID;
+ }
+
+ /**
+ * Creates a new MessageDecodeException instance.
+ *
+ * @param message a text message explaining the exception
+ * @param stunResponseCode a STUN Error Response code to use if the message
+ * that caused the exception was a {@link Request} and we could send an
+ * error response, or -1 in case we should not reply.
+ * @param transactionID the id of the transaction to use in an error
+ * response.
+ * @param attribute the Attribute an attribute to include in the error
+ * response.
+ */
+ public MessageDecodeException(String message,
+ int stunResponseCode,
+ byte[] transactionID,
+ Attribute attribute)
+ {
+ super(message);
+ this.stunResponseCode = stunResponseCode;
+ this.transactionID = transactionID;
+ }
+
+
+ /**
+ * Returns a STUN Error Response code to use if the message that caused the
+ * exception was a {@link Request} and we could send an error response.
+ *
+ * @return a STUN Error Response code to use if the message that caused the
+ * exception was a {@link Request} and we could send an error response.
+ */
+ public int getErrorResponseCode()
+ {
+ return stunResponseCode;
+ }
+
+ /**
+ * Returns whatever attribute would have to be included in a potential
+ * error response like for example the attribute that cause a 420 error.
+ *
+ * @return whatever attribute would have to be included in a potential
+ * error response like for example the attribute that cause a 420 error.
+ */
+ public Attribute getResponseAttribute()
+ {
+ return responseAttribute;
+ }
+
+ /**
+ * Returns the id of the transaction to use in an error response.
+ *
+ * @return the id of the transaction to use in an error response.
+ */
+ public byte[] getTransactionID()
+ {
+ return transactionID;
+ }
+}
diff --git a/src/org/ice4j/stack/MessageProcessor.java b/src/org/ice4j/stack/MessageProcessor.java
index 561dc29..d2ac4a3 100644
--- a/src/org/ice4j/stack/MessageProcessor.java
+++ b/src/org/ice4j/stack/MessageProcessor.java
@@ -9,6 +9,7 @@ package org.ice4j.stack;
import java.util.logging.*;
import org.ice4j.*;
+import org.ice4j.attribute.*;
import org.ice4j.message.*;
/**
@@ -125,10 +126,11 @@ class MessageProcessor
(char) 0,
(char) rawMessage.getMessageLength());
}
- catch (StunException ex)
+ catch (MessageDecodeException ex)
{
errorHandler.handleError("Failed to decode a stun mesage!",
ex);
+
continue; //let this one go and for better luck next time.
}
diff --git a/src/org/ice4j/stack/StunStack.java b/src/org/ice4j/stack/StunStack.java
index f79fa30..51f00da 100644
--- a/src/org/ice4j/stack/StunStack.java
+++ b/src/org/ice4j/stack/StunStack.java
@@ -523,6 +523,8 @@ public class StunStack
sTran.start();
}
+ //validate attributes that need validation.
+
eventDispatcher.fireMessageEvent(event);
}
@@ -584,4 +586,229 @@ public class StunStack
tran.expire();
}
}
+
+ /**
+ * Executes actions related specific attributes like asserting proper
+ * checksums or verifying the validity of user names.
+ *
+ * @param attribute the Attribute we'd like to process.
+ * @param binMessage the byte array that the message arrived with.
+ * @param message the Message that we're parsing
+ * binMessage into.
+ * @param offset the index where data starts in binMessage.
+ * @param msgLen the number of message bytes in binMessage.
+ *
+ * @throws MessageDecodeException if there's something in the
+ * attribute that caused us to discard the whole message (e.g. an
+ * invalid checksum
+ * or username)
+ */
+ private void performAttributeSpecificActions(Attribute attribute,
+ byte[] binMessage,
+ Message message,
+ int offset,
+ int msgLen)
+ throws MessageDecodeException
+ {
+ ///HANDLE OPTIONAL ATTRIBUTES
+ byte[] tranID = message.getTransactionID();
+ //assert valid username
+ if (attribute instanceof UsernameAttribute)
+ {
+ if (!validateUsername( (UsernameAttribute)attribute))
+ {
+ throw new MessageDecodeException(
+ "Non-recognized username: "
+ + new String(((UsernameAttribute)attribute)
+ .getUsername()),
+ ErrorCodeAttribute.UNAUTHORIZED, tranID);
+ }
+ }
+
+ //assert Message Integrity
+ if (attribute instanceof MessageIntegrityAttribute)
+ {
+ //we should complain if we have msg integrity and no username.
+ if (message.getAttribute(Attribute.USERNAME) == null)
+ {
+ throw new MessageDecodeException(
+ "Missing USERNAME in the presence of MESSAGE-INTEGRITY: ",
+ ErrorCodeAttribute.BAD_REQUEST, tranID);
+ }
+
+ if (!validateMessageIntegrity((MessageIntegrityAttribute)attribute,
+ binMessage, offset, msgLen))
+ {
+ throw new MessageDecodeException(
+ "Wrong MESSAGE-INTEGRITY value.",
+ ErrorCodeAttribute.UNAUTHORIZED, tranID);
+ }
+
+ }
+
+ //check finger print CRC
+ if (attribute instanceof FingerprintAttribute)
+ {
+ if (!validateFingerprint((FingerprintAttribute)attribute,
+ binMessage, offset, msgLen))
+ {
+ //RFC 5389 says that we should ignore bad CRCs rather than
+ //reply with an error response.
+ throw new MessageDecodeException(
+ "Wrong value in FINGERPRINT");
+ }
+ }
+ }
+
+ /**
+ * Recalculates the FINGERPRINT CRC32 checksum of the message
+ * array so that we could compare it with the value brought by the
+ * {@link FingerprintAttribute}.
+ *
+ * @param fingerprint the attribute that we need to validate.
+ * @param message the message whose CRC32 checksum we'd need to recalculate.
+ * @param offset the index in message where data starts.
+ * @param length the number of bytes in message that the CRC32
+ * would need to be calculated over.
+ *
+ * @return true if FINGERPRINT contains a valid CRC32
+ * value and false otherwise.
+ */
+ private static boolean validateFingerprint(FingerprintAttribute fingerprint,
+ byte[] message,
+ int offset,
+ int length)
+ {
+
+ byte[] incomingCrcBytes = fingerprint.getChecksum();
+
+ //now check whether the CRC really is what it's supposed to be.
+ //re calculate the check sum
+ byte[] realCrcBytes = FingerprintAttribute.calculateXorCRC32(
+ message, offset, length);
+
+ //CRC validation.
+ if ( ! Arrays.equals(incomingCrcBytes, realCrcBytes))
+ {
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine(
+ "An incoming message arrived with a wrong FINGERPRINT "
+ +"attribute value. "
+ +"CRC Was:" + Arrays.toString(incomingCrcBytes)
+ + ". Should have been:" + Arrays.toString(realCrcBytes)
+ +". Will ignore.");
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Recalculates the HMAC-SHA1 signature of the message array so
+ * that we could compare it with the value brought by the
+ * {@link MessageIntegrityAttribute}.
+ *
+ * @param msgInt the attribute that we need to validate.
+ * @param message the message whose SHA1 checksum we'd need to recalculate.
+ * @param offset the index in message where data starts.
+ * @param length the number of bytes in message that the SHA1 would
+ * need to be calculated over.
+ *
+ * @return true if msgInt contains a valid SHA1 value and
+ * false otherwise.
+ */
+ private boolean validateMessageIntegrity(MessageIntegrityAttribute msgInt,
+ byte[] message,
+ int offset,
+ int length)
+ {
+ //first get a password for the username specified with this message.
+ UsernameAttribute unameAttr
+ = (UsernameAttribute)getAttribute(Attribute.USERNAME);
+
+ if (unameAttr == null)
+ {
+ logger.info( "Received a message containing a "
+ +" MESSAGE-INTEGRITY attribute and no USERNAME");
+ return false;
+ }
+
+ String username = new String(unameAttr.getUsername());
+
+ int colon = username.indexOf(":");
+
+ if( username.length() < 1
+ || colon < 1)
+ {
+ if(logger.isLoggable(Level.FINE))
+ {
+ logger.log(Level.FINE, "Received a message with an improperly "
+ +"formatted username");
+ }
+ return false;
+ }
+
+ String lfrag = username.substring(0, colon);
+
+ byte[] key = StunStack.getInstance()
+ .getCredentialsManager().getLocalKey(lfrag);
+
+ if(key == null)
+ return false;
+
+ //now check whether the SHA1 matches.
+ byte[] expectedSha1 = MessageIntegrityAttribute
+ .calculateHmacSha1(message, offset, length, key);
+
+ if (!Arrays.equals(expectedSha1, msgInt.getHmacSha1Content()))
+ {
+ if(logger.isLoggable(Level.FINE))
+ {
+ logger.log(Level.FINE, "Received a message with a wrong "
+ +"MESSAGE-INTEGRITY HMAC-SHA1 signature");
+ }
+ return false;
+ }
+
+ if (logger.isLoggable(Level.FINEST))
+ logger.finest("Successfully verified msg integrity");
+
+ return true;
+ }
+
+ /**
+ * Asserts the validity of the user name we've received in
+ * unameAttr.
+ *
+ * @param unameAttr the attribute that we need to validate.
+ *
+ * @return true if unameAttr contains a valid user name
+ * and false otherwise.
+ */
+ private static boolean validateUsername(UsernameAttribute unameAttr)
+ {
+ String username = new String(unameAttr.getUsername());
+
+ int colon = username.indexOf(":");
+
+ if( username.length() < 1
+ || colon < 1)
+ {
+ if(logger.isLoggable(Level.FINE))
+ {
+ logger.log(Level.FINE, "Received a message with an improperly "
+ +"formatted username");
+ }
+
+ return false;
+ }
+
+ String lfrag = username.substring(0, colon);
+
+ return StunStack.getInstance()
+ .getCredentialsManager().checkLocalUserName(lfrag);
+ }
}
diff --git a/test/org/ice4j/attribute/AttributeDecoderTest.java b/test/org/ice4j/attribute/AttributeDecoderTest.java
index 1d9adbe..23f976e 100644
--- a/test/org/ice4j/attribute/AttributeDecoderTest.java
+++ b/test/org/ice4j/attribute/AttributeDecoderTest.java
@@ -67,8 +67,7 @@ public class AttributeDecoderTest extends TestCase {
Transport.UDP));
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals(
"AttributeDecoder.decode() failed for a MAPPED-ADDRESS attribute",
@@ -92,8 +91,7 @@ public class AttributeDecoderTest extends TestCase {
Transport.UDP));
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals(
"AttributeDecoder.decode() failed for a MAPPED-ADDRESS attribute",
@@ -101,7 +99,7 @@ public class AttributeDecoderTest extends TestCase {
}
public void testDecodeChangeRequest()
- throws StunException
+ throws Exception
{
//
byte[] bytes = msgFixture.chngReqTestValue1;
@@ -114,8 +112,7 @@ public class AttributeDecoderTest extends TestCase {
expectedReturn.setChangePortFlag(MsgFixture.CHANGE_PORT_FLAG_1);
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals("AttributeDecoder.decode() failed for a CHANGE-REQUEST attribute",
expectedReturn, actualReturn);
@@ -123,7 +120,7 @@ public class AttributeDecoderTest extends TestCase {
public void testDecodeErrorCode()
- throws StunException
+ throws Exception
{
//
byte[] bytes = msgFixture.errCodeTestValue;
@@ -137,8 +134,7 @@ public class AttributeDecoderTest extends TestCase {
expectedReturn.setReasonPhrase(MsgFixture.REASON_PHRASE);
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals(
"AttributeDecoder.decode() failed for a ERROR-CODE attribute",
expectedReturn, actualReturn);
@@ -146,7 +142,7 @@ public class AttributeDecoderTest extends TestCase {
}
public void testDecodeUnknownAttributes()
- throws StunException
+ throws Exception
{
//unknown attributes
byte[] bytes = msgFixture.unknownAttsDecodeTestValue;
@@ -154,14 +150,14 @@ public class AttributeDecoderTest extends TestCase {
char length = (char)msgFixture.mappedAddress.length;
//create the message
- UnknownAttributesAttribute expectedReturn = new UnknownAttributesAttribute();
+ UnknownAttributesAttribute expectedReturn
+ = new UnknownAttributesAttribute();
expectedReturn.addAttributeID(MsgFixture.UNKNOWN_ATTRIBUTES_1ST_ATT);
expectedReturn.addAttributeID(MsgFixture.UNKNOWN_ATTRIBUTES_2ND_ATT);
expectedReturn.addAttributeID(MsgFixture.UNKNOWN_ATTRIBUTES_3D_ATT);
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals("AttributeDecoder.decode() failed for a ERROR-CODE attribute",
expectedReturn, actualReturn);
@@ -169,7 +165,7 @@ public class AttributeDecoderTest extends TestCase {
}
public void testDecodeUnknownOptionalAttribute()
- throws StunException
+ throws Exception
{
//unknown attributes
byte[] bytes = msgFixture.unknownOptionalAttribute;
@@ -183,8 +179,7 @@ public class AttributeDecoderTest extends TestCase {
expectedAttributeValue.length);
Attribute actualReturn = AttributeDecoder.decode(
- bytes, offset, length, //attribute
- bytes, (char)0, offset);//message head
+ bytes, offset, length, null);
assertEquals(
"AttributeDecoder.decode() failed for a UNKNOWN_OPTIONAL attribute",
expectedReturn, actualReturn);
diff --git a/test/org/ice4j/message/MessageTest.java b/test/org/ice4j/message/MessageTest.java
index 5528f7e..29afa12 100644
--- a/test/org/ice4j/message/MessageTest.java
+++ b/test/org/ice4j/message/MessageTest.java
@@ -157,14 +157,14 @@ public class MessageTest extends TestCase {
* @throws StunException java.lang.Exception if we fail
*/
public void testDecode()
- throws StunException
+ throws Exception
{
//Binding Request
Message expectedReturn = bindingRequest;
Message actualReturn = Message.decode(msgFixture.bindingRequest,
- (char)0,
- (char)msgFixture.bindingRequest.length);
+ (char)0,
+ (char)msgFixture.bindingRequest.length);
assertEquals("A binding request was not properly decoded",
expectedReturn, actualReturn );
@@ -173,8 +173,8 @@ public class MessageTest extends TestCase {
expectedReturn = bindingResponse;
actualReturn = Message.decode(msgFixture.bindingResponse,
- (char)0,
- (char)msgFixture.bindingResponse.length);
+ (char)0,
+ (char)msgFixture.bindingResponse.length);
assertEquals("A binding response was not properly decoded",
expectedReturn, actualReturn );
@@ -192,36 +192,44 @@ public class MessageTest extends TestCase {
Object target = null;
boolean expectedReturn = false;
boolean actualReturn = bindingRequest.equals(target);
- assertEquals("Equals failed against a null target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against a null target",
+ expectedReturn, actualReturn);
actualReturn = bindingResponse.equals(target);
- assertEquals("Equals failed against a null target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against a null target",
+ expectedReturn, actualReturn);
//different
actualReturn = bindingRequest.equals(bindingResponse);
- assertEquals("Equals failed against a different target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against a different target",
+ expectedReturn, actualReturn);
actualReturn = bindingResponse.equals(bindingRequest);
- assertEquals("Equals failed against a different target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against a different target",
+ expectedReturn, actualReturn);
//same
expectedReturn = true;
- //Create a binding request with the same attributes as this.bindingRequest
+ //Create a binding request with the same attributes as
+ //this.bindingRequest
Request binReqTarget = new Request();
binReqTarget.setMessageType(Message.BINDING_REQUEST);
binReqTarget.addAttribute(changeRequest);
actualReturn = bindingRequest.equals(binReqTarget);
- assertEquals("Equals failed against an equal target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against an equal target",
+ expectedReturn, actualReturn);
- //Create a binding response with the same attributes as this.bindingRequest
+ //Create a binding response with the same attributes as
+ //this.bindingRequest
Response binResTarget = new Response();
binResTarget.setMessageType(Message.BINDING_RESPONSE);
binResTarget.addAttribute(mappedAddress);
binResTarget.addAttribute(sourceAddress);
binResTarget.addAttribute(changedAddress);
actualReturn = bindingResponse.equals(binResTarget);
- assertEquals("Equals failed against a different target", expectedReturn, actualReturn);
+ assertEquals("Equals failed against a different target",
+ expectedReturn, actualReturn);
}
/**
@@ -246,12 +254,13 @@ public class MessageTest extends TestCase {
bindingRequest.removeAttribute(changeRequest.getAttributeType());
assertNull("An attribute was still in the request after being removed",
- bindingRequest.getAttribute(changeRequest.getAttributeType()));
+ bindingRequest.getAttribute(changeRequest.getAttributeType()));
//test count
int expectedReturn = 0;
int actualReturn = bindingRequest.getAttributeCount();
- assertEquals("Attribute count did not change after removing an attribute",
- expectedReturn, actualReturn);
+ assertEquals(
+ "Attribute count did not change after removing an attribute",
+ expectedReturn, actualReturn);
}
}