Don't crash if STUN error message is missing ERROR-CODE attribute.

webrtc/p2p/base/turnport.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 1147 matching lines @@
     return;
   }
   // Notify the port the allocate succeeded, and schedule a refresh request.
   port_->OnAllocateSuccess(relayed_attr->GetAddress(),
                            mapped_attr->GetAddress());
   port_->ScheduleRefresh(lifetime_attr->value());
 }
 
 void TurnAllocateRequest::OnErrorResponse(StunMessage* response) {
   // Process error response according to RFC5766, Section 6.4.
-  const StunErrorCodeAttribute* error_code = response->GetErrorCode();
+  int error_code = response->GetErrorCodeValue();
 
   LOG_J(LS_INFO, port_) << "Received TURN allocate error response"
                         << ", id=" << rtc::hex_encode(id())
-                        << ", code=" << error_code->code()
-                        << ", rtt=" << Elapsed();
+                        << ", code=" << error_code << ", rtt=" << Elapsed();
 
-  switch (error_code->code()) {
+  switch (error_code) {
     case STUN_ERROR_UNAUTHORIZED:       // Unauthrorized.
-      OnAuthChallenge(response, error_code->code());
+      OnAuthChallenge(response, error_code);
       break;
     case STUN_ERROR_TRY_ALTERNATE:
-      OnTryAlternate(response, error_code->code());
+      OnTryAlternate(response, error_code);
       break;
     case STUN_ERROR_ALLOCATION_MISMATCH:
       // We must handle this error async because trying to delete the socket in
       // OnErrorResponse will cause a deadlock on the socket.
       port_->thread()->Post(RTC_FROM_HERE, port_,
                             TurnPort::MSG_ALLOCATE_MISMATCH);
       break;
     default:
-      LOG_J(LS_WARNING, port_) << "Received TURN allocate error response"
-                               << ", id=" << rtc::hex_encode(id())
-                               << ", code=" << error_code->code()
-                               << ", rtt=" << Elapsed();
+      LOG_J(LS_WARNING, port_)
+          << "Received TURN allocate error response"
+          << ", id=" << rtc::hex_encode(id()) << ", code=" << error_code
+          << ", rtt=" << Elapsed();
       port_->OnAllocateError();
   }
 }
 
 void TurnAllocateRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN allocate request "
                            << rtc::hex_encode(id()) << " timeout";
   port_->OnAllocateRequestTimeout();
 }
 
@@ skipping 111 matching lines @@
                              << "refresh success response.";
     return;
   }
 
   // Schedule a refresh based on the returned lifetime value.
   port_->ScheduleRefresh(lifetime_attr->value());
   port_->SignalTurnRefreshResult(port_, TURN_SUCCESS_RESULT_CODE);
 }
 
 void TurnRefreshRequest::OnErrorResponse(StunMessage* response) {
-  const StunErrorCodeAttribute* error_code = response->GetErrorCode();
+  int error_code = response->GetErrorCodeValue();
 
-  if (error_code->code() == STUN_ERROR_STALE_NONCE) {
+  if (error_code == STUN_ERROR_STALE_NONCE) {
     if (port_->UpdateNonce(response)) {
       // Send RefreshRequest immediately.
       port_->SendRequest(new TurnRefreshRequest(port_), 0);
     }
   } else {
-    LOG_J(LS_WARNING, port_) << "Received TURN refresh error response"
-                             << ", id=" << rtc::hex_encode(id())
-                             << ", code=" << error_code->code()
-                             << ", rtt=" << Elapsed();
+    LOG_J(LS_WARNING, port_)
+        << "Received TURN refresh error response"
+        << ", id=" << rtc::hex_encode(id()) << ", code=" << error_code
+        << ", rtt=" << Elapsed();
     port_->OnRefreshError();
-    port_->SignalTurnRefreshResult(port_, error_code->code());
+    port_->SignalTurnRefreshResult(port_, error_code);
   }
 }
 
 void TurnRefreshRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN refresh timeout " << rtc::hex_encode(id());
   port_->OnRefreshError();
 }
 
 TurnCreatePermissionRequest::TurnCreatePermissionRequest(
     TurnPort* port, TurnEntry* entry,
@@ skipping 25 matching lines @@
                         << ", id=" << rtc::hex_encode(id())
                         << ", code=0"  // Makes logging easier to parse.
                         << ", rtt=" << Elapsed();
 
   if (entry_) {
     entry_->OnCreatePermissionSuccess();
   }
 }
 
 void TurnCreatePermissionRequest::OnErrorResponse(StunMessage* response) {
-  const StunErrorCodeAttribute* error_code = response->GetErrorCode();
+  int error_code = response->GetErrorCodeValue();
   LOG_J(LS_WARNING, port_) << "Received TURN create permission error response"
                            << ", id=" << rtc::hex_encode(id())
-                           << ", code=" << error_code->code()
-                           << ", rtt=" << Elapsed();
+                           << ", code=" << error_code << ", rtt=" << Elapsed();
   if (entry_) {
-    entry_->OnCreatePermissionError(response, error_code->code());
+    entry_->OnCreatePermissionError(response, error_code);
   }
 }
 
 void TurnCreatePermissionRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN create permission timeout "
                            << rtc::hex_encode(id());
   if (entry_) {
     entry_->OnCreatePermissionTimeout();
   }
 }
@@ skipping 43 matching lines @@
     // threshold. The channel binding has a longer lifetime, but
     // this is the easiest way to keep both the channel and the
     // permission from expiring.
     int delay = TURN_PERMISSION_TIMEOUT - 60000;
     entry_->SendChannelBindRequest(delay);
     LOG_J(LS_INFO, port_) << "Scheduled channel bind in " << delay << "ms.";
   }
 }
 
 void TurnChannelBindRequest::OnErrorResponse(StunMessage* response) {
-  const StunErrorCodeAttribute* error_code = response->GetErrorCode();
+  int error_code = response->GetErrorCodeValue();
   LOG_J(LS_WARNING, port_) << "Received TURN channel bind error response"
                            << ", id=" << rtc::hex_encode(id())
-                           << ", code=" << error_code->code()
-                           << ", rtt=" << Elapsed();
+                           << ", code=" << error_code << ", rtt=" << Elapsed();
   if (entry_) {
-    entry_->OnChannelBindError(response, error_code->code());
+    entry_->OnChannelBindError(response, error_code);
   }
 }
 
 void TurnChannelBindRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN channel bind timeout "
                            << rtc::hex_encode(id());
   if (entry_) {
     entry_->OnChannelBindTimeout();
   }
 }
@@ skipping 111 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket