third_party/libjingle/source/talk/p2p/base/stun_unittest.cc - vendor/opensource/webrtc - Git at Google

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <string>

 #include "talk/base/bytebuffer.h"
 #include "talk/base/gunit.h"
 #include "talk/base/logging.h"
 #include "talk/p2p/base/stun.h"

 using namespace cricket;

 static const unsigned char INPUT_STUN[] = {
   0x00, 0x01, 0x00, 135,   // message header
   0x21, 0x12, 0xA4, 0x42,  // magic cookie
   '0', '1', '2', '3',      // transaction id
   '4', '5', '6', '7',
   '8', '9', 'a', 'b',
   0x00, 0x01, 0x00, 8,     // mapped address
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x06, 0x00, 12,    // username
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
   0x00, 0x08, 0x00, 20,    // message integrity
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
   'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
   0x00, 0x09, 0x00, 12,    // error code
   0x00, 0x00, 2, 10,
   'f', 'o', 'o', ' ', 'b', 'a', 'r', '!',
   0x00, 0x0a, 0x00, 4,     // unknown attributes
   0x00, 0x01, 0x00, 0x02,
   0x00, 0x0d, 0x00, 4,     // lifetime
   0x00, 0x00, 0x00, 11,
   0x00, 0x0f, 0x00, 4,     // magic cookie
   0x72, 0xc6, 0x4b, 0xc6,
   0x00, 0x10, 0x00, 4,     // bandwidth
   0x00, 0x00, 0x00, 6,
   0x00, 0x11, 0x00, 8,     // destination address
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x12, 0x00, 8,     // source address 2
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x13, 0x00, 7,     // data
   'a', 'b', 'c', 'd', 'e', 'f', 'g'
 };


 // RTCP packet, for testing we correctly ignore non stun packet types.
 // V=2, P=false, RC=0, Type=200, Len=6, Sender-SSRC=85, etc
 static const unsigned char INPUT_RTCP[] = {
   0x80, 0xc8, 0x00, 0x06, 0x00, 0x00, 0x00, 0x55,
   0xce, 0xa5, 0x18, 0x3a, 0x39, 0xcc, 0x7d, 0x09,
   0x23, 0xed, 0x19, 0x07, 0x00, 0x00, 0x01, 0x56,
   0x00, 0x03, 0x73, 0x50,
 };

 // STUN packet with a legacy header.
 static const unsigned char INPUT_LEGACY[] = {
   0x00, 0x01, 0x00, 135,   // message header
   '0', '1', '2', '3',      // transaction id
   '4', '5', '6', '7',
   '8', '9', 'a', 'b',
   'c', 'd', 'e', 'f',
   0x00, 0x01, 0x00, 8,     // mapped address
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x06, 0x00, 12,    // username
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
   0x00, 0x08, 0x00, 20,    // message integrity
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
   'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
   0x00, 0x09, 0x00, 12,    // error code
   0x00, 0x00, 2, 10,
   'f', 'o', 'o', ' ', 'b', 'a', 'r', '!',
   0x00, 0x0a, 0x00, 4,     // unknown attributes
   0x00, 0x01, 0x00, 0x02,
   0x00, 0x0d, 0x00, 4,     // lifetime
   0x00, 0x00, 0x00, 11,
   0x00, 0x0f, 0x00, 4,     // magic cookie
   0x72, 0xc6, 0x4b, 0xc6,
   0x00, 0x10, 0x00, 4,     // bandwidth
   0x00, 0x00, 0x00, 6,
   0x00, 0x11, 0x00, 8,     // destination address
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x12, 0x00, 8,     // source address 2
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0x13, 0x00, 7,     // data
   'a', 'b', 'c', 'd', 'e', 'f', 'g'
 };

 static const unsigned char INPUT_STUN_UNKNOWN_ATTR[] = {
   0x00, 0x01, 0x00, 0x1F,  // message header
   0x21, 0x12, 0xA4, 0x42,  // magic cookie
   '0', '1', '2', '3',      // transaction id
   '4', '5', '6', '7',
   '8', '9', 'a', 'b',
   0x00, 0x01, 0x00, 8,     // mapped address
   0x00, 0x01, 0x00, 13,
   0x00, 0x00, 0x00, 17,
   0x00, 0xaa, 0x00, 7,     // unknown attribute
   'a', 'b', 'c', 'd', 'e', 'f', 'g',
   0x00, 0x0d, 0x00, 4,     // lifetime
   0x00, 0x00, 0x00, 11,
 };

 static const unsigned char INPUT_STUN_XOR_MAPPED_ADDRESS[] = {
   0x00, 0x01, 0x00, 0x0c,  // message header
   0x21, 0x12, 0xA4, 0x42,  // magic cookie
   '0', '1', '2', '3',      // transaction id
   '4', '5', '6', '7',
   '8', '9', 'a', 'b',
   0x00, 0x20, 0x00, 0x08,  // xor mapped address
   0x00, 0x01, 0x21, 0x1F,
   0x21, 0x12, 0xA4, 0x53,
 };

 static void DoTest(const char* input, size_t size, const char* transaction_id) {
   StunMessage msg, msg2;

   talk_base::ByteBuffer buf(input, size);
   EXPECT_TRUE(msg.Read(&buf));

   EXPECT_EQ(STUN_BINDING_REQUEST, msg.type());
   EXPECT_EQ(size - 20, msg.length());
   EXPECT_EQ(transaction_id, msg.transaction_id());

   msg2.SetType(STUN_BINDING_REQUEST);
   msg2.SetTransactionID(transaction_id);

   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

   StunAddressAttribute* addr2 =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(talk_base::IPAddress(17U));
   msg2.AddAttribute(addr2);

   const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
   EXPECT_TRUE(bytes != NULL);
   EXPECT_EQ(12, bytes->length());
   EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefghijkl", bytes->length()));

   StunByteStringAttribute* bytes2 =
       StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   bytes2->CopyBytes("abcdefghijkl");
   msg2.AddAttribute(bytes2);

   bytes = msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
   EXPECT_TRUE(bytes != NULL);
   EXPECT_EQ(20, bytes->length());
   EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefghijklmnopqrst", bytes->length()));

   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MESSAGE_INTEGRITY);
   bytes2->CopyBytes("abcdefghijklmnopqrst");
   msg2.AddAttribute(bytes2);

   const StunErrorCodeAttribute* ecode = msg.GetErrorCode();
   EXPECT_TRUE(ecode != NULL);
   EXPECT_EQ(2, ecode->error_class());
   EXPECT_EQ(10, ecode->number());
   EXPECT_EQ("foo bar!", ecode->reason());

   StunErrorCodeAttribute* ecode2 = StunAttribute::CreateErrorCode();
   ecode2->SetErrorClass(2);
   ecode2->SetNumber(10);
   ecode2->SetReason("foo bar!");
   msg2.AddAttribute(ecode2);

   const StunUInt16ListAttribute* unknown = msg.GetUnknownAttributes();
   EXPECT_TRUE(unknown != NULL);
   EXPECT_EQ(2U, unknown->Size());
   EXPECT_EQ(1U, unknown->GetType(0));
   EXPECT_EQ(2U, unknown->GetType(1));

   StunUInt16ListAttribute* unknown2 = StunAttribute::CreateUnknownAttributes();
   unknown2->AddType(1);
   unknown2->AddType(2);
   msg2.AddAttribute(unknown2);

   const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
   EXPECT_TRUE(uval != NULL);
   EXPECT_EQ(11U, uval->value());

   StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
   uval2->SetValue(11);
   msg2.AddAttribute(uval2);

   bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
   EXPECT_TRUE(bytes != NULL);
   EXPECT_EQ(4, bytes->length());
   EXPECT_EQ(0, memcmp(bytes->bytes(), TURN_MAGIC_COOKIE_VALUE,
                       sizeof(TURN_MAGIC_COOKIE_VALUE)));

   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
   bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
                     sizeof(TURN_MAGIC_COOKIE_VALUE));
   msg2.AddAttribute(bytes2);

   uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
   EXPECT_TRUE(uval != NULL);
   EXPECT_EQ(6U, uval->value());

   uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
   uval2->SetValue(6);
   msg2.AddAttribute(uval2);

   addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

   addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(talk_base::IPAddress(17U));
   msg2.AddAttribute(addr2);

   addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

   addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr2->SetPort(13);
   addr2->SetIP(talk_base::IPAddress(17U));
   msg2.AddAttribute(addr2);

   bytes = msg.GetByteString(STUN_ATTR_DATA);
   EXPECT_TRUE(bytes != NULL);
   EXPECT_EQ(7, bytes->length());
   EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefg", bytes->length()));

   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   bytes2->CopyBytes("abcdefg");
   msg2.AddAttribute(bytes2);

   talk_base::ByteBuffer out;
   msg.Write(&out);
   EXPECT_EQ(size, out.Length());
   EXPECT_EQ(0, memcmp(out.Data(), input, out.Length()));

   talk_base::ByteBuffer out2;
   msg2.Write(&out2);
   EXPECT_EQ(size, out2.Length());
   EXPECT_EQ(0, memcmp(out2.Data(), input, out2.Length()));
 }

 TEST(StunTest, TestStunPacket) {
   DoTest(reinterpret_cast<const char*>(INPUT_STUN), sizeof(INPUT_STUN),
          "0123456789ab");
 }

 TEST(StunTest, TestRejectsRtcpPacket) {
   StunMessage msg;

   talk_base::ByteBuffer buf(
       reinterpret_cast<const char*>(INPUT_RTCP), sizeof(INPUT_RTCP));
   EXPECT_FALSE(msg.Read(&buf));
 }

 TEST(StunTest, TestLegacyPacket) {
   DoTest(reinterpret_cast<const char*>(INPUT_LEGACY),
          sizeof(INPUT_LEGACY), "0123456789abcdef");
 }

 TEST(StunTest, TestIgnoreUnknownAttr) {
   StunMessage msg;
   talk_base::ByteBuffer buf(
       reinterpret_cast<const char*>(INPUT_STUN_UNKNOWN_ATTR),
       sizeof(INPUT_STUN_UNKNOWN_ATTR));
   EXPECT_TRUE(msg.Read(&buf));

   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

   const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
   EXPECT_TRUE(uval != NULL);
   EXPECT_EQ(11U, uval->value());
 }

 TEST(StunTest, TestXorMappedAddress) {
   StunMessage msg;
   talk_base::ByteBuffer buf(
       reinterpret_cast<const char*>(INPUT_STUN_XOR_MAPPED_ADDRESS),
       sizeof(INPUT_STUN_XOR_MAPPED_ADDRESS));
   EXPECT_TRUE(msg.Read(&buf));

   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

   addr = msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   EXPECT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
 }
	/*
	* libjingle
	* Copyright 2004 Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <string>

	#include "talk/base/bytebuffer.h"
	#include "talk/base/gunit.h"
	#include "talk/base/logging.h"
	#include "talk/p2p/base/stun.h"

	using namespace cricket;

	static const unsigned char INPUT_STUN[] = {
	0x00, 0x01, 0x00, 135, // message header
	0x21, 0x12, 0xA4, 0x42, // magic cookie
	'0', '1', '2', '3', // transaction id
	'4', '5', '6', '7',
	'8', '9', 'a', 'b',
	0x00, 0x01, 0x00, 8, // mapped address
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x06, 0x00, 12, // username
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	0x00, 0x08, 0x00, 20, // message integrity
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
	0x00, 0x09, 0x00, 12, // error code
	0x00, 0x00, 2, 10,
	'f', 'o', 'o', ' ', 'b', 'a', 'r', '!',
	0x00, 0x0a, 0x00, 4, // unknown attributes
	0x00, 0x01, 0x00, 0x02,
	0x00, 0x0d, 0x00, 4, // lifetime
	0x00, 0x00, 0x00, 11,
	0x00, 0x0f, 0x00, 4, // magic cookie
	0x72, 0xc6, 0x4b, 0xc6,
	0x00, 0x10, 0x00, 4, // bandwidth
	0x00, 0x00, 0x00, 6,
	0x00, 0x11, 0x00, 8, // destination address
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x12, 0x00, 8, // source address 2
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x13, 0x00, 7, // data
	'a', 'b', 'c', 'd', 'e', 'f', 'g'
	};


	// RTCP packet, for testing we correctly ignore non stun packet types.
	// V=2, P=false, RC=0, Type=200, Len=6, Sender-SSRC=85, etc
	static const unsigned char INPUT_RTCP[] = {
	0x80, 0xc8, 0x00, 0x06, 0x00, 0x00, 0x00, 0x55,
	0xce, 0xa5, 0x18, 0x3a, 0x39, 0xcc, 0x7d, 0x09,
	0x23, 0xed, 0x19, 0x07, 0x00, 0x00, 0x01, 0x56,
	0x00, 0x03, 0x73, 0x50,
	};

	// STUN packet with a legacy header.
	static const unsigned char INPUT_LEGACY[] = {
	0x00, 0x01, 0x00, 135, // message header
	'0', '1', '2', '3', // transaction id
	'4', '5', '6', '7',
	'8', '9', 'a', 'b',
	'c', 'd', 'e', 'f',
	0x00, 0x01, 0x00, 8, // mapped address
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x06, 0x00, 12, // username
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	0x00, 0x08, 0x00, 20, // message integrity
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
	0x00, 0x09, 0x00, 12, // error code
	0x00, 0x00, 2, 10,
	'f', 'o', 'o', ' ', 'b', 'a', 'r', '!',
	0x00, 0x0a, 0x00, 4, // unknown attributes
	0x00, 0x01, 0x00, 0x02,
	0x00, 0x0d, 0x00, 4, // lifetime
	0x00, 0x00, 0x00, 11,
	0x00, 0x0f, 0x00, 4, // magic cookie
	0x72, 0xc6, 0x4b, 0xc6,
	0x00, 0x10, 0x00, 4, // bandwidth
	0x00, 0x00, 0x00, 6,
	0x00, 0x11, 0x00, 8, // destination address
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x12, 0x00, 8, // source address 2
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0x13, 0x00, 7, // data
	'a', 'b', 'c', 'd', 'e', 'f', 'g'
	};

	static const unsigned char INPUT_STUN_UNKNOWN_ATTR[] = {
	0x00, 0x01, 0x00, 0x1F, // message header
	0x21, 0x12, 0xA4, 0x42, // magic cookie
	'0', '1', '2', '3', // transaction id
	'4', '5', '6', '7',
	'8', '9', 'a', 'b',
	0x00, 0x01, 0x00, 8, // mapped address
	0x00, 0x01, 0x00, 13,
	0x00, 0x00, 0x00, 17,
	0x00, 0xaa, 0x00, 7, // unknown attribute
	'a', 'b', 'c', 'd', 'e', 'f', 'g',
	0x00, 0x0d, 0x00, 4, // lifetime
	0x00, 0x00, 0x00, 11,
	};

	static const unsigned char INPUT_STUN_XOR_MAPPED_ADDRESS[] = {
	0x00, 0x01, 0x00, 0x0c, // message header
	0x21, 0x12, 0xA4, 0x42, // magic cookie
	'0', '1', '2', '3', // transaction id
	'4', '5', '6', '7',
	'8', '9', 'a', 'b',
	0x00, 0x20, 0x00, 0x08, // xor mapped address
	0x00, 0x01, 0x21, 0x1F,
	0x21, 0x12, 0xA4, 0x53,
	};

	static void DoTest(const char* input, size_t size, const char* transaction_id) {
	StunMessage msg, msg2;

	talk_base::ByteBuffer buf(input, size);
	EXPECT_TRUE(msg.Read(&buf));

	EXPECT_EQ(STUN_BINDING_REQUEST, msg.type());
	EXPECT_EQ(size - 20, msg.length());
	EXPECT_EQ(transaction_id, msg.transaction_id());

	msg2.SetType(STUN_BINDING_REQUEST);
	msg2.SetTransactionID(transaction_id);

	const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

	StunAddressAttribute* addr2 =
	StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
	addr2->SetPort(13);
	addr2->SetIP(talk_base::IPAddress(17U));
	msg2.AddAttribute(addr2);

	const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
	EXPECT_TRUE(bytes != NULL);
	EXPECT_EQ(12, bytes->length());
	EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefghijkl", bytes->length()));

	StunByteStringAttribute* bytes2 =
	StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
	bytes2->CopyBytes("abcdefghijkl");
	msg2.AddAttribute(bytes2);

	bytes = msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
	EXPECT_TRUE(bytes != NULL);
	EXPECT_EQ(20, bytes->length());
	EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefghijklmnopqrst", bytes->length()));

	bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MESSAGE_INTEGRITY);
	bytes2->CopyBytes("abcdefghijklmnopqrst");
	msg2.AddAttribute(bytes2);

	const StunErrorCodeAttribute* ecode = msg.GetErrorCode();
	EXPECT_TRUE(ecode != NULL);
	EXPECT_EQ(2, ecode->error_class());
	EXPECT_EQ(10, ecode->number());
	EXPECT_EQ("foo bar!", ecode->reason());

	StunErrorCodeAttribute* ecode2 = StunAttribute::CreateErrorCode();
	ecode2->SetErrorClass(2);
	ecode2->SetNumber(10);
	ecode2->SetReason("foo bar!");
	msg2.AddAttribute(ecode2);

	const StunUInt16ListAttribute* unknown = msg.GetUnknownAttributes();
	EXPECT_TRUE(unknown != NULL);
	EXPECT_EQ(2U, unknown->Size());
	EXPECT_EQ(1U, unknown->GetType(0));
	EXPECT_EQ(2U, unknown->GetType(1));

	StunUInt16ListAttribute* unknown2 = StunAttribute::CreateUnknownAttributes();
	unknown2->AddType(1);
	unknown2->AddType(2);
	msg2.AddAttribute(unknown2);

	const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
	EXPECT_TRUE(uval != NULL);
	EXPECT_EQ(11U, uval->value());

	StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
	uval2->SetValue(11);
	msg2.AddAttribute(uval2);

	bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
	EXPECT_TRUE(bytes != NULL);
	EXPECT_EQ(4, bytes->length());
	EXPECT_EQ(0, memcmp(bytes->bytes(), TURN_MAGIC_COOKIE_VALUE,
	sizeof(TURN_MAGIC_COOKIE_VALUE)));

	bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
	bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
	sizeof(TURN_MAGIC_COOKIE_VALUE));
	msg2.AddAttribute(bytes2);

	uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
	EXPECT_TRUE(uval != NULL);
	EXPECT_EQ(6U, uval->value());

	uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
	uval2->SetValue(6);
	msg2.AddAttribute(uval2);

	addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

	addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
	addr2->SetPort(13);
	addr2->SetIP(talk_base::IPAddress(17U));
	msg2.AddAttribute(addr2);

	addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

	addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
	addr2->SetPort(13);
	addr2->SetIP(talk_base::IPAddress(17U));
	msg2.AddAttribute(addr2);

	bytes = msg.GetByteString(STUN_ATTR_DATA);
	EXPECT_TRUE(bytes != NULL);
	EXPECT_EQ(7, bytes->length());
	EXPECT_EQ(0, memcmp(bytes->bytes(), "abcdefg", bytes->length()));

	bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
	bytes2->CopyBytes("abcdefg");
	msg2.AddAttribute(bytes2);

	talk_base::ByteBuffer out;
	msg.Write(&out);
	EXPECT_EQ(size, out.Length());
	EXPECT_EQ(0, memcmp(out.Data(), input, out.Length()));

	talk_base::ByteBuffer out2;
	msg2.Write(&out2);
	EXPECT_EQ(size, out2.Length());
	EXPECT_EQ(0, memcmp(out2.Data(), input, out2.Length()));
	}

	TEST(StunTest, TestStunPacket) {
	DoTest(reinterpret_cast<const char*>(INPUT_STUN), sizeof(INPUT_STUN),
	"0123456789ab");
	}

	TEST(StunTest, TestRejectsRtcpPacket) {
	StunMessage msg;

	talk_base::ByteBuffer buf(
	reinterpret_cast<const char*>(INPUT_RTCP), sizeof(INPUT_RTCP));
	EXPECT_FALSE(msg.Read(&buf));
	}

	TEST(StunTest, TestLegacyPacket) {
	DoTest(reinterpret_cast<const char*>(INPUT_LEGACY),
	sizeof(INPUT_LEGACY), "0123456789abcdef");
	}

	TEST(StunTest, TestIgnoreUnknownAttr) {
	StunMessage msg;
	talk_base::ByteBuffer buf(
	reinterpret_cast<const char*>(INPUT_STUN_UNKNOWN_ATTR),
	sizeof(INPUT_STUN_UNKNOWN_ATTR));
	EXPECT_TRUE(msg.Read(&buf));

	const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

	const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
	EXPECT_TRUE(uval != NULL);
	EXPECT_EQ(11U, uval->value());
	}

	TEST(StunTest, TestXorMappedAddress) {
	StunMessage msg;
	talk_base::ByteBuffer buf(
	reinterpret_cast<const char*>(INPUT_STUN_XOR_MAPPED_ADDRESS),
	sizeof(INPUT_STUN_XOR_MAPPED_ADDRESS));
	EXPECT_TRUE(msg.Read(&buf));

	const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());

	addr = msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
	EXPECT_TRUE(addr != NULL);
	EXPECT_EQ(1, addr->family());
	EXPECT_EQ(13, addr->port());
	EXPECT_EQ(talk_base::IPAddress(17U), addr->ipaddr());
	}