Home | History | Annotate | Download | only in base 
      1 /*
      2  * libjingle
      3  * Copyright 2004--2005, Google Inc.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are met:
      7  *
      8  *  1. Redistributions of source code must retain the above copyright notice,
      9  *     this list of conditions and the following disclaimer.
     10  *  2. Redistributions in binary form must reproduce the above copyright notice,
     11  *     this list of conditions and the following disclaimer in the documentation
     12  *     and/or other materials provided with the distribution.
     13  *  3. The name of the author may not be used to endorse or promote products
     14  *     derived from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #ifndef TALK_P2P_BASE_STUN_H_
     29 #define TALK_P2P_BASE_STUN_H_
     30 
     31 // This file contains classes for dealing with the STUN protocol, as specified
     32 // in RFC 5389, and its descendants.
     33 
     34 #include <string>
     35 #include <vector>
     36 
     37 #include "webrtc/base/basictypes.h"
     38 #include "webrtc/base/bytebuffer.h"
     39 #include "webrtc/base/socketaddress.h"
     40 
     41 namespace cricket {
     42 
     43 // These are the types of STUN messages defined in RFC 5389.
     44 enum StunMessageType {
     45   STUN_BINDING_REQUEST                  = 0x0001,
     46   STUN_BINDING_INDICATION               = 0x0011,
     47   STUN_BINDING_RESPONSE                 = 0x0101,
     48   STUN_BINDING_ERROR_RESPONSE           = 0x0111,
     49 };
     50 
     51 // These are all known STUN attributes, defined in RFC 5389 and elsewhere.
     52 // Next to each is the name of the class (T is StunTAttribute) that implements
     53 // that type.
     54 // RETRANSMIT_COUNT is the number of outstanding pings without a response at
     55 // the time the packet is generated.
     56 enum StunAttributeType {
     57   STUN_ATTR_MAPPED_ADDRESS              = 0x0001,  // Address
     58   STUN_ATTR_USERNAME                    = 0x0006,  // ByteString
     59   STUN_ATTR_MESSAGE_INTEGRITY           = 0x0008,  // ByteString, 20 bytes
     60   STUN_ATTR_ERROR_CODE                  = 0x0009,  // ErrorCode
     61   STUN_ATTR_UNKNOWN_ATTRIBUTES          = 0x000a,  // UInt16List
     62   STUN_ATTR_REALM                       = 0x0014,  // ByteString
     63   STUN_ATTR_NONCE                       = 0x0015,  // ByteString
     64   STUN_ATTR_XOR_MAPPED_ADDRESS          = 0x0020,  // XorAddress
     65   STUN_ATTR_SOFTWARE                    = 0x8022,  // ByteString
     66   STUN_ATTR_ALTERNATE_SERVER            = 0x8023,  // Address
     67   STUN_ATTR_FINGERPRINT                 = 0x8028,  // UInt32
     68   STUN_ATTR_RETRANSMIT_COUNT            = 0xFF00   // UInt32
     69 };
     70 
     71 // These are the types of the values associated with the attributes above.
     72 // This allows us to perform some basic validation when reading or adding
     73 // attributes. Note that these values are for our own use, and not defined in
     74 // RFC 5389.
     75 enum StunAttributeValueType {
     76   STUN_VALUE_UNKNOWN                    = 0,
     77   STUN_VALUE_ADDRESS                    = 1,
     78   STUN_VALUE_XOR_ADDRESS                = 2,
     79   STUN_VALUE_UINT32                     = 3,
     80   STUN_VALUE_UINT64                     = 4,
     81   STUN_VALUE_BYTE_STRING                = 5,
     82   STUN_VALUE_ERROR_CODE                 = 6,
     83   STUN_VALUE_UINT16_LIST                = 7
     84 };
     85 
     86 // These are the types of STUN addresses defined in RFC 5389.
     87 enum StunAddressFamily {
     88   // NB: UNDEF is not part of the STUN spec.
     89   STUN_ADDRESS_UNDEF                    = 0,
     90   STUN_ADDRESS_IPV4                     = 1,
     91   STUN_ADDRESS_IPV6                     = 2
     92 };
     93 
     94 // These are the types of STUN error codes defined in RFC 5389.
     95 enum StunErrorCode {
     96   STUN_ERROR_TRY_ALTERNATE              = 300,
     97   STUN_ERROR_BAD_REQUEST                = 400,
     98   STUN_ERROR_UNAUTHORIZED               = 401,
     99   STUN_ERROR_UNKNOWN_ATTRIBUTE          = 420,
    100   STUN_ERROR_STALE_CREDENTIALS          = 430,  // GICE only
    101   STUN_ERROR_STALE_NONCE                = 438,
    102   STUN_ERROR_SERVER_ERROR               = 500,
    103   STUN_ERROR_GLOBAL_FAILURE             = 600
    104 };
    105 
    106 // Strings for the error codes above.
    107 extern const char STUN_ERROR_REASON_TRY_ALTERNATE_SERVER[];
    108 extern const char STUN_ERROR_REASON_BAD_REQUEST[];
    109 extern const char STUN_ERROR_REASON_UNAUTHORIZED[];
    110 extern const char STUN_ERROR_REASON_UNKNOWN_ATTRIBUTE[];
    111 extern const char STUN_ERROR_REASON_STALE_CREDENTIALS[];
    112 extern const char STUN_ERROR_REASON_STALE_NONCE[];
    113 extern const char STUN_ERROR_REASON_SERVER_ERROR[];
    114 
    115 // The mask used to determine whether a STUN message is a request/response etc.
    116 const uint32 kStunTypeMask = 0x0110;
    117 
    118 // STUN Attribute header length.
    119 const size_t kStunAttributeHeaderSize = 4;
    120 
    121 // Following values correspond to RFC5389.
    122 const size_t kStunHeaderSize = 20;
    123 const size_t kStunTransactionIdOffset = 8;
    124 const size_t kStunTransactionIdLength = 12;
    125 const uint32 kStunMagicCookie = 0x2112A442;
    126 const size_t kStunMagicCookieLength = sizeof(kStunMagicCookie);
    127 
    128 // Following value corresponds to an earlier version of STUN from
    129 // RFC3489.
    130 const size_t kStunLegacyTransactionIdLength = 16;
    131 
    132 // STUN Message Integrity HMAC length.
    133 const size_t kStunMessageIntegritySize = 20;
    134 
    135 class StunAttribute;
    136 class StunAddressAttribute;
    137 class StunXorAddressAttribute;
    138 class StunUInt32Attribute;
    139 class StunUInt64Attribute;
    140 class StunByteStringAttribute;
    141 class StunErrorCodeAttribute;
    142 class StunUInt16ListAttribute;
    143 
    144 // Records a complete STUN/TURN message.  Each message consists of a type and
    145 // any number of attributes.  Each attribute is parsed into an instance of an
    146 // appropriate class (see above).  The Get* methods will return instances of
    147 // that attribute class.
    148 class StunMessage {
    149  public:
    150   StunMessage();
    151   virtual ~StunMessage();
    152 
    153   int type() const { return type_; }
    154   size_t length() const { return length_; }
    155   const std::string& transaction_id() const { return transaction_id_; }
    156 
    157   // Returns true if the message confirms to RFC3489 rather than
    158   // RFC5389. The main difference between two version of the STUN
    159   // protocol is the presence of the magic cookie and different length
    160   // of transaction ID. For outgoing packets version of the protocol
    161   // is determined by the lengths of the transaction ID.
    162   bool IsLegacy() const;
    163 
    164   void SetType(int type) { type_ = static_cast<uint16>(type); }
    165   bool SetTransactionID(const std::string& str);
    166 
    167   // Gets the desired attribute value, or NULL if no such attribute type exists.
    168   const StunAddressAttribute* GetAddress(int type) const;
    169   const StunUInt32Attribute* GetUInt32(int type) const;
    170   const StunUInt64Attribute* GetUInt64(int type) const;
    171   const StunByteStringAttribute* GetByteString(int type) const;
    172 
    173   // Gets these specific attribute values.
    174   const StunErrorCodeAttribute* GetErrorCode() const;
    175   const StunUInt16ListAttribute* GetUnknownAttributes() const;
    176 
    177   // Takes ownership of the specified attribute, verifies it is of the correct
    178   // type, and adds it to the message. The return value indicates whether this
    179   // was successful.
    180   bool AddAttribute(StunAttribute* attr);
    181 
    182   // Validates that a raw STUN message has a correct MESSAGE-INTEGRITY value.
    183   // This can't currently be done on a StunMessage, since it is affected by
    184   // padding data (which we discard when reading a StunMessage).
    185   static bool ValidateMessageIntegrity(const char* data, size_t size,
    186                                        const std::string& password);
    187   // Adds a MESSAGE-INTEGRITY attribute that is valid for the current message.
    188   bool AddMessageIntegrity(const std::string& password);
    189   bool AddMessageIntegrity(const char* key, size_t keylen);
    190 
    191   // Verifies that a given buffer is STUN by checking for a correct FINGERPRINT.
    192   static bool ValidateFingerprint(const char* data, size_t size);
    193 
    194   // Adds a FINGERPRINT attribute that is valid for the current message.
    195   bool AddFingerprint();
    196 
    197   // Parses the STUN packet in the given buffer and records it here. The
    198   // return value indicates whether this was successful.
    199   bool Read(rtc::ByteBuffer* buf);
    200 
    201   // Writes this object into a STUN packet. The return value indicates whether
    202   // this was successful.
    203   bool Write(rtc::ByteBuffer* buf) const;
    204 
    205   // Creates an empty message. Overridable by derived classes.
    206   virtual StunMessage* CreateNew() const { return new StunMessage(); }
    207 
    208  protected:
    209   // Verifies that the given attribute is allowed for this message.
    210   virtual StunAttributeValueType GetAttributeValueType(int type) const;
    211 
    212  private:
    213   StunAttribute* CreateAttribute(int type, size_t length) /* const*/;
    214   const StunAttribute* GetAttribute(int type) const;
    215   static bool IsValidTransactionId(const std::string& transaction_id);
    216 
    217   uint16 type_;
    218   uint16 length_;
    219   std::string transaction_id_;
    220   std::vector<StunAttribute*>* attrs_;
    221 };
    222 
    223 // Base class for all STUN/TURN attributes.
    224 class StunAttribute {
    225  public:
    226   virtual ~StunAttribute() {
    227   }
    228 
    229   int type() const { return type_; }
    230   size_t length() const { return length_; }
    231 
    232   // Return the type of this attribute.
    233   virtual StunAttributeValueType value_type() const = 0;
    234 
    235   // Only XorAddressAttribute needs this so far.
    236   virtual void SetOwner(StunMessage* owner) {}
    237 
    238   // Reads the body (not the type or length) for this type of attribute from
    239   // the given buffer.  Return value is true if successful.
    240   virtual bool Read(rtc::ByteBuffer* buf) = 0;
    241 
    242   // Writes the body (not the type or length) to the given buffer.  Return
    243   // value is true if successful.
    244   virtual bool Write(rtc::ByteBuffer* buf) const = 0;
    245 
    246   // Creates an attribute object with the given type and smallest length.
    247   static StunAttribute* Create(StunAttributeValueType value_type, uint16 type,
    248                                uint16 length, StunMessage* owner);
    249   // TODO: Allow these create functions to take parameters, to reduce
    250   // the amount of work callers need to do to initialize attributes.
    251   static StunAddressAttribute* CreateAddress(uint16 type);
    252   static StunXorAddressAttribute* CreateXorAddress(uint16 type);
    253   static StunUInt32Attribute* CreateUInt32(uint16 type);
    254   static StunUInt64Attribute* CreateUInt64(uint16 type);
    255   static StunByteStringAttribute* CreateByteString(uint16 type);
    256   static StunErrorCodeAttribute* CreateErrorCode();
    257   static StunUInt16ListAttribute* CreateUnknownAttributes();
    258 
    259  protected:
    260   StunAttribute(uint16 type, uint16 length);
    261   void SetLength(uint16 length) { length_ = length; }
    262   void WritePadding(rtc::ByteBuffer* buf) const;
    263   void ConsumePadding(rtc::ByteBuffer* buf) const;
    264 
    265  private:
    266   uint16 type_;
    267   uint16 length_;
    268 };
    269 
    270 // Implements STUN attributes that record an Internet address.
    271 class StunAddressAttribute : public StunAttribute {
    272  public:
    273   static const uint16 SIZE_UNDEF = 0;
    274   static const uint16 SIZE_IP4 = 8;
    275   static const uint16 SIZE_IP6 = 20;
    276   StunAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
    277   StunAddressAttribute(uint16 type, uint16 length);
    278 
    279   virtual StunAttributeValueType value_type() const {
    280     return STUN_VALUE_ADDRESS;
    281   }
    282 
    283   StunAddressFamily family() const {
    284     switch (address_.ipaddr().family()) {
    285       case AF_INET:
    286         return STUN_ADDRESS_IPV4;
    287       case AF_INET6:
    288         return STUN_ADDRESS_IPV6;
    289     }
    290     return STUN_ADDRESS_UNDEF;
    291   }
    292 
    293   const rtc::SocketAddress& GetAddress() const { return address_; }
    294   const rtc::IPAddress& ipaddr() const { return address_.ipaddr(); }
    295   uint16 port() const { return address_.port(); }
    296 
    297   void SetAddress(const rtc::SocketAddress& addr) {
    298     address_ = addr;
    299     EnsureAddressLength();
    300   }
    301   void SetIP(const rtc::IPAddress& ip) {
    302     address_.SetIP(ip);
    303     EnsureAddressLength();
    304   }
    305   void SetPort(uint16 port) { address_.SetPort(port); }
    306 
    307   virtual bool Read(rtc::ByteBuffer* buf);
    308   virtual bool Write(rtc::ByteBuffer* buf) const;
    309 
    310  private:
    311   void EnsureAddressLength() {
    312     switch (family()) {
    313       case STUN_ADDRESS_IPV4: {
    314         SetLength(SIZE_IP4);
    315         break;
    316       }
    317       case STUN_ADDRESS_IPV6: {
    318         SetLength(SIZE_IP6);
    319         break;
    320       }
    321       default: {
    322         SetLength(SIZE_UNDEF);
    323         break;
    324       }
    325     }
    326   }
    327   rtc::SocketAddress address_;
    328 };
    329 
    330 // Implements STUN attributes that record an Internet address. When encoded
    331 // in a STUN message, the address contained in this attribute is XORed with the
    332 // transaction ID of the message.
    333 class StunXorAddressAttribute : public StunAddressAttribute {
    334  public:
    335   StunXorAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
    336   StunXorAddressAttribute(uint16 type, uint16 length,
    337                           StunMessage* owner);
    338 
    339   virtual StunAttributeValueType value_type() const {
    340     return STUN_VALUE_XOR_ADDRESS;
    341   }
    342   virtual void SetOwner(StunMessage* owner) {
    343     owner_ = owner;
    344   }
    345   virtual bool Read(rtc::ByteBuffer* buf);
    346   virtual bool Write(rtc::ByteBuffer* buf) const;
    347 
    348  private:
    349   rtc::IPAddress GetXoredIP() const;
    350   StunMessage* owner_;
    351 };
    352 
    353 // Implements STUN attributes that record a 32-bit integer.
    354 class StunUInt32Attribute : public StunAttribute {
    355  public:
    356   static const uint16 SIZE = 4;
    357   StunUInt32Attribute(uint16 type, uint32 value);
    358   explicit StunUInt32Attribute(uint16 type);
    359 
    360   virtual StunAttributeValueType value_type() const {
    361     return STUN_VALUE_UINT32;
    362   }
    363 
    364   uint32 value() const { return bits_; }
    365   void SetValue(uint32 bits) { bits_ = bits; }
    366 
    367   bool GetBit(size_t index) const;
    368   void SetBit(size_t index, bool value);
    369 
    370   virtual bool Read(rtc::ByteBuffer* buf);
    371   virtual bool Write(rtc::ByteBuffer* buf) const;
    372 
    373  private:
    374   uint32 bits_;
    375 };
    376 
    377 class StunUInt64Attribute : public StunAttribute {
    378  public:
    379   static const uint16 SIZE = 8;
    380   StunUInt64Attribute(uint16 type, uint64 value);
    381   explicit StunUInt64Attribute(uint16 type);
    382 
    383   virtual StunAttributeValueType value_type() const {
    384     return STUN_VALUE_UINT64;
    385   }
    386 
    387   uint64 value() const { return bits_; }
    388   void SetValue(uint64 bits) { bits_ = bits; }
    389 
    390   virtual bool Read(rtc::ByteBuffer* buf);
    391   virtual bool Write(rtc::ByteBuffer* buf) const;
    392 
    393  private:
    394   uint64 bits_;
    395 };
    396 
    397 // Implements STUN attributes that record an arbitrary byte string.
    398 class StunByteStringAttribute : public StunAttribute {
    399  public:
    400   explicit StunByteStringAttribute(uint16 type);
    401   StunByteStringAttribute(uint16 type, const std::string& str);
    402   StunByteStringAttribute(uint16 type, const void* bytes, size_t length);
    403   StunByteStringAttribute(uint16 type, uint16 length);
    404   ~StunByteStringAttribute();
    405 
    406   virtual StunAttributeValueType value_type() const {
    407     return STUN_VALUE_BYTE_STRING;
    408   }
    409 
    410   const char* bytes() const { return bytes_; }
    411   std::string GetString() const { return std::string(bytes_, length()); }
    412 
    413   void CopyBytes(const char* bytes);  // uses strlen
    414   void CopyBytes(const void* bytes, size_t length);
    415 
    416   uint8 GetByte(size_t index) const;
    417   void SetByte(size_t index, uint8 value);
    418 
    419   virtual bool Read(rtc::ByteBuffer* buf);
    420   virtual bool Write(rtc::ByteBuffer* buf) const;
    421 
    422  private:
    423   void SetBytes(char* bytes, size_t length);
    424 
    425   char* bytes_;
    426 };
    427 
    428 // Implements STUN attributes that record an error code.
    429 class StunErrorCodeAttribute : public StunAttribute {
    430  public:
    431   static const uint16 MIN_SIZE = 4;
    432   StunErrorCodeAttribute(uint16 type, int code, const std::string& reason);
    433   StunErrorCodeAttribute(uint16 type, uint16 length);
    434   ~StunErrorCodeAttribute();
    435 
    436   virtual StunAttributeValueType value_type() const {
    437     return STUN_VALUE_ERROR_CODE;
    438   }
    439 
    440   // The combined error and class, e.g. 0x400.
    441   int code() const;
    442   void SetCode(int code);
    443 
    444   // The individual error components.
    445   int eclass() const { return class_; }
    446   int number() const { return number_; }
    447   const std::string& reason() const { return reason_; }
    448   void SetClass(uint8 eclass) { class_ = eclass; }
    449   void SetNumber(uint8 number) { number_ = number; }
    450   void SetReason(const std::string& reason);
    451 
    452   bool Read(rtc::ByteBuffer* buf);
    453   bool Write(rtc::ByteBuffer* buf) const;
    454 
    455  private:
    456   uint8 class_;
    457   uint8 number_;
    458   std::string reason_;
    459 };
    460 
    461 // Implements STUN attributes that record a list of attribute names.
    462 class StunUInt16ListAttribute : public StunAttribute {
    463  public:
    464   StunUInt16ListAttribute(uint16 type, uint16 length);
    465   ~StunUInt16ListAttribute();
    466 
    467   virtual StunAttributeValueType value_type() const {
    468     return STUN_VALUE_UINT16_LIST;
    469   }
    470 
    471   size_t Size() const;
    472   uint16 GetType(int index) const;
    473   void SetType(int index, uint16 value);
    474   void AddType(uint16 value);
    475 
    476   bool Read(rtc::ByteBuffer* buf);
    477   bool Write(rtc::ByteBuffer* buf) const;
    478 
    479  private:
    480   std::vector<uint16>* attr_types_;
    481 };
    482 
    483 // Returns the (successful) response type for the given request type.
    484 // Returns -1 if |request_type| is not a valid request type.
    485 int GetStunSuccessResponseType(int request_type);
    486 
    487 // Returns the error response type for the given request type.
    488 // Returns -1 if |request_type| is not a valid request type.
    489 int GetStunErrorResponseType(int request_type);
    490 
    491 // Returns whether a given message is a request type.
    492 bool IsStunRequestType(int msg_type);
    493 
    494 // Returns whether a given message is an indication type.
    495 bool IsStunIndicationType(int msg_type);
    496 
    497 // Returns whether a given response is a success type.
    498 bool IsStunSuccessResponseType(int msg_type);
    499 
    500 // Returns whether a given response is an error type.
    501 bool IsStunErrorResponseType(int msg_type);
    502 
    503 // Computes the STUN long-term credential hash.
    504 bool ComputeStunCredentialHash(const std::string& username,
    505     const std::string& realm, const std::string& password, std::string* hash);
    506 
    507 // TODO: Move the TURN/ICE stuff below out to separate files.
    508 extern const char TURN_MAGIC_COOKIE_VALUE[4];
    509 
    510 // "GTURN" STUN methods.
    511 // TODO: Rename these methods to GTURN_ to make it clear they aren't
    512 // part of standard STUN/TURN.
    513 enum RelayMessageType {
    514   // For now, using the same defs from TurnMessageType below.
    515   // STUN_ALLOCATE_REQUEST              = 0x0003,
    516   // STUN_ALLOCATE_RESPONSE             = 0x0103,
    517   // STUN_ALLOCATE_ERROR_RESPONSE       = 0x0113,
    518   STUN_SEND_REQUEST                     = 0x0004,
    519   STUN_SEND_RESPONSE                    = 0x0104,
    520   STUN_SEND_ERROR_RESPONSE              = 0x0114,
    521   STUN_DATA_INDICATION                  = 0x0115,
    522 };
    523 
    524 // "GTURN"-specific STUN attributes.
    525 // TODO: Rename these attributes to GTURN_ to avoid conflicts.
    526 enum RelayAttributeType {
    527   STUN_ATTR_LIFETIME                    = 0x000d,  // UInt32
    528   STUN_ATTR_MAGIC_COOKIE                = 0x000f,  // ByteString, 4 bytes
    529   STUN_ATTR_BANDWIDTH                   = 0x0010,  // UInt32
    530   STUN_ATTR_DESTINATION_ADDRESS         = 0x0011,  // Address
    531   STUN_ATTR_SOURCE_ADDRESS2             = 0x0012,  // Address
    532   STUN_ATTR_DATA                        = 0x0013,  // ByteString
    533   STUN_ATTR_OPTIONS                     = 0x8001,  // UInt32
    534 };
    535 
    536 // A "GTURN" STUN message.
    537 class RelayMessage : public StunMessage {
    538  protected:
    539   virtual StunAttributeValueType GetAttributeValueType(int type) const {
    540     switch (type) {
    541       case STUN_ATTR_LIFETIME:            return STUN_VALUE_UINT32;
    542       case STUN_ATTR_MAGIC_COOKIE:        return STUN_VALUE_BYTE_STRING;
    543       case STUN_ATTR_BANDWIDTH:           return STUN_VALUE_UINT32;
    544       case STUN_ATTR_DESTINATION_ADDRESS: return STUN_VALUE_ADDRESS;
    545       case STUN_ATTR_SOURCE_ADDRESS2:     return STUN_VALUE_ADDRESS;
    546       case STUN_ATTR_DATA:                return STUN_VALUE_BYTE_STRING;
    547       case STUN_ATTR_OPTIONS:             return STUN_VALUE_UINT32;
    548       default: return StunMessage::GetAttributeValueType(type);
    549     }
    550   }
    551   virtual StunMessage* CreateNew() const { return new RelayMessage(); }
    552 };
    553 
    554 // Defined in TURN RFC 5766.
    555 enum TurnMessageType {
    556   STUN_ALLOCATE_REQUEST                 = 0x0003,
    557   STUN_ALLOCATE_RESPONSE                = 0x0103,
    558   STUN_ALLOCATE_ERROR_RESPONSE          = 0x0113,
    559   TURN_REFRESH_REQUEST                  = 0x0004,
    560   TURN_REFRESH_RESPONSE                 = 0x0104,
    561   TURN_REFRESH_ERROR_RESPONSE           = 0x0114,
    562   TURN_SEND_INDICATION                  = 0x0016,
    563   TURN_DATA_INDICATION                  = 0x0017,
    564   TURN_CREATE_PERMISSION_REQUEST        = 0x0008,
    565   TURN_CREATE_PERMISSION_RESPONSE       = 0x0108,
    566   TURN_CREATE_PERMISSION_ERROR_RESPONSE = 0x0118,
    567   TURN_CHANNEL_BIND_REQUEST             = 0x0009,
    568   TURN_CHANNEL_BIND_RESPONSE            = 0x0109,
    569   TURN_CHANNEL_BIND_ERROR_RESPONSE      = 0x0119,
    570 };
    571 
    572 enum TurnAttributeType {
    573   STUN_ATTR_CHANNEL_NUMBER              = 0x000C,  // UInt32
    574   STUN_ATTR_TURN_LIFETIME               = 0x000d,  // UInt32
    575   STUN_ATTR_XOR_PEER_ADDRESS            = 0x0012,  // XorAddress
    576   // TODO(mallinath) - Uncomment after RelayAttributes are renamed.
    577   // STUN_ATTR_DATA                     = 0x0013,  // ByteString
    578   STUN_ATTR_XOR_RELAYED_ADDRESS         = 0x0016,  // XorAddress
    579   STUN_ATTR_EVEN_PORT                   = 0x0018,  // ByteString, 1 byte.
    580   STUN_ATTR_REQUESTED_TRANSPORT         = 0x0019,  // UInt32
    581   STUN_ATTR_DONT_FRAGMENT               = 0x001A,  // No content, Length = 0
    582   STUN_ATTR_RESERVATION_TOKEN           = 0x0022,  // ByteString, 8 bytes.
    583   // TODO(mallinath) - Rename STUN_ATTR_TURN_LIFETIME to STUN_ATTR_LIFETIME and
    584   // STUN_ATTR_TURN_DATA to STUN_ATTR_DATA. Also rename RelayMessage attributes
    585   // by appending G to attribute name.
    586 };
    587 
    588 // RFC 5766-defined errors.
    589 enum TurnErrorType {
    590   STUN_ERROR_FORBIDDEN                  = 403,
    591   STUN_ERROR_ALLOCATION_MISMATCH        = 437,
    592   STUN_ERROR_WRONG_CREDENTIALS          = 441,
    593   STUN_ERROR_UNSUPPORTED_PROTOCOL       = 442
    594 };
    595 extern const char STUN_ERROR_REASON_FORBIDDEN[];
    596 extern const char STUN_ERROR_REASON_ALLOCATION_MISMATCH[];
    597 extern const char STUN_ERROR_REASON_WRONG_CREDENTIALS[];
    598 extern const char STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL[];
    599 class TurnMessage : public StunMessage {
    600  protected:
    601   virtual StunAttributeValueType GetAttributeValueType(int type) const {
    602     switch (type) {
    603       case STUN_ATTR_CHANNEL_NUMBER:      return STUN_VALUE_UINT32;
    604       case STUN_ATTR_TURN_LIFETIME:       return STUN_VALUE_UINT32;
    605       case STUN_ATTR_XOR_PEER_ADDRESS:    return STUN_VALUE_XOR_ADDRESS;
    606       case STUN_ATTR_DATA:                return STUN_VALUE_BYTE_STRING;
    607       case STUN_ATTR_XOR_RELAYED_ADDRESS: return STUN_VALUE_XOR_ADDRESS;
    608       case STUN_ATTR_EVEN_PORT:           return STUN_VALUE_BYTE_STRING;
    609       case STUN_ATTR_REQUESTED_TRANSPORT: return STUN_VALUE_UINT32;
    610       case STUN_ATTR_DONT_FRAGMENT:       return STUN_VALUE_BYTE_STRING;
    611       case STUN_ATTR_RESERVATION_TOKEN:   return STUN_VALUE_BYTE_STRING;
    612       default: return StunMessage::GetAttributeValueType(type);
    613     }
    614   }
    615   virtual StunMessage* CreateNew() const { return new TurnMessage(); }
    616 };
    617 
    618 // RFC 5245 ICE STUN attributes.
    619 enum IceAttributeType {
    620   STUN_ATTR_PRIORITY                    = 0x0024,  // UInt32
    621   STUN_ATTR_USE_CANDIDATE               = 0x0025,  // No content, Length = 0
    622   STUN_ATTR_ICE_CONTROLLED              = 0x8029,  // UInt64
    623   STUN_ATTR_ICE_CONTROLLING             = 0x802A   // UInt64
    624 };
    625 
    626 // RFC 5245-defined errors.
    627 enum IceErrorCode {
    628   STUN_ERROR_ROLE_CONFLICT              = 487,
    629 };
    630 extern const char STUN_ERROR_REASON_ROLE_CONFLICT[];
    631 
    632 // A RFC 5245 ICE STUN message.
    633 class IceMessage : public StunMessage {
    634  protected:
    635   virtual StunAttributeValueType GetAttributeValueType(int type) const {
    636     switch (type) {
    637       case STUN_ATTR_PRIORITY:        return STUN_VALUE_UINT32;
    638       case STUN_ATTR_USE_CANDIDATE:   return STUN_VALUE_BYTE_STRING;
    639       case STUN_ATTR_ICE_CONTROLLED:  return STUN_VALUE_UINT64;
    640       case STUN_ATTR_ICE_CONTROLLING: return STUN_VALUE_UINT64;
    641       default: return StunMessage::GetAttributeValueType(type);
    642     }
    643   }
    644   virtual StunMessage* CreateNew() const { return new IceMessage(); }
    645 };
    646 
    647 }  // namespace cricket
    648 
    649 #endif  // TALK_P2P_BASE_STUN_H_
    650