Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/p2p/base/stun.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 79 matching lines @@
 // Strings for the error codes above.
 extern const char STUN_ERROR_REASON_TRY_ALTERNATE_SERVER[];
 extern const char STUN_ERROR_REASON_BAD_REQUEST[];
 extern const char STUN_ERROR_REASON_UNAUTHORIZED[];
 extern const char STUN_ERROR_REASON_UNKNOWN_ATTRIBUTE[];
 extern const char STUN_ERROR_REASON_STALE_CREDENTIALS[];
 extern const char STUN_ERROR_REASON_STALE_NONCE[];
 extern const char STUN_ERROR_REASON_SERVER_ERROR[];
 
 // The mask used to determine whether a STUN message is a request/response etc.
-const uint32 kStunTypeMask = 0x0110;
+const uint32_t kStunTypeMask = 0x0110;
 
 // STUN Attribute header length.
 const size_t kStunAttributeHeaderSize = 4;
 
 // Following values correspond to RFC5389.
 const size_t kStunHeaderSize = 20;
 const size_t kStunTransactionIdOffset = 8;
 const size_t kStunTransactionIdLength = 12;
-const uint32 kStunMagicCookie = 0x2112A442;
+const uint32_t kStunMagicCookie = 0x2112A442;
 const size_t kStunMagicCookieLength = sizeof(kStunMagicCookie);
 
 // Following value corresponds to an earlier version of STUN from
 // RFC3489.
 const size_t kStunLegacyTransactionIdLength = 16;
 
 // STUN Message Integrity HMAC length.
 const size_t kStunMessageIntegritySize = 20;
 
 class StunAttribute;
@@ skipping 18 matching lines @@
   size_t length() const { return length_; }
   const std::string& transaction_id() const { return transaction_id_; }
 
   // Returns true if the message confirms to RFC3489 rather than
   // RFC5389. The main difference between two version of the STUN
   // protocol is the presence of the magic cookie and different length
   // of transaction ID. For outgoing packets version of the protocol
   // is determined by the lengths of the transaction ID.
   bool IsLegacy() const;
 
-  void SetType(int type) { type_ = static_cast<uint16>(type); }
+  void SetType(int type) { type_ = static_cast<uint16_t>(type); }
   bool SetTransactionID(const std::string& str);
 
   // Gets the desired attribute value, or NULL if no such attribute type exists.
   const StunAddressAttribute* GetAddress(int type) const;
   const StunUInt32Attribute* GetUInt32(int type) const;
   const StunUInt64Attribute* GetUInt64(int type) const;
   const StunByteStringAttribute* GetByteString(int type) const;
 
   // Gets these specific attribute values.
   const StunErrorCodeAttribute* GetErrorCode() const;
@@ skipping 32 matching lines @@
 
  protected:
   // Verifies that the given attribute is allowed for this message.
   virtual StunAttributeValueType GetAttributeValueType(int type) const;
 
  private:
   StunAttribute* CreateAttribute(int type, size_t length) /* const*/;
   const StunAttribute* GetAttribute(int type) const;
   static bool IsValidTransactionId(const std::string& transaction_id);
 
