Using 64-bit timestamp in webrtc/p2p

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 17 matching lines @@
 //static const int IPPROTO_UDP = 17;
 static const int kNonceTimeout = 60 * 60 * 1000;              // 60 minutes
 static const int kDefaultAllocationTimeout = 10 * 60 * 1000;  // 10 minutes
 static const int kPermissionTimeout = 5 * 60 * 1000;          //  5 minutes
 static const int kChannelTimeout = 10 * 60 * 1000;            // 10 minutes
 
 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 kNonceSize = 48;
 
 static const size_t TURN_CHANNEL_HEADER_SIZE = 4U;
 
 // TODO(mallinath) - Move these to a common place.
 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.
@@ skipping 336 matching lines @@
   // If the actual socket allocation fails, send an internal error.
   TurnServerAllocation* alloc = CreateAllocation(conn, proto, key);
   if (alloc) {
     alloc->HandleTurnMessage(msg);
   } else {
     SendErrorResponse(conn, msg, STUN_ERROR_SERVER_ERROR,
                       "Failed to allocate socket");
   }
 }
 
-std::string TurnServer::GenerateNonce(uint32_t now) const {
+std::string TurnServer::GenerateNonce(int64_t now) const {
   // Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
   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_t then;
+  int64_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)))) {
     return false;
   }
 
   // Validate the timestamp.
-  return rtc::TimeSince(then) < kNonceTimeout;
+  return rtc::Time64() - then < kNonceTimeout;
 }
 
 TurnServerAllocation* TurnServer::FindAllocation(TurnServerConnection* conn) {
   AllocationMap::const_iterator it = allocations_.find(*conn);
   return (it != allocations_.end()) ? it->second : NULL;
 }
 
 TurnServerAllocation* TurnServer::CreateAllocation(TurnServerConnection* conn,
                                                    int proto,
                                                    const std::string& key) {
@@ skipping 20 matching lines @@
                << ", code=" << code << ", reason=" << reason;
   SendStun(conn, &resp);
 }
 
 void TurnServer::SendErrorResponseWithRealmAndNonce(
     TurnServerConnection* conn, const StunMessage* msg,
     int code, const std::string& reason) {
   TurnMessage resp;
   InitErrorResponse(msg, code, reason, &resp);
 
-  uint32_t timestamp = rtc::Time();
+  int64_t timestamp = rtc::Time64();
   if (ts_for_next_nonce_) {
     timestamp = ts_for_next_nonce_;
     ts_for_next_nonce_ = 0;
   }
   VERIFY(resp.AddAttribute(
       new StunByteStringAttribute(STUN_ATTR_NONCE, GenerateNonce(timestamp))));
   VERIFY(resp.AddAttribute(new StunByteStringAttribute(
       STUN_ATTR_REALM, realm_)));
   SendStun(conn, &resp);
 }
@@ skipping 332 matching lines @@
         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_t lifetime = kDefaultAllocationTimeout / 1000;  // convert to seconds
+  int 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();
+  if (lifetime_attr && static_cast<int>(lifetime_attr->value()) < lifetime) {
+    lifetime = static_cast<int>(lifetime_attr->value());
   }
   return lifetime;
 }
 
 bool TurnServerAllocation::HasPermission(const rtc::IPAddress& addr) {
   return (FindPermission(addr) != NULL);
 }
 
 void TurnServerAllocation::AddPermission(const rtc::IPAddress& addr) {
   Permission* perm = FindPermission(addr);
@@ skipping 113 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