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 = SPDY4; 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 667