-  uint16 type_;
-  uint16 length_;
+  uint16_t type_;
+  uint16_t length_;
   std::string transaction_id_;
   std::vector<StunAttribute*>* attrs_;
 };
 
 // Base class for all STUN/TURN attributes.
 class StunAttribute {
  public:
   virtual ~StunAttribute() {
   }
 
   int type() const { return type_; }
   size_t length() const { return length_; }
 
   // Return the type of this attribute.
   virtual StunAttributeValueType value_type() const = 0;
 
   // Only XorAddressAttribute needs this so far.
   virtual void SetOwner(StunMessage* owner) {}
 
   // Reads the body (not the type or length) for this type of attribute from
   // the given buffer.  Return value is true if successful.
   virtual bool Read(rtc::ByteBuffer* buf) = 0;
 
   // Writes the body (not the type or length) to the given buffer.  Return
   // value is true if successful.
   virtual bool Write(rtc::ByteBuffer* buf) const = 0;
 
   // Creates an attribute object with the given type and smallest length.
-  static StunAttribute* Create(StunAttributeValueType value_type, uint16 type,
-                               uint16 length, StunMessage* owner);
+  static StunAttribute* Create(StunAttributeValueType value_type,
+                               uint16_t type,
+                               uint16_t length,
+                               StunMessage* owner);
   // TODO: Allow these create functions to take parameters, to reduce
   // the amount of work callers need to do to initialize attributes.
-  static StunAddressAttribute* CreateAddress(uint16 type);
-  static StunXorAddressAttribute* CreateXorAddress(uint16 type);
-  static StunUInt32Attribute* CreateUInt32(uint16 type);
-  static StunUInt64Attribute* CreateUInt64(uint16 type);
-  static StunByteStringAttribute* CreateByteString(uint16 type);
+  static StunAddressAttribute* CreateAddress(uint16_t type);
+  static StunXorAddressAttribute* CreateXorAddress(uint16_t type);
+  static StunUInt32Attribute* CreateUInt32(uint16_t type);
+  static StunUInt64Attribute* CreateUInt64(uint16_t type);
+  static StunByteStringAttribute* CreateByteString(uint16_t type);
   static StunErrorCodeAttribute* CreateErrorCode();
   static StunUInt16ListAttribute* CreateUnknownAttributes();
 
  protected:
-  StunAttribute(uint16 type, uint16 length);
-  void SetLength(uint16 length) { length_ = length; }
+  StunAttribute(uint16_t type, uint16_t length);
+  void SetLength(uint16_t length) { length_ = length; }
   void WritePadding(rtc::ByteBuffer* buf) const;
   void ConsumePadding(rtc::ByteBuffer* buf) const;
 
  private:
-  uint16 type_;
-  uint16 length_;
+  uint16_t type_;
+  uint16_t length_;
 };
 
 // Implements STUN attributes that record an Internet address.
 class StunAddressAttribute : public StunAttribute {
  public:
-  static const uint16 SIZE_UNDEF = 0;
-  static const uint16 SIZE_IP4 = 8;
-  static const uint16 SIZE_IP6 = 20;
-  StunAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
-  StunAddressAttribute(uint16 type, uint16 length);
+  static const uint16_t SIZE_UNDEF = 0;
+  static const uint16_t SIZE_IP4 = 8;
+  static const uint16_t SIZE_IP6 = 20;
+  StunAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+  StunAddressAttribute(uint16_t type, uint16_t length);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_ADDRESS;
   }
 
   StunAddressFamily family() const {
     switch (address_.ipaddr().family()) {
       case AF_INET:
         return STUN_ADDRESS_IPV4;
       case AF_INET6:
         return STUN_ADDRESS_IPV6;
     }
     return STUN_ADDRESS_UNDEF;
   }
 
   const rtc::SocketAddress& GetAddress() const { return address_; }
   const rtc::IPAddress& ipaddr() const { return address_.ipaddr(); }
-  uint16 port() const { return address_.port(); }
+  uint16_t port() const { return address_.port(); }
 
   void SetAddress(const rtc::SocketAddress& addr) {
     address_ = addr;
     EnsureAddressLength();
   }
   void SetIP(const rtc::IPAddress& ip) {
     address_.SetIP(ip);
     EnsureAddressLength();
   }
-  void SetPort(uint16 port) { address_.SetPort(port); }
+  void SetPort(uint16_t port) { address_.SetPort(port); }
 
   virtual bool Read(rtc::ByteBuffer* buf);
   virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   void EnsureAddressLength() {
     switch (family()) {
       case STUN_ADDRESS_IPV4: {
         SetLength(SIZE_IP4);
         break;
       }
       case STUN_ADDRESS_IPV6: {
         SetLength(SIZE_IP6);
         break;
       }
       default: {
         SetLength(SIZE_UNDEF);
         break;
       }
     }
   }
   rtc::SocketAddress address_;
 };
 
 // Implements STUN attributes that record an Internet address. When encoded
 // in a STUN message, the address contained in this attribute is XORed with the
 // transaction ID of the message.
 class StunXorAddressAttribute : public StunAddressAttribute {
  public:
-  StunXorAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
-  StunXorAddressAttribute(uint16 type, uint16 length,
-                          StunMessage* owner);
+  StunXorAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+  StunXorAddressAttribute(uint16_t type, uint16_t length, StunMessage* owner);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_XOR_ADDRESS;
   }
   virtual void SetOwner(StunMessage* owner) {
     owner_ = owner;
   }
   virtual bool Read(rtc::ByteBuffer* buf);
   virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   rtc::IPAddress GetXoredIP() const;
   StunMessage* owner_;
 };
 
 // Implements STUN attributes that record a 32-bit integer.
 class StunUInt32Attribute : public StunAttribute {
  public:
-  static const uint16 SIZE = 4;
-  StunUInt32Attribute(uint16 type, uint32 value);
-  explicit StunUInt32Attribute(uint16 type);
+  static const uint16_t SIZE = 4;
+  StunUInt32Attribute(uint16_t type, uint32_t value);
+  explicit StunUInt32Attribute(uint16_t type);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT32;
   }
 
-  uint32 value() const { return bits_; }
-  void SetValue(uint32 bits) { bits_ = bits; }
+  uint32_t value() const { return bits_; }
+  void SetValue(uint32_t bits) { bits_ = bits; }
 
   bool GetBit(size_t index) const;
   void SetBit(size_t index, bool value);
 
   virtual bool Read(rtc::ByteBuffer* buf);
   virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
-  uint32 bits_;
+  uint32_t bits_;
 };
 
 class StunUInt64Attribute : public StunAttribute {
  public:
-  static const uint16 SIZE = 8;
-  StunUInt64Attribute(uint16 type, uint64 value);
-  explicit StunUInt64Attribute(uint16 type);
+  static const uint16_t SIZE = 8;
+  StunUInt64Attribute(uint16_t type, uint64_t value);
+  explicit StunUInt64Attribute(uint16_t type);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT64;
   }
 
-  uint64 value() const { return bits_; }
-  void SetValue(uint64 bits) { bits_ = bits; }
+  uint64_t value() const { return bits_; }
+  void SetValue(uint64_t bits) { bits_ = bits; }
 
   virtual bool Read(rtc::ByteBuffer* buf);
   virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
-  uint64 bits_;
+  uint64_t bits_;
 };
 
 // Implements STUN attributes that record an arbitrary byte string.
 class StunByteStringAttribute : public StunAttribute {
  public:
-  explicit StunByteStringAttribute(uint16 type);
-  StunByteStringAttribute(uint16 type, const std::string& str);
-  StunByteStringAttribute(uint16 type, const void* bytes, size_t length);
-  StunByteStringAttribute(uint16 type, uint16 length);
+  explicit StunByteStringAttribute(uint16_t type);
+  StunByteStringAttribute(uint16_t type, const std::string& str);
+  StunByteStringAttribute(uint16_t type, const void* bytes, size_t length);
+  StunByteStringAttribute(uint16_t type, uint16_t length);
   ~StunByteStringAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_BYTE_STRING;
   }
 
   const char* bytes() const { return bytes_; }
   std::string GetString() const { return std::string(bytes_, length()); }
 
   void CopyBytes(const char* bytes);  // uses strlen
   void CopyBytes(const void* bytes, size_t length);
 
-  uint8 GetByte(size_t index) const;
-  void SetByte(size_t index, uint8 value);
+  uint8_t GetByte(size_t index) const;
+  void SetByte(size_t index, uint8_t value);
 
   virtual bool Read(rtc::ByteBuffer* buf);
   virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   void SetBytes(char* bytes, size_t length);
 
   char* bytes_;
 };
 
 // Implements STUN attributes that record an error code.
 class StunErrorCodeAttribute : public StunAttribute {
  public:
-  static const uint16 MIN_SIZE = 4;
-  StunErrorCodeAttribute(uint16 type, int code, const std::string& reason);
-  StunErrorCodeAttribute(uint16 type, uint16 length);
+  static const uint16_t MIN_SIZE = 4;
+  StunErrorCodeAttribute(uint16_t type, int code, const std::string& reason);
+  StunErrorCodeAttribute(uint16_t type, uint16_t length);
   ~StunErrorCodeAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_ERROR_CODE;
   }
 
   // The combined error and class, e.g. 0x400.
   int code() const;
   void SetCode(int code);
 
   // The individual error components.
   int eclass() const { return class_; }
   int number() const { return number_; }
   const std::string& reason() const { return reason_; }
-  void SetClass(uint8 eclass) { class_ = eclass; }
-  void SetNumber(uint8 number) { number_ = number; }
+  void SetClass(uint8_t eclass) { class_ = eclass; }
+  void SetNumber(uint8_t number) { number_ = number; }
   void SetReason(const std::string& reason);
 
   bool Read(rtc::ByteBuffer* buf);
   bool Write(rtc::ByteBuffer* buf) const;
 
  private:
-  uint8 class_;
-  uint8 number_;
+  uint8_t class_;
+  uint8_t number_;
   std::string reason_;
 };
 
 // Implements STUN attributes that record a list of attribute names.
 class StunUInt16ListAttribute : public StunAttribute {
  public:
-  StunUInt16ListAttribute(uint16 type, uint16 length);
+  StunUInt16ListAttribute(uint16_t type, uint16_t length);
   ~StunUInt16ListAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT16_LIST;
   }
 
   size_t Size() const;
-  uint16 GetType(int index) const;
-  void SetType(int index, uint16 value);
-  void AddType(uint16 value);
+  uint16_t GetType(int index) const;
+  void SetType(int index, uint16_t value);
+  void AddType(uint16_t value);
 
   bool Read(rtc::ByteBuffer* buf);
   bool Write(rtc::ByteBuffer* buf) const;
 
  private:
-  std::vector<uint16>* attr_types_;
+  std::vector<uint16_t>* attr_types_;
 };
 
 // Returns the (successful) response type for the given request type.
 // Returns -1 if |request_type| is not a valid request type.
 int GetStunSuccessResponseType(int request_type);
 
 // Returns the error response type for the given request type.
 // Returns -1 if |request_type| is not a valid request type.
 int GetStunErrorResponseType(int request_type);
 
@@ skipping 149 matching lines @@
       case STUN_ATTR_ICE_CONTROLLING: return STUN_VALUE_UINT64;
       default: return StunMessage::GetAttributeValueType(type);
     }
   }
   virtual StunMessage* CreateNew() const { return new IceMessage(); }
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_STUN_H_