DNS: Don't spin on unexpected EOF reading TCP response

net/dns/dns_transaction.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/dns_transaction.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 321 matching lines @@
   virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
     return socket_->NetLog();
   }
 
  private:
   enum State {
     STATE_CONNECT_COMPLETE,
     STATE_SEND_LENGTH,
     STATE_SEND_QUERY,
     STATE_READ_LENGTH,
+    STATE_READ_LENGTH_COMPLETE,
     STATE_READ_RESPONSE,
+    STATE_READ_RESPONSE_COMPLETE,
     STATE_NONE,
   };
 
   int DoLoop(int result) {
     CHECK_NE(STATE_NONE, next_state_);
     int rv = result;
     do {
       State state = next_state_;
       next_state_ = STATE_NONE;
       switch (state) {
         case STATE_CONNECT_COMPLETE:
           rv = DoConnectComplete(rv);
           break;
         case STATE_SEND_LENGTH:
           rv = DoSendLength(rv);
           break;
         case STATE_SEND_QUERY:
           rv = DoSendQuery(rv);
           break;
         case STATE_READ_LENGTH:
           rv = DoReadLength(rv);
           break;
+        case STATE_READ_LENGTH_COMPLETE:
+          rv = DoReadLengthComplete(rv);
+          break;
         case STATE_READ_RESPONSE:
           rv = DoReadResponse(rv);
           break;
+        case STATE_READ_RESPONSE_COMPLETE:
+          rv = DoReadResponseComplete(rv);
+          break;
         default:
           NOTREACHED();
           break;
       }
     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
     set_result(rv);
     if (rv == OK) {
       DCHECK_EQ(STATE_NONE, next_state_);
       DNS_HISTOGRAM("AsyncDNS.TCPAttemptSuccess",
@@ skipping 50 matching lines @@
           buffer_->BytesRemaining(),
           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
     buffer_ =
         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
     next_state_ = STATE_READ_LENGTH;
     return OK;
   }
 
   int DoReadLength(int rv) {
+    DCHECK_EQ(OK, rv);
+
+    next_state_ = STATE_READ_LENGTH_COMPLETE;
+    return ReadIntoBuffer();
+  }
+
+  int DoReadLengthComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
+    if (rv == 0)
+      return ERR_CONNECTION_CLOSED;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_READ_LENGTH;
-      return socket_->Read(
-          buffer_.get(),
-          buffer_->BytesRemaining(),
-          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
+      return OK;
     }
+
     base::ReadBigEndian<uint16>(length_buffer_->data(), &response_length_);
     // Check if advertised response is too short. (Optimization only.)
     if (response_length_ < query_->io_buffer()->size())
       return ERR_DNS_MALFORMED_RESPONSE;
     // Allocate more space so that DnsResponse::InitParse sanity check passes.
     response_.reset(new DnsResponse(response_length_ + 1));
     buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
     next_state_ = STATE_READ_RESPONSE;
     return OK;
   }
 
   int DoReadResponse(int rv) {
+    DCHECK_EQ(OK, rv);
+
+    next_state_ = STATE_READ_RESPONSE_COMPLETE;
+    return ReadIntoBuffer();
+  }
+
+  int DoReadResponseComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
+    if (rv == 0)
+      return ERR_CONNECTION_CLOSED;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_READ_RESPONSE;
-      return socket_->Read(
-          buffer_.get(),
-          buffer_->BytesRemaining(),
-          base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
+      return OK;
     }
+
     if (!response_->InitParse(buffer_->BytesConsumed(), *query_))
       return ERR_DNS_MALFORMED_RESPONSE;
     if (response_->flags() & dns_protocol::kFlagTC)
       return ERR_UNEXPECTED;
     // TODO(szym): Frankly, none of these are expected.
     if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
       return ERR_NAME_NOT_RESOLVED;
     if (response_->rcode() != dns_protocol::kRcodeNOERROR)
       return ERR_DNS_SERVER_FAILED;
 
     return OK;
   }
 
   void OnIOComplete(int rv) {
     rv = DoLoop(rv);
     if (rv != ERR_IO_PENDING)
       callback_.Run(rv);
   }
 
+  int ReadIntoBuffer() {
+    return socket_->Read(
+        buffer_.get(),
+        buffer_->BytesRemaining(),
+        base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
+  }
+
   State next_state_;
   base::TimeTicks start_time_;
 
   scoped_ptr<StreamSocket> socket_;
   scoped_ptr<DnsQuery> query_;
   scoped_refptr<IOBufferWithSize> length_buffer_;
   scoped_refptr<DrainableIOBuffer> buffer_;
 
   uint16 response_length_;
   scoped_ptr<DnsResponse> response_;
@@ skipping 452 matching lines @@
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net