src/third_party/libjingle/source/talk/base/schanneladapter.cc

   1 /*
   2  * libjingle
   3  * Copyright 2004--2005, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/base/win32.h"
  29 #define SECURITY_WIN32
  30 #include <security.h>
  31 #include <schannel.h>
  32
  33 #include <iomanip>
  34 #include <vector>
  35
  36 #include "talk/base/common.h"
  37 #include "talk/base/logging.h"
  38 #include "talk/base/schanneladapter.h"
  39 #include "talk/base/sec_buffer.h"
  40 #include "talk/base/thread.h"
  41
  42 namespace talk_base {
  43
  44 /////////////////////////////////////////////////////////////////////////////
  45 // SChannelAdapter
  46 /////////////////////////////////////////////////////////////////////////////
  47
  48 extern const ConstantLabel SECURITY_ERRORS[];
  49
  50 const ConstantLabel SCHANNEL_BUFFER_TYPES[] = {
  51   KLABEL(SECBUFFER_EMPTY),              //  0
  52   KLABEL(SECBUFFER_DATA),               //  1
  53   KLABEL(SECBUFFER_TOKEN),              //  2
  54   KLABEL(SECBUFFER_PKG_PARAMS),         //  3
  55   KLABEL(SECBUFFER_MISSING),            //  4
  56   KLABEL(SECBUFFER_EXTRA),              //  5
  57   KLABEL(SECBUFFER_STREAM_TRAILER),     //  6
  58   KLABEL(SECBUFFER_STREAM_HEADER),      //  7
  59   KLABEL(SECBUFFER_MECHLIST),           // 11
  60   KLABEL(SECBUFFER_MECHLIST_SIGNATURE), // 12
  61   KLABEL(SECBUFFER_TARGET),             // 13
  62   KLABEL(SECBUFFER_CHANNEL_BINDINGS),   // 14
  63   LASTLABEL
  64 };
  65
  66 void DescribeBuffer(LoggingSeverity severity, const char* prefix,
  67                     const SecBuffer& sb) {
  68   LOG_V(severity)
  69     << prefix
  70     << "(" << sb.cbBuffer
  71     << ", " << FindLabel(sb.BufferType & ~SECBUFFER_ATTRMASK,
  72                           SCHANNEL_BUFFER_TYPES)
  73     << ", " << sb.pvBuffer << ")";
  74 }
  75
  76 void DescribeBuffers(LoggingSeverity severity, const char* prefix,
  77                      const SecBufferDesc* sbd) {
  78   if (!LOG_CHECK_LEVEL_V(severity))
  79     return;
  80   LOG_V(severity) << prefix << "(";
  81   for (size_t i=0; i<sbd->cBuffers; ++i) {
  82     DescribeBuffer(severity, "  ", sbd->pBuffers[i]);
  83   }
  84   LOG_V(severity) << ")";
  85 }
  86
  87 const ULONG SSL_FLAGS_DEFAULT = ISC_REQ_ALLOCATE_MEMORY
  88                               | ISC_REQ_CONFIDENTIALITY
  89                               | ISC_REQ_EXTENDED_ERROR
  90                               | ISC_REQ_INTEGRITY
  91                               | ISC_REQ_REPLAY_DETECT
  92                               | ISC_REQ_SEQUENCE_DETECT
  93                               | ISC_REQ_STREAM;
  94                               //| ISC_REQ_USE_SUPPLIED_CREDS;
  95
  96 typedef std::vector<char> SChannelBuffer;
  97
  98 struct SChannelAdapter::SSLImpl {
  99   CredHandle cred;
 100   CtxtHandle ctx;
 101   bool cred_init, ctx_init;
 102   SChannelBuffer inbuf, outbuf, readable;
 103   SecPkgContext_StreamSizes sizes;
 104
 105   SSLImpl() : cred_init(false), ctx_init(false) { }
 106 };
 107
 108 SChannelAdapter::SChannelAdapter(AsyncSocket* socket)
 109   : SSLAdapter(socket), state_(SSL_NONE),
 110     restartable_(false), signal_close_(false), message_pending_(false),
 111     impl_(new SSLImpl) {
 112 }
 113
 114 SChannelAdapter::~SChannelAdapter() {
 115   Cleanup();
 116 }
 117
 118 int
 119 SChannelAdapter::StartSSL(const char* hostname, bool restartable) {
 120   if (state_ != SSL_NONE)
 121     return ERROR_ALREADY_INITIALIZED;
 122
 123   ssl_host_name_ = hostname;
 124   restartable_ = restartable;
 125
 126   if (socket_->GetState() != Socket::CS_CONNECTED) {
 127     state_ = SSL_WAIT;
 128     return 0;
 129   }
 130
 131   state_ = SSL_CONNECTING;
 132   if (int err = BeginSSL()) {
 133     Error("BeginSSL", err, false);
 134     return err;
 135   }
 136
 137   return 0;
 138 }
 139
 140 int
 141 SChannelAdapter::BeginSSL() {
 142   LOG(LS_VERBOSE) << "BeginSSL: " << ssl_host_name_;
 143   ASSERT(state_ == SSL_CONNECTING);
 144
 145   SECURITY_STATUS ret;
 146
 147   SCHANNEL_CRED sc_cred = { 0 };
 148   sc_cred.dwVersion = SCHANNEL_CRED_VERSION;
 149   //sc_cred.dwMinimumCipherStrength = 128; // Note: use system default
 150   sc_cred.dwFlags = SCH_CRED_NO_DEFAULT_CREDS | SCH_CRED_AUTO_CRED_VALIDATION;
 151
 152   ret = AcquireCredentialsHandle(NULL, UNISP_NAME, SECPKG_CRED_OUTBOUND, NULL,
 153                                  &sc_cred, NULL, NULL, &impl_->cred, NULL);
 154   if (ret != SEC_E_OK) {
 155     LOG(LS_ERROR) << "AcquireCredentialsHandle error: "
 156                   << ErrorName(ret, SECURITY_ERRORS);
 157     return ret;
 158   }
 159   impl_->cred_init = true;
 160
 161   if (LOG_CHECK_LEVEL(LS_VERBOSE)) {
 162     SecPkgCred_CipherStrengths cipher_strengths = { 0 };
 163     ret = QueryCredentialsAttributes(&impl_->cred,
 164                                      SECPKG_ATTR_CIPHER_STRENGTHS,
 165                                      &cipher_strengths);
 166     if (SUCCEEDED(ret)) {
 167       LOG(LS_VERBOSE) << "SChannel cipher strength: "
 168                   << cipher_strengths.dwMinimumCipherStrength << " - "
 169                   << cipher_strengths.dwMaximumCipherStrength;
 170     }
 171
 172     SecPkgCred_SupportedAlgs supported_algs = { 0 };
 173     ret = QueryCredentialsAttributes(&impl_->cred,
 174                                      SECPKG_ATTR_SUPPORTED_ALGS,
 175                                      &supported_algs);
 176     if (SUCCEEDED(ret)) {
 177       LOG(LS_VERBOSE) << "SChannel supported algorithms:";
 178       for (DWORD i=0; i<supported_algs.cSupportedAlgs; ++i) {
 179         ALG_ID alg_id = supported_algs.palgSupportedAlgs[i];
 180         PCCRYPT_OID_INFO oinfo = CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY,
 181                                                   &alg_id, 0);
 182         LPCWSTR alg_name = (NULL != oinfo) ? oinfo->pwszName : L"Unknown";
 183         LOG(LS_VERBOSE) << "  " << ToUtf8(alg_name) << " (" << alg_id << ")";
 184       }
 185       CSecBufferBase::FreeSSPI(supported_algs.palgSupportedAlgs);
 186     }
 187   }
 188
 189   ULONG flags = SSL_FLAGS_DEFAULT, ret_flags = 0;
 190   if (ignore_bad_cert())
 191     flags |= ISC_REQ_MANUAL_CRED_VALIDATION;
 192
 193   CSecBufferBundle<2, CSecBufferBase::FreeSSPI> sb_out;
 194   ret = InitializeSecurityContextA(&impl_->cred, NULL,
 195                                    const_cast<char*>(ssl_host_name_.c_str()),
 196                                    flags, 0, 0, NULL, 0,
 197                                    &impl_->ctx, sb_out.desc(),
 198                                    &ret_flags, NULL);
 199   if (SUCCEEDED(ret))
 200     impl_->ctx_init = true;
 201   return ProcessContext(ret, NULL, sb_out.desc());
 202 }
 203
 204 int
 205 SChannelAdapter::ContinueSSL() {
 206   LOG(LS_VERBOSE) << "ContinueSSL";
 207   ASSERT(state_ == SSL_CONNECTING);
 208
 209   SECURITY_STATUS ret;
 210
 211   CSecBufferBundle<2> sb_in;
 212   sb_in[0].BufferType = SECBUFFER_TOKEN;
 213   sb_in[0].cbBuffer = static_cast<unsigned long>(impl_->inbuf.size());
 214   sb_in[0].pvBuffer = &impl_->inbuf[0];
 215   //DescribeBuffers(LS_VERBOSE, "Input Buffer ", sb_in.desc());
 216
 217   ULONG flags = SSL_FLAGS_DEFAULT, ret_flags = 0;
 218   if (ignore_bad_cert())
 219     flags |= ISC_REQ_MANUAL_CRED_VALIDATION;
 220
 221   CSecBufferBundle<2, CSecBufferBase::FreeSSPI> sb_out;
 222   ret = InitializeSecurityContextA(&impl_->cred, &impl_->ctx,
 223                                    const_cast<char*>(ssl_host_name_.c_str()),
 224                                    flags, 0, 0, sb_in.desc(), 0,
 225                                    NULL, sb_out.desc(),
 226                                    &ret_flags, NULL);
 227   return ProcessContext(ret, sb_in.desc(), sb_out.desc());
 228 }
 229
 230 int
 231 SChannelAdapter::ProcessContext(long int status, _SecBufferDesc* sbd_in,
 232                                 _SecBufferDesc* sbd_out) {
 233   if (status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED &&
 234       status != SEC_E_INCOMPLETE_MESSAGE) {
 235     LOG(LS_ERROR)
 236       << "InitializeSecurityContext error: "
 237       << ErrorName(status, SECURITY_ERRORS);
 238   }
 239   //if (sbd_in)
 240   //  DescribeBuffers(LS_VERBOSE, "Input Buffer ", sbd_in);
 241   //if (sbd_out)
 242   //  DescribeBuffers(LS_VERBOSE, "Output Buffer ", sbd_out);
 243
 244   if (status == SEC_E_INCOMPLETE_MESSAGE) {
 245     // Wait for more input from server.
 246     return Flush();
 247   }
 248
 249   if (FAILED(status)) {
 250     // We can't continue.  Common errors:
 251     // SEC_E_CERT_EXPIRED - Typically, this means the computer clock is wrong.
 252     return status;
 253   }
 254
 255   // Note: we check both input and output buffers for SECBUFFER_EXTRA.
 256   // Experience shows it appearing in the input, but the documentation claims
 257   // it should appear in the output.
 258   size_t extra = 0;
 259   if (sbd_in) {
 260     for (size_t i=0; i<sbd_in->cBuffers; ++i) {
 261       SecBuffer& buffer = sbd_in->pBuffers[i];
 262       if (buffer.BufferType == SECBUFFER_EXTRA) {
 263         extra += buffer.cbBuffer;
 264       }
 265     }
 266   }
 267   if (sbd_out) {
 268     for (size_t i=0; i<sbd_out->cBuffers; ++i) {
 269       SecBuffer& buffer = sbd_out->pBuffers[i];
 270       if (buffer.BufferType == SECBUFFER_EXTRA) {
 271         extra += buffer.cbBuffer;
 272       } else if (buffer.BufferType == SECBUFFER_TOKEN) {
 273         impl_->outbuf.insert(impl_->outbuf.end(),
 274           reinterpret_cast<char*>(buffer.pvBuffer),
 275           reinterpret_cast<char*>(buffer.pvBuffer) + buffer.cbBuffer);
 276       }
 277     }
 278   }
 279
 280   if (extra) {
 281     ASSERT(extra <= impl_->inbuf.size());
 282     size_t consumed = impl_->inbuf.size() - extra;
 283     memmove(&impl_->inbuf[0], &impl_->inbuf[consumed], extra);
 284     impl_->inbuf.resize(extra);
 285   } else {
 286     impl_->inbuf.clear();
 287   }
 288
 289   if (SEC_I_CONTINUE_NEEDED == status) {
 290     // Send data to server and wait for response.
 291     // Note: ContinueSSL will result in a Flush, anyway.
 292     return impl_->inbuf.empty() ? Flush() : ContinueSSL();
 293   }
 294
 295   if (SEC_E_OK == status) {
 296     LOG(LS_VERBOSE) << "QueryContextAttributes";
 297     status = QueryContextAttributes(&impl_->ctx, SECPKG_ATTR_STREAM_SIZES,
 298                                     &impl_->sizes);
 299     if (FAILED(status)) {
 300       LOG(LS_ERROR) << "QueryContextAttributes error: "
 301                     << ErrorName(status, SECURITY_ERRORS);
 302       return status;
 303     }
 304
 305     state_ = SSL_CONNECTED;
 306
 307     if (int err = DecryptData()) {
 308       return err;
 309     } else if (int err = Flush()) {
 310       return err;
 311     } else {
 312       // If we decrypted any data, queue up a notification here
 313       PostEvent();
 314       // Signal our connectedness
 315       AsyncSocketAdapter::OnConnectEvent(this);
 316     }
 317     return 0;
 318   }
 319
 320   if (SEC_I_INCOMPLETE_CREDENTIALS == status) {
 321     // We don't support client authentication in schannel.
 322     return status;
 323   }
 324
 325   // We don't expect any other codes
 326   ASSERT(false);
 327   return status;
 328 }
 329
 330 int
 331 SChannelAdapter::DecryptData() {
 332   SChannelBuffer& inbuf = impl_->inbuf;
 333   SChannelBuffer& readable = impl_->readable;
 334
 335   while (!inbuf.empty()) {
 336     CSecBufferBundle<4> in_buf;
 337     in_buf[0].BufferType = SECBUFFER_DATA;
 338     in_buf[0].cbBuffer = static_cast<unsigned long>(inbuf.size());
 339     in_buf[0].pvBuffer = &inbuf[0];
 340
 341     //DescribeBuffers(LS_VERBOSE, "Decrypt In ", in_buf.desc());
 342     SECURITY_STATUS status = DecryptMessage(&impl_->ctx, in_buf.desc(), 0, 0);
 343     //DescribeBuffers(LS_VERBOSE, "Decrypt Out ", in_buf.desc());
 344
 345     // Note: We are explicitly treating SEC_E_OK, SEC_I_CONTEXT_EXPIRED, and
 346     // any other successful results as continue.
 347     if (SUCCEEDED(status)) {
 348       size_t data_len = 0, extra_len = 0;
 349       for (size_t i=0; i<in_buf.desc()->cBuffers; ++i) {
 350         if (in_buf[i].BufferType == SECBUFFER_DATA) {
 351           data_len += in_buf[i].cbBuffer;
 352           readable.insert(readable.end(),
 353             reinterpret_cast<char*>(in_buf[i].pvBuffer),
 354             reinterpret_cast<char*>(in_buf[i].pvBuffer) + in_buf[i].cbBuffer);
 355         } else if (in_buf[i].BufferType == SECBUFFER_EXTRA) {
 356           extra_len += in_buf[i].cbBuffer;
 357         }
 358       }
 359       // There is a bug on Win2K where SEC_I_CONTEXT_EXPIRED is misclassified.
 360       if ((data_len == 0) && (inbuf[0] == 0x15)) {
 361         status = SEC_I_CONTEXT_EXPIRED;
 362       }
 363       if (extra_len) {
 364         size_t consumed = inbuf.size() - extra_len;
 365         memmove(&inbuf[0], &inbuf[consumed], extra_len);
 366         inbuf.resize(extra_len);
 367       } else {
 368         inbuf.clear();
 369       }
 370       // TODO: Handle SEC_I_CONTEXT_EXPIRED to do clean shutdown
 371       if (status != SEC_E_OK) {
 372         LOG(LS_INFO) << "DecryptMessage returned continuation code: "
 373                       << ErrorName(status, SECURITY_ERRORS);
 374       }
 375       continue;
 376     }
 377
 378     if (status == SEC_E_INCOMPLETE_MESSAGE) {
 379       break;
 380     } else {
 381       return status;
 382     }
 383   }
 384
 385   return 0;
 386 }
 387
 388 void
 389 SChannelAdapter::Cleanup() {
 390   if (impl_->ctx_init)
 391     DeleteSecurityContext(&impl_->ctx);
 392   if (impl_->cred_init)
 393     FreeCredentialsHandle(&impl_->cred);
 394   delete impl_;
 395 }
 396
 397 void
 398 SChannelAdapter::PostEvent() {
 399   // Check if there's anything notable to signal
 400   if (impl_->readable.empty() && !signal_close_)
 401     return;
 402
 403   // Only one post in the queue at a time
 404   if (message_pending_)
 405     return;
 406
 407   if (Thread* thread = Thread::Current()) {
 408     message_pending_ = true;
 409     thread->Post(this);
 410   } else {
 411     LOG(LS_ERROR) << "No thread context available for SChannelAdapter";
 412     ASSERT(false);
 413   }
 414 }
 415
 416 void
 417 SChannelAdapter::Error(const char* context, int err, bool signal) {
 418   LOG(LS_WARNING) << "SChannelAdapter::Error("
 419                   << context << ", "
 420                   << ErrorName(err, SECURITY_ERRORS) << ")";
 421   state_ = SSL_ERROR;
 422   SetError(err);
 423   if (signal)
 424     AsyncSocketAdapter::OnCloseEvent(this, err);
 425 }
 426
 427 int
 428 SChannelAdapter::Read() {
 429   char buffer[4096];
 430   SChannelBuffer& inbuf = impl_->inbuf;
 431   while (true) {
 432     int ret = AsyncSocketAdapter::Recv(buffer, sizeof(buffer));
 433     if (ret > 0) {
 434       inbuf.insert(inbuf.end(), buffer, buffer + ret);
 435     } else if (GetError() == EWOULDBLOCK) {
 436       return 0;  // Blocking
 437     } else {
 438       return GetError();
 439     }
 440   }
 441 }
 442
 443 int
 444 SChannelAdapter::Flush() {
 445   int result = 0;
 446   size_t pos = 0;
 447   SChannelBuffer& outbuf = impl_->outbuf;
 448   while (pos < outbuf.size()) {
 449     int sent = AsyncSocketAdapter::Send(&outbuf[pos], outbuf.size() - pos);
 450     if (sent > 0) {
 451       pos += sent;
 452     } else if (GetError() == EWOULDBLOCK) {
 453       break;  // Blocking
 454     } else {
 455       result = GetError();
 456       break;
 457     }
 458   }
 459   if (int remainder = static_cast<int>(outbuf.size() - pos)) {
 460     memmove(&outbuf[0], &outbuf[pos], remainder);
 461     outbuf.resize(remainder);
 462   } else {
 463     outbuf.clear();
 464   }
 465   return result;
 466 }
 467
 468 //
 469 // AsyncSocket Implementation
 470 //
 471
 472 int
 473 SChannelAdapter::Send(const void* pv, size_t cb) {
 474   switch (state_) {
 475   case SSL_NONE:
 476     return AsyncSocketAdapter::Send(pv, cb);
 477
 478   case SSL_WAIT:
 479   case SSL_CONNECTING:
 480     SetError(EWOULDBLOCK);
 481     return SOCKET_ERROR;
 482
 483   case SSL_CONNECTED:
 484     break;
 485
 486   case SSL_ERROR:
 487   default:
 488     return SOCKET_ERROR;
 489   }
 490
 491   size_t written = 0;
 492   SChannelBuffer& outbuf = impl_->outbuf;
 493   while (written < cb) {
 494     const size_t encrypt_len = std::min<size_t>(cb - written,
 495                                                 impl_->sizes.cbMaximumMessage);
 496
 497     CSecBufferBundle<4> out_buf;
 498     out_buf[0].BufferType = SECBUFFER_STREAM_HEADER;
 499     out_buf[0].cbBuffer = impl_->sizes.cbHeader;
 500     out_buf[1].BufferType = SECBUFFER_DATA;
 501     out_buf[1].cbBuffer = static_cast<unsigned long>(encrypt_len);
 502     out_buf[2].BufferType = SECBUFFER_STREAM_TRAILER;
 503     out_buf[2].cbBuffer = impl_->sizes.cbTrailer;
 504
 505     size_t packet_len = out_buf[0].cbBuffer
 506                       + out_buf[1].cbBuffer
 507                       + out_buf[2].cbBuffer;
 508
 509     SChannelBuffer message;
 510     message.resize(packet_len);
 511     out_buf[0].pvBuffer = &message[0];
 512     out_buf[1].pvBuffer = &message[out_buf[0].cbBuffer];
 513     out_buf[2].pvBuffer = &message[out_buf[0].cbBuffer + out_buf[1].cbBuffer];
 514
 515     memcpy(out_buf[1].pvBuffer,
 516            static_cast<const char*>(pv) + written,
 517            encrypt_len);
 518
 519     //DescribeBuffers(LS_VERBOSE, "Encrypt In ", out_buf.desc());
 520     SECURITY_STATUS res = EncryptMessage(&impl_->ctx, 0, out_buf.desc(), 0);
 521     //DescribeBuffers(LS_VERBOSE, "Encrypt Out ", out_buf.desc());
 522
 523     if (FAILED(res)) {
 524       Error("EncryptMessage", res, false);
 525       return SOCKET_ERROR;
 526     }
 527
 528     // We assume that the header and data segments do not change length,
 529     // or else encrypting the concatenated packet in-place is wrong.
 530     ASSERT(out_buf[0].cbBuffer == impl_->sizes.cbHeader);
 531     ASSERT(out_buf[1].cbBuffer == static_cast<unsigned long>(encrypt_len));
 532
 533     // However, the length of the trailer may change due to padding.
 534     ASSERT(out_buf[2].cbBuffer <= impl_->sizes.cbTrailer);
 535
 536     packet_len = out_buf[0].cbBuffer
 537                + out_buf[1].cbBuffer
 538                + out_buf[2].cbBuffer;
 539
 540     written += encrypt_len;
 541     outbuf.insert(outbuf.end(), &message[0], &message[packet_len-1]+1);
 542   }
 543
 544   if (int err = Flush()) {
 545     state_ = SSL_ERROR;
 546     SetError(err);
 547     return SOCKET_ERROR;
 548   }
 549
 550   return static_cast<int>(written);
 551 }
 552
 553 int
 554 SChannelAdapter::Recv(void* pv, size_t cb) {
 555   switch (state_) {
 556   case SSL_NONE:
 557     return AsyncSocketAdapter::Recv(pv, cb);
 558
 559   case SSL_WAIT:
 560   case SSL_CONNECTING:
 561     SetError(EWOULDBLOCK);
 562     return SOCKET_ERROR;
 563
 564   case SSL_CONNECTED:
 565     break;
 566
 567   case SSL_ERROR:
 568   default:
 569     return SOCKET_ERROR;
 570   }
 571
 572   SChannelBuffer& readable = impl_->readable;
 573   if (readable.empty()) {
 574     SetError(EWOULDBLOCK);
 575     return SOCKET_ERROR;
 576   }
 577   size_t read = _min(cb, readable.size());
 578   memcpy(pv, &readable[0], read);
 579   if (size_t remaining = readable.size() - read) {
 580     memmove(&readable[0], &readable[read], remaining);
 581     readable.resize(remaining);
 582   } else {
 583     readable.clear();
 584   }
 585
 586   PostEvent();
 587   return static_cast<int>(read);
 588 }
 589
 590 int
 591 SChannelAdapter::Close() {
 592   if (!impl_->readable.empty()) {
 593     LOG(WARNING) << "SChannelAdapter::Close with readable data";
 594     // Note: this isn't strictly an error, but we're using it temporarily to
 595     // track bugs.
 596     //ASSERT(false);
 597   }
 598   if (state_ == SSL_CONNECTED) {
 599     DWORD token = SCHANNEL_SHUTDOWN;
 600     CSecBufferBundle<1> sb_in;
 601     sb_in[0].BufferType = SECBUFFER_TOKEN;
 602     sb_in[0].cbBuffer = sizeof(token);
 603     sb_in[0].pvBuffer = &token;
 604     ApplyControlToken(&impl_->ctx, sb_in.desc());
 605     // TODO: In theory, to do a nice shutdown, we need to begin shutdown
 606     // negotiation with more calls to InitializeSecurityContext.  Since the
 607     // socket api doesn't support nice shutdown at this point, we don't bother.
 608   }
 609   Cleanup();
 610   impl_ = new SSLImpl;
 611   state_ = restartable_ ? SSL_WAIT : SSL_NONE;
 612   signal_close_ = false;
 613   message_pending_ = false;
 614   return AsyncSocketAdapter::Close();
 615 }
 616
 617 Socket::ConnState
 618 SChannelAdapter::GetState() const {
 619   if (signal_close_)
 620     return CS_CONNECTED;
 621   ConnState state = socket_->GetState();
 622   if ((state == CS_CONNECTED)
 623       && ((state_ == SSL_WAIT) || (state_ == SSL_CONNECTING)))
 624     state = CS_CONNECTING;
 625   return state;
 626 }
 627
 628 void
 629 SChannelAdapter::OnConnectEvent(AsyncSocket* socket) {
 630   LOG(LS_VERBOSE) << "SChannelAdapter::OnConnectEvent";
 631   if (state_ != SSL_WAIT) {
 632     ASSERT(state_ == SSL_NONE);
 633     AsyncSocketAdapter::OnConnectEvent(socket);
 634     return;
 635   }
 636
 637   state_ = SSL_CONNECTING;
 638   if (int err = BeginSSL()) {
 639     Error("BeginSSL", err);
 640   }
 641 }
 642
 643 void
 644 SChannelAdapter::OnReadEvent(AsyncSocket* socket) {
 645   if (state_ == SSL_NONE) {
 646     AsyncSocketAdapter::OnReadEvent(socket);
 647     return;
 648   }
 649
 650   if (int err = Read()) {
 651     Error("Read", err);
 652     return;
 653   }
 654
 655   if (impl_->inbuf.empty())
 656     return;
 657
 658   if (state_ == SSL_CONNECTED) {
 659     if (int err = DecryptData()) {
 660       Error("DecryptData", err);
 661     } else if (!impl_->readable.empty()) {
 662       AsyncSocketAdapter::OnReadEvent(this);
 663     }
 664   } else if (state_ == SSL_CONNECTING) {
 665     if (int err = ContinueSSL()) {
 666       Error("ContinueSSL", err);
 667     }
 668   }
 669 }
 670
 671 void
 672 SChannelAdapter::OnWriteEvent(AsyncSocket* socket) {
 673   if (state_ == SSL_NONE) {
 674     AsyncSocketAdapter::OnWriteEvent(socket);
 675     return;
 676   }
 677
 678   if (int err = Flush()) {
 679     Error("Flush", err);
 680     return;
 681   }
 682
 683   // See if we have more data to write
 684   if (!impl_->outbuf.empty())
 685     return;
 686
 687   // Buffer is empty, submit notification
 688   if (state_ == SSL_CONNECTED) {
 689     AsyncSocketAdapter::OnWriteEvent(socket);
 690   }
 691 }
 692
 693 void
 694 SChannelAdapter::OnCloseEvent(AsyncSocket* socket, int err) {
 695   if ((state_ == SSL_NONE) || impl_->readable.empty()) {
 696     AsyncSocketAdapter::OnCloseEvent(socket, err);
 697     return;
 698   }
 699
 700   // If readable is non-empty, then we have a pending Message
 701   // that will allow us to signal close (eventually).
 702   signal_close_ = true;
 703 }
 704
 705 void
 706 SChannelAdapter::OnMessage(Message* pmsg) {
 707   if (!message_pending_)
 708     return;  // This occurs when socket is closed
 709
 710   message_pending_ = false;
 711   if (!impl_->readable.empty()) {
 712     AsyncSocketAdapter::OnReadEvent(this);
 713   } else if (signal_close_) {
 714     signal_close_ = false;
 715     AsyncSocketAdapter::OnCloseEvent(this, 0); // TODO: cache this error?
 716   }
 717 }
 718
 719 } // namespace talk_base