net/tools/flip_server/sm_connection.cc

   1 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/tools/flip_server/sm_connection.h"
   6
   7 #include <errno.h>
   8 #include <netinet/tcp.h>
   9 #include <sys/socket.h>
  10 #include <unistd.h>
  11
  12 #include <algorithm>
  13 #include <list>
  14 #include <string>
  15
  16 #include "net/tools/flip_server/constants.h"
  17 #include "net/tools/flip_server/flip_config.h"
  18 #include "net/tools/flip_server/http_interface.h"
  19 #include "net/tools/flip_server/spdy_interface.h"
  20 #include "net/tools/flip_server/spdy_ssl.h"
  21 #include "net/tools/flip_server/streamer_interface.h"
  22
  23 namespace net {
  24
  25 // static
  26 bool SMConnection::force_spdy_ = false;
  27
  28 DataFrame::~DataFrame() {
  29   if (delete_when_done)
  30     delete[] data;
  31 }
  32
  33 SMConnection::SMConnection(EpollServer* epoll_server,
  34                            SSLState* ssl_state,
  35                            MemoryCache* memory_cache,
  36                            FlipAcceptor* acceptor,
  37                            std::string log_prefix)
  38     : last_read_time_(0),
  39       fd_(-1),
  40       events_(0),
  41       registered_in_epoll_server_(false),
  42       initialized_(false),
  43       protocol_detected_(false),
  44       connection_complete_(false),
  45       connection_pool_(NULL),
  46       epoll_server_(epoll_server),
  47       ssl_state_(ssl_state),
  48       memory_cache_(memory_cache),
  49       acceptor_(acceptor),
  50       read_buffer_(kSpdySegmentSize * 40),
  51       sm_spdy_interface_(NULL),
  52       sm_http_interface_(NULL),
  53       sm_streamer_interface_(NULL),
  54       sm_interface_(NULL),
  55       log_prefix_(log_prefix),
  56       max_bytes_sent_per_dowrite_(4096),
  57       ssl_(NULL) {}
  58
  59 SMConnection::~SMConnection() {
  60   if (initialized())
  61     Reset();
  62 }
  63
  64 EpollServer* SMConnection::epoll_server() { return epoll_server_; }
  65
  66 void SMConnection::ReadyToSend() {
  67   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
  68           << "Setting ready to send: EPOLLIN | EPOLLOUT";
  69   epoll_server_->SetFDReady(fd_, EPOLLIN | EPOLLOUT);
  70 }
  71
  72 void SMConnection::EnqueueDataFrame(DataFrame* df) {
  73   output_list_.push_back(df);
  74   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "EnqueueDataFrame: "
  75           << "size = " << df->size << ": Setting FD ready.";
  76   ReadyToSend();
  77 }
  78
  79 void SMConnection::InitSMConnection(SMConnectionPoolInterface* connection_pool,
  80                                     SMInterface* sm_interface,
  81                                     EpollServer* epoll_server,
  82                                     int fd,
  83                                     std::string server_ip,
  84                                     std::string server_port,
  85                                     std::string remote_ip,
  86                                     bool use_ssl) {
  87   if (initialized_) {
  88     LOG(FATAL) << "Attempted to initialize already initialized server";
  89     return;
  90   }
  91
  92   client_ip_ = remote_ip;
  93
  94   if (fd == -1) {
  95     // If fd == -1, then we are initializing a new connection that will
  96     // connect to the backend.
  97     //
  98     // ret:  -1 == error
  99     //        0 == connection in progress
 100     //        1 == connection complete
 101     // TODO(kelindsay): is_numeric_host_address value needs to be detected
 102     server_ip_ = server_ip;
 103     server_port_ = server_port;
 104     int ret = CreateConnectedSocket(
 105         &fd_, server_ip, server_port, true, acceptor_->disable_nagle_);
 106
 107     if (ret < 0) {
 108       LOG(ERROR) << "-1 Could not create connected socket";
 109       return;
 110     } else if (ret == 1) {
 111       DCHECK_NE(-1, fd_);
 112       connection_complete_ = true;
 113       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 114               << "Connection complete to: " << server_ip_ << ":" << server_port_
 115               << " ";
 116     }
 117     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 118             << "Connecting to server: " << server_ip_ << ":" << server_port_
 119             << " ";
 120   } else {
 121     // If fd != -1 then we are initializing a connection that has just been
 122     // accepted from the listen socket.
 123     connection_complete_ = true;
 124     if (epoll_server_ && registered_in_epoll_server_ && fd_ != -1) {
 125       epoll_server_->UnregisterFD(fd_);
 126     }
 127     if (fd_ != -1) {
 128       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 129               << "Closing pre-existing fd";
 130       close(fd_);
 131       fd_ = -1;
 132     }
 133
 134     fd_ = fd;
 135   }
 136
 137   registered_in_epoll_server_ = false;
 138   // Set the last read time here as the idle checker will start from
 139   // now.
 140   last_read_time_ = time(NULL);
 141   initialized_ = true;
 142
 143   connection_pool_ = connection_pool;
 144   epoll_server_ = epoll_server;
 145
 146   if (sm_interface) {
 147     sm_interface_ = sm_interface;
 148     protocol_detected_ = true;
 149   }
 150
 151   read_buffer_.Clear();
 152
 153   epoll_server_->RegisterFD(fd_, this, EPOLLIN | EPOLLOUT | EPOLLET);
 154
 155   if (use_ssl) {
 156     ssl_ = CreateSSLContext(ssl_state_->ssl_ctx);
 157     SSL_set_fd(ssl_, fd_);
 158     PrintSslError();
 159   }
 160 }
 161
 162 void SMConnection::CorkSocket() {
 163   int state = 1;
 164   int rv = setsockopt(fd_, IPPROTO_TCP, TCP_CORK, &state, sizeof(state));
 165   if (rv < 0)
 166     VLOG(1) << "setsockopt(CORK): " << errno;
 167 }
 168
 169 void SMConnection::UncorkSocket() {
 170   int state = 0;
 171   int rv = setsockopt(fd_, IPPROTO_TCP, TCP_CORK, &state, sizeof(state));
 172   if (rv < 0)
 173     VLOG(1) << "setsockopt(CORK): " << errno;
 174 }
 175
 176 int SMConnection::Send(const char* data, int len, int flags) {
 177   int rv = 0;
 178   CorkSocket();
 179   if (ssl_) {
 180     ssize_t bytes_written = 0;
 181     // Write smallish chunks to SSL so that we don't have large
 182     // multi-packet TLS records to receive before being able to handle
 183     // the data.  We don't have to be too careful here, because our data
 184     // frames are already getting chunked appropriately, and those are
 185     // the most likely "big" frames.
 186     while (len > 0) {
 187       const int kMaxTLSRecordSize = 1500;
 188       const char* ptr = &(data[bytes_written]);
 189       int chunksize = std::min(len, kMaxTLSRecordSize);
 190       rv = SSL_write(ssl_, ptr, chunksize);
 191       VLOG(2) << "SSLWrite(" << chunksize << " bytes): " << rv;
 192       if (rv <= 0) {
 193         switch (SSL_get_error(ssl_, rv)) {
 194           case SSL_ERROR_WANT_READ:
 195           case SSL_ERROR_WANT_WRITE:
 196           case SSL_ERROR_WANT_ACCEPT:
 197           case SSL_ERROR_WANT_CONNECT:
 198             rv = -2;
 199             break;
 200           default:
 201             PrintSslError();
 202             break;
 203         }
 204         break;
 205       }
 206       bytes_written += rv;
 207       len -= rv;
 208       if (rv != chunksize)
 209         break;  // If we couldn't write everything, we're implicitly stalled
 210     }
 211     // If we wrote some data, return that count.  Otherwise
 212     // return the stall error.
 213     if (bytes_written > 0)
 214       rv = bytes_written;
 215   } else {
 216     rv = send(fd_, data, len, flags);
 217   }
 218   if (!(flags & MSG_MORE))
 219     UncorkSocket();
 220   return rv;
 221 }
 222
 223 void SMConnection::OnRegistration(EpollServer* eps, int fd, int event_mask) {
 224   registered_in_epoll_server_ = true;
 225 }
 226
 227 void SMConnection::OnEvent(int fd, EpollEvent* event) {
 228   events_ |= event->in_events;
 229   HandleEvents();
 230   if (events_) {
 231     event->out_ready_mask = events_;
 232     events_ = 0;
 233   }
 234 }
 235
 236 void SMConnection::OnUnregistration(int fd, bool replaced) {
 237   registered_in_epoll_server_ = false;
 238 }
 239
 240 void SMConnection::OnShutdown(EpollServer* eps, int fd) {
 241   Cleanup("OnShutdown");
 242   return;
 243 }
 244
 245 void SMConnection::Cleanup(const char* cleanup) {
 246   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Cleanup: " << cleanup;
 247   if (!initialized_)
 248     return;
 249   Reset();
 250   if (connection_pool_)
 251     connection_pool_->SMConnectionDone(this);
 252   if (sm_interface_)
 253     sm_interface_->ResetForNewConnection();
 254   last_read_time_ = 0;
 255 }
 256
 257 void SMConnection::HandleEvents() {
 258   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 259           << "Received: " << EpollServer::EventMaskToString(events_).c_str();
 260
 261   if (events_ & EPOLLIN) {
 262     if (!DoRead())
 263       goto handle_close_or_error;
 264   }
 265
 266   if (events_ & EPOLLOUT) {
 267     // Check if we have connected or not
 268     if (connection_complete_ == false) {
 269       int sock_error;
 270       socklen_t sock_error_len = sizeof(sock_error);
 271       int ret =
 272           getsockopt(fd_, SOL_SOCKET, SO_ERROR, &sock_error, &sock_error_len);
 273       if (ret != 0) {
 274         VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 275                 << "getsockopt error: " << errno << ": " << strerror(errno);
 276         goto handle_close_or_error;
 277       }
 278       if (sock_error == 0) {
 279         connection_complete_ = true;
 280         VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 281                 << "Connection complete to " << server_ip_ << ":"
 282                 << server_port_ << " ";
 283       } else if (sock_error == EINPROGRESS) {
 284         return;
 285       } else {
 286         VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 287                 << "error connecting to server";
 288         goto handle_close_or_error;
 289       }
 290     }
 291     if (!DoWrite())
 292       goto handle_close_or_error;
 293   }
 294
 295   if (events_ & (EPOLLHUP | EPOLLERR)) {
 296     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "!!! Got HUP or ERR";
 297     goto handle_close_or_error;
 298   }
 299   return;
 300
 301  handle_close_or_error:
 302   Cleanup("HandleEvents");
 303 }
 304
 305 // Decide if SPDY was negotiated.
 306 bool SMConnection::WasSpdyNegotiated(SpdyMajorVersion* version_negotiated) {
 307   *version_negotiated = SPDY3;
 308   if (force_spdy())
 309     return true;
 310
 311   // If this is an SSL connection, check if NPN specifies SPDY.
 312   if (ssl_) {
 313     const unsigned char* npn_proto;
 314     unsigned int npn_proto_len;
 315     SSL_get0_next_proto_negotiated(ssl_, &npn_proto, &npn_proto_len);
 316     if (npn_proto_len > 0) {
 317       std::string npn_proto_str((const char*)npn_proto, npn_proto_len);
 318       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 319               << "NPN protocol detected: " << npn_proto_str;
 320       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
 321                    "spdy/2",
 322                    npn_proto_len)) {
 323         *version_negotiated = SPDY2;
 324         return true;
 325       }
 326       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
 327                    "spdy/3",
 328                    npn_proto_len)) {
 329         *version_negotiated = SPDY3;
 330         return true;
 331       }
 332       if (!strncmp(reinterpret_cast<const char*>(npn_proto),
 333                    "spdy/4a2",
 334                    npn_proto_len)) {
 335         *version_negotiated = HTTP2;
 336         return true;
 337       }
 338     }
 339   }
 340
 341   return false;
 342 }
 343
 344 bool SMConnection::SetupProtocolInterfaces() {
 345   DCHECK(!protocol_detected_);
 346   protocol_detected_ = true;
 347
 348   SpdyMajorVersion version;
 349   bool spdy_negotiated = WasSpdyNegotiated(&version);
 350   bool using_ssl = ssl_ != NULL;
 351
 352   if (using_ssl)
 353     VLOG(1) << (SSL_session_reused(ssl_) ? "Resumed" : "Renegotiated")
 354             << " SSL Session.";
 355
 356   if (acceptor_->spdy_only_ && !spdy_negotiated) {
 357     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 358             << "SPDY proxy only, closing HTTPS connection.";
 359     return false;
 360   }
 361
 362   switch (acceptor_->flip_handler_type_) {
 363     case FLIP_HANDLER_HTTP_SERVER: {
 364       DCHECK(!spdy_negotiated);
 365       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 366               << (sm_http_interface_ ? "Creating" : "Reusing")
 367               << " HTTP interface.";
 368       if (!sm_http_interface_)
 369         sm_http_interface_ = new HttpSM(this, NULL, memory_cache_, acceptor_);
 370       sm_interface_ = sm_http_interface_;
 371       break;
 372     }
 373     case FLIP_HANDLER_PROXY: {
 374       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 375               << (sm_streamer_interface_ ? "Creating" : "Reusing")
 376               << " PROXY Streamer interface.";
 377       if (!sm_streamer_interface_) {
 378         sm_streamer_interface_ =
 379             new StreamerSM(this, NULL, epoll_server_, acceptor_);
 380         sm_streamer_interface_->set_is_request();
 381       }
 382       sm_interface_ = sm_streamer_interface_;
 383       // If spdy is not negotiated, the streamer interface will proxy all
 384       // data to the origin server.
 385       if (!spdy_negotiated)
 386         break;
 387     }
 388     // Otherwise fall through into the case below.
 389     case FLIP_HANDLER_SPDY_SERVER: {
 390       DCHECK(spdy_negotiated);
 391       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 392               << (sm_spdy_interface_ ? "Creating" : "Reusing")
 393               << " SPDY interface.";
 394       if (sm_spdy_interface_)
 395         sm_spdy_interface_->CreateFramer(version);
 396       else
 397         sm_spdy_interface_ = new SpdySM(
 398             this, NULL, epoll_server_, memory_cache_, acceptor_, version);
 399       sm_interface_ = sm_spdy_interface_;
 400       break;
 401     }
 402   }
 403
 404   CorkSocket();
 405   if (!sm_interface_->PostAcceptHook())
 406     return false;
 407
 408   return true;
 409 }
 410
 411 bool SMConnection::DoRead() {
 412   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "DoRead()";
 413   while (!read_buffer_.Full()) {
 414     char* bytes;
 415     int size;
 416     if (fd_ == -1) {
 417       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 418               << "DoRead(): fd_ == -1. Invalid FD. Returning false";
 419       return false;
 420     }
 421     read_buffer_.GetWritablePtr(&bytes, &size);
 422     ssize_t bytes_read = 0;
 423     if (ssl_) {
 424       bytes_read = SSL_read(ssl_, bytes, size);
 425       if (bytes_read < 0) {
 426         int err = SSL_get_error(ssl_, bytes_read);
 427         switch (err) {
 428           case SSL_ERROR_WANT_READ:
 429           case SSL_ERROR_WANT_WRITE:
 430           case SSL_ERROR_WANT_ACCEPT:
 431           case SSL_ERROR_WANT_CONNECT:
 432             events_ &= ~EPOLLIN;
 433             VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 434                     << "DoRead: SSL WANT_XXX: " << err;
 435             goto done;
 436           default:
 437             PrintSslError();
 438             goto error_or_close;
 439         }
 440       }
 441     } else {
 442       bytes_read = recv(fd_, bytes, size, MSG_DONTWAIT);
 443     }
 444     int stored_errno = errno;
 445     if (bytes_read == -1) {
 446       switch (stored_errno) {
 447         case EAGAIN:
 448           events_ &= ~EPOLLIN;
 449           VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 450                   << "Got EAGAIN while reading";
 451           goto done;
 452         case EINTR:
 453           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 454                   << "Got EINTR while reading";
 455           continue;
 456         default:
 457           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 458                   << "While calling recv, got error: "
 459                   << (ssl_ ? "(ssl error)" : strerror(stored_errno));
 460           goto error_or_close;
 461       }
 462     } else if (bytes_read > 0) {
 463       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "read " << bytes_read
 464               << " bytes";
 465       last_read_time_ = time(NULL);
 466       // If the protocol hasn't been detected yet, set up the handlers
 467       // we'll need.
 468       if (!protocol_detected_) {
 469         if (!SetupProtocolInterfaces()) {
 470           LOG(ERROR) << "Error setting up protocol interfaces.";
 471           goto error_or_close;
 472         }
 473       }
 474       read_buffer_.AdvanceWritablePtr(bytes_read);
 475       if (!DoConsumeReadData())
 476         goto error_or_close;
 477       continue;
 478     } else {  // bytes_read == 0
 479       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 480               << "0 bytes read with recv call.";
 481     }
 482     goto error_or_close;
 483   }
 484  done:
 485   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "DoRead done!";
 486   return true;
 487
 488  error_or_close:
 489   VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 490           << "DoRead(): error_or_close. "
 491           << "Cleaning up, then returning false";
 492   Cleanup("DoRead");
 493   return false;
 494 }
 495
 496 bool SMConnection::DoConsumeReadData() {
 497   char* bytes;
 498   int size;
 499   read_buffer_.GetReadablePtr(&bytes, &size);
 500   while (size != 0) {
 501     size_t bytes_consumed = sm_interface_->ProcessReadInput(bytes, size);
 502     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "consumed "
 503             << bytes_consumed << " bytes";
 504     if (bytes_consumed == 0) {
 505       break;
 506     }
 507     read_buffer_.AdvanceReadablePtr(bytes_consumed);
 508     if (sm_interface_->MessageFullyRead()) {
 509       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 510               << "HandleRequestFullyRead: Setting EPOLLOUT";
 511       HandleResponseFullyRead();
 512       events_ |= EPOLLOUT;
 513     } else if (sm_interface_->Error()) {
 514       LOG(ERROR) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 515                  << "Framer error detected: Setting EPOLLOUT: "
 516                  << sm_interface_->ErrorAsString();
 517       // this causes everything to be closed/cleaned up.
 518       events_ |= EPOLLOUT;
 519       return false;
 520     }
 521     read_buffer_.GetReadablePtr(&bytes, &size);
 522   }
 523   return true;
 524 }
 525
 526 void SMConnection::HandleResponseFullyRead() { sm_interface_->Cleanup(); }
 527
 528 bool SMConnection::DoWrite() {
 529   size_t bytes_sent = 0;
 530   int flags = MSG_NOSIGNAL | MSG_DONTWAIT;
 531   if (fd_ == -1) {
 532     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 533             << "DoWrite: fd == -1. Returning false.";
 534     return false;
 535   }
 536   if (output_list_.empty()) {
 537     VLOG(2) << log_prefix_ << "DoWrite: Output list empty.";
 538     if (sm_interface_) {
 539       sm_interface_->GetOutput();
 540     }
 541     if (output_list_.empty()) {
 542       events_ &= ~EPOLLOUT;
 543     }
 544   }
 545   while (!output_list_.empty()) {
 546     VLOG(2) << log_prefix_
 547             << "DoWrite: Items in output list: " << output_list_.size();
 548     if (bytes_sent >= max_bytes_sent_per_dowrite_) {
 549       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 550               << " byte sent >= max bytes sent per write: Setting EPOLLOUT: "
 551               << bytes_sent;
 552       events_ |= EPOLLOUT;
 553       break;
 554     }
 555     if (sm_interface_ && output_list_.size() < 2) {
 556       sm_interface_->GetOutput();
 557     }
 558     DataFrame* data_frame = output_list_.front();
 559     const char* bytes = data_frame->data;
 560     int size = data_frame->size;
 561     bytes += data_frame->index;
 562     size -= data_frame->index;
 563     DCHECK_GE(size, 0);
 564     if (size <= 0) {
 565       output_list_.pop_front();
 566       delete data_frame;
 567       continue;
 568     }
 569
 570     flags = MSG_NOSIGNAL | MSG_DONTWAIT;
 571     // Look for a queue size > 1 because |this| frame is remains on the list
 572     // until it has finished sending.
 573     if (output_list_.size() > 1) {
 574       VLOG(2) << log_prefix_ << "Outlist size: " << output_list_.size()
 575               << ": Adding MSG_MORE flag";
 576       flags |= MSG_MORE;
 577     }
 578     VLOG(2) << log_prefix_ << "Attempting to send " << size << " bytes.";
 579     ssize_t bytes_written = Send(bytes, size, flags);
 580     int stored_errno = errno;
 581     if (bytes_written == -1) {
 582       switch (stored_errno) {
 583         case EAGAIN:
 584           events_ &= ~EPOLLOUT;
 585           VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 586                   << "Got EAGAIN while writing";
 587           goto done;
 588         case EINTR:
 589           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 590                   << "Got EINTR while writing";
 591           continue;
 592         default:
 593           VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 594                   << "While calling send, got error: " << stored_errno << ": "
 595                   << (ssl_ ? "" : strerror(stored_errno));
 596           goto error_or_close;
 597       }
 598     } else if (bytes_written > 0) {
 599       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 600               << "Wrote: " << bytes_written << " bytes";
 601       data_frame->index += bytes_written;
 602       bytes_sent += bytes_written;
 603       continue;
 604     } else if (bytes_written == -2) {
 605       // -2 handles SSL_ERROR_WANT_* errors
 606       events_ &= ~EPOLLOUT;
 607       goto done;
 608     }
 609     VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 610             << "0 bytes written with send call.";
 611     goto error_or_close;
 612   }
 613  done:
 614   UncorkSocket();
 615   return true;
 616
 617  error_or_close:
 618   VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
 619           << "DoWrite: error_or_close. Returning false "
 620           << "after cleaning up";
 621   Cleanup("DoWrite");
 622   UncorkSocket();
 623   return false;
 624 }
 625
 626 void SMConnection::Reset() {
 627   VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Resetting";
 628   if (ssl_) {
 629     SSL_shutdown(ssl_);
 630     PrintSslError();
 631     SSL_free(ssl_);
 632     PrintSslError();
 633     ssl_ = NULL;
 634   }
 635   if (registered_in_epoll_server_) {
 636     epoll_server_->UnregisterFD(fd_);
 637     registered_in_epoll_server_ = false;
 638   }
 639   if (fd_ >= 0) {
 640     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Closing connection";
 641     close(fd_);
 642     fd_ = -1;
 643   }
 644   read_buffer_.Clear();
 645   initialized_ = false;
 646   protocol_detected_ = false;
 647   events_ = 0;
 648   for (std::list<DataFrame*>::iterator i = output_list_.begin();
 649        i != output_list_.end();
 650        ++i) {
 651     delete *i;
 652   }
 653   output_list_.clear();
 654 }
 655
 656 // static
 657 SMConnection* SMConnection::NewSMConnection(EpollServer* epoll_server,
 658                                             SSLState* ssl_state,
 659                                             MemoryCache* memory_cache,
 660                                             FlipAcceptor* acceptor,
 661                                             std::string log_prefix) {
 662   return new SMConnection(
 663       epoll_server, ssl_state, memory_cache, acceptor, log_prefix);
 664 }
 665
 666 }  // namespace net