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

webrtc/p2p/base/turnserver.cc

 /*
  *  Copyright 2012 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 22 matching lines @@
 
 static const int kMinChannelNumber = 0x4000;
 static const int kMaxChannelNumber = 0x7FFF;
 
 static const size_t kNonceKeySize = 16;
 static const size_t kNonceSize = 40;
 
 static const size_t TURN_CHANNEL_HEADER_SIZE = 4U;
 
 // TODO(mallinath) - Move these to a common place.
-inline bool IsTurnChannelData(uint16 msg_type) {
+inline bool IsTurnChannelData(uint16_t msg_type) {
   // The first two bits of a channel data message are 0b01.
   return ((msg_type & 0xC000) == 0x4000);
 }
 
 // IDs used for posted messages for TurnServerAllocation.
 enum {
   MSG_ALLOCATION_TIMEOUT,
 };
 
 // Encapsulates a TURN permission.
@@ skipping 139 matching lines @@
                                   const char* data, size_t size,
                                   const rtc::SocketAddress& addr,
                                   const rtc::PacketTime& packet_time) {
   // Fail if the packet is too small to even contain a channel header.
   if (size < TURN_CHANNEL_HEADER_SIZE) {
    return;
   }
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   ASSERT(iter != server_sockets_.end());
   TurnServerConnection conn(addr, iter->second, socket);
-  uint16 msg_type = rtc::GetBE16(data);
+  uint16_t msg_type = rtc::GetBE16(data);
   if (!IsTurnChannelData(msg_type)) {
     // This is a STUN message.
     HandleStunMessage(&conn, data, size);
   } else {
     // This is a channel message; let the allocation handle it.
     TurnServerAllocation* allocation = FindAllocation(&conn);
     if (allocation) {
       allocation->HandleChannelData(data, size);
     }
   }
@@ skipping 173 matching lines @@
   if (alloc) {
     alloc->HandleTurnMessage(msg);
   } else {
     SendErrorResponse(conn, msg, STUN_ERROR_SERVER_ERROR,
                       "Failed to allocate socket");
   }
 }
 
 std::string TurnServer::GenerateNonce() const {
   // Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
-  uint32 now = rtc::Time();
+  uint32_t now = rtc::Time();
   std::string input(reinterpret_cast<const char*>(&now), sizeof(now));
   std::string nonce = rtc::hex_encode(input.c_str(), input.size());
   nonce += rtc::ComputeHmac(rtc::DIGEST_MD5, nonce_key_, input);
   ASSERT(nonce.size() == kNonceSize);
   return nonce;
 }
 
 bool TurnServer::ValidateNonce(const std::string& nonce) const {
   // Check the size.
   if (nonce.size() != kNonceSize) {
     return false;
   }
 
   // Decode the timestamp.
-  uint32 then;
+  uint32_t then;
   char* p = reinterpret_cast<char*>(&then);
   size_t len = rtc::hex_decode(p, sizeof(then),
       nonce.substr(0, sizeof(then) * 2));
   if (len != sizeof(then)) {
     return false;
   }
 
   // Verify the HMAC.
   if (nonce.substr(sizeof(then) * 2) != rtc::ComputeHmac(
       rtc::DIGEST_MD5, nonce_key_, std::string(p, sizeof(then)))) {
@@ skipping 331 matching lines @@
                        << ", peer=" << peer_attr->GetAddress();
 
   // Send a success response.
   TurnMessage response;
   InitResponse(msg, &response);
   SendResponse(&response);
 }
 
 void TurnServerAllocation::HandleChannelData(const char* data, size_t size) {
   // Extract the channel number from the data.
-  uint16 channel_id = rtc::GetBE16(data);
+  uint16_t channel_id = rtc::GetBE16(data);
   Channel* channel = FindChannel(channel_id);
   if (channel) {
     // Send the data to the peer address.
     SendExternal(data + TURN_CHANNEL_HEADER_SIZE,
                  size - TURN_CHANNEL_HEADER_SIZE, channel->peer());
   } else {
     LOG_J(LS_WARNING, this) << "Received channel data for invalid channel, id="
                             << channel_id;
   }
 }
 
 void TurnServerAllocation::OnExternalPacket(
     rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
     const rtc::SocketAddress& addr,
     const rtc::PacketTime& packet_time) {
   ASSERT(external_socket_.get() == socket);
   Channel* channel = FindChannel(addr);
   if (channel) {
     // There is a channel bound to this address. Send as a channel message.
     rtc::ByteBuffer buf;
     buf.WriteUInt16(channel->id());
-    buf.WriteUInt16(static_cast<uint16>(size));
+    buf.WriteUInt16(static_cast<uint16_t>(size));
     buf.WriteBytes(data, size);
     server_->Send(&conn_, buf);
   } else if (HasPermission(addr.ipaddr())) {
     // No channel, but a permission exists. Send as a data indication.
     TurnMessage msg;
     msg.SetType(TURN_DATA_INDICATION);
     msg.SetTransactionID(
         rtc::CreateRandomString(kStunTransactionIdLength));
     VERIFY(msg.AddAttribute(new StunXorAddressAttribute(
         STUN_ATTR_XOR_PEER_ADDRESS, addr)));
     VERIFY(msg.AddAttribute(new StunByteStringAttribute(
         STUN_ATTR_DATA, data, size)));
     server_->SendStun(&conn_, &msg);
   } else {
     LOG_J(LS_WARNING, this) << "Received external packet without permission, "
                             << "peer=" << addr;
   }
 }
 
 int TurnServerAllocation::ComputeLifetime(const TurnMessage* msg) {
   // Return the smaller of our default lifetime and the requested lifetime.
-  uint32 lifetime = kDefaultAllocationTimeout / 1000;  // convert to seconds
+  uint32_t lifetime = kDefaultAllocationTimeout / 1000;  // convert to seconds
   const StunUInt32Attribute* lifetime_attr = msg->GetUInt32(STUN_ATTR_LIFETIME);
   if (lifetime_attr && lifetime_attr->value() < lifetime) {
     lifetime = lifetime_attr->value();
   }
   return lifetime;
 }
 
 bool TurnServerAllocation::HasPermission(const rtc::IPAddress& addr) {
   return (FindPermission(addr) != NULL);
 }
@@ skipping 116 matching lines @@
   thread_->PostDelayed(kChannelTimeout, this, MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket