Fixing memory leak in TurnServer.

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.
  */
 
 #include "webrtc/p2p/base/turnserver.h"
 
+#include <tuple>  // for std::tie
+
 #include "webrtc/p2p/base/asyncstuntcpsocket.h"
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/packetsocketfactory.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/stringencode.h"
@@ skipping 94 matching lines @@
 
 TurnServer::TurnServer(rtc::Thread* thread)
     : thread_(thread),
       nonce_key_(rtc::CreateRandomString(kNonceKeySize)),
       auth_hook_(NULL),
       redirect_hook_(NULL),
       enable_otu_nonce_(false) {
 }
 
 TurnServer::~TurnServer() {
-  for (AllocationMap::iterator it = allocations_.begin();
-       it != allocations_.end(); ++it) {
-    delete it->second;
-  }
-
   for (InternalSocketMap::iterator it = server_sockets_.begin();
        it != server_sockets_.end(); ++it) {
     rtc::AsyncPacketSocket* socket = it->first;
     delete socket;
   }
 
   for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
        it != server_listen_sockets_.end(); ++it) {
     rtc::AsyncSocket* socket = it->first;
     delete socket;
@@ skipping 280 matching lines @@
       rtc::DIGEST_MD5, nonce_key_, std::string(p, sizeof(then)))) {
     return false;
   }
 
   // Validate the timestamp.
   return rtc::TimeMillis() - then < kNonceTimeout;
 }
 
 TurnServerAllocation* TurnServer::FindAllocation(TurnServerConnection* conn) {
   AllocationMap::const_iterator it = allocations_.find(*conn);
-  return (it != allocations_.end()) ? it->second : NULL;
+  return (it != allocations_.end()) ? it->second.get() : nullptr;
 }
 
 TurnServerAllocation* TurnServer::CreateAllocation(TurnServerConnection* conn,
                                                    int proto,
                                                    const std::string& key) {
   rtc::AsyncPacketSocket* external_socket = (external_socket_factory_) ?
       external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0) : NULL;
   if (!external_socket) {
     return NULL;
   }
 
   // The Allocation takes ownership of the socket.
   TurnServerAllocation* allocation = new TurnServerAllocation(this,
       thread_, *conn, external_socket, key);
   allocation->SignalDestroyed.connect(this, &TurnServer::OnAllocationDestroyed);
-  allocations_[*conn] = allocation;
+  allocations_[*conn].reset(allocation);
   return allocation;
 }
 
 void TurnServer::SendErrorResponse(TurnServerConnection* conn,
                                    const StunMessage* req,
                                    int code, const std::string& reason) {
   TurnMessage resp;
   InitErrorResponse(req, code, reason, &resp);
   LOG(LS_INFO) << "Sending error response, type=" << resp.type()
                << ", code=" << code << ", reason=" << reason;
@@ skipping 52 matching lines @@
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   // Skip if the socket serving this allocation is UDP, as this will be shared
   // by all allocations.
   // Note: We may not find a socket if it's a TCP socket that was closed, and
   // the allocation is only now timing out.
   if (iter != server_sockets_.end() && iter->second != cricket::PROTO_UDP) {
     DestroyInternalSocket(socket);
   }
 
   AllocationMap::iterator it = allocations_.find(*(allocation->conn()));
-  if (it != allocations_.end())
+  if (it != allocations_.end()) {
+    it->second.release();
     allocations_.erase(it);
+  }
 }
 
 void TurnServer::DestroyInternalSocket(rtc::AsyncPacketSocket* socket) {
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   if (iter != server_sockets_.end()) {
     rtc::AsyncPacketSocket* socket = iter->first;
     // We must destroy the socket async to avoid invalidating the sigslot
     // callback list iterator inside a sigslot callback.
     rtc::Thread::Current()->Dispose(socket);
     server_sockets_.erase(iter);
   }
 }
 
 TurnServerConnection::TurnServerConnection(const rtc::SocketAddress& src,
                                            ProtocolType proto,
                                            rtc::AsyncPacketSocket* socket)
     : src_(src),
       dst_(socket->GetRemoteAddress()),
       proto_(proto),
       socket_(socket) {
 }
 
 bool TurnServerConnection::operator==(const TurnServerConnection& c) const {
   return src_ == c.src_ && dst_ == c.dst_ && proto_ == c.proto_;
 }
 
 bool TurnServerConnection::operator<(const TurnServerConnection& c) const {
-  return src_ < c.src_ || dst_ < c.dst_ || proto_ < c.proto_;
+  return std::tie(src_, dst_, proto_) < std::tie(c.src_, c.dst_, c.proto_);
 }
 
 std::string TurnServerConnection::ToString() const {
   const char* const kProtos[] = {
       "unknown", "udp", "tcp", "ssltcp"
   };
   std::ostringstream ost;
   ost << src_.ToString() << "-" << dst_.ToString() << ":"<< kProtos[proto_];
   return ost.str();
 }
@@ skipping 393 matching lines @@
                        MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket