Multi-step authentication support in JingleSession.

remoting/protocol/v1_authenticator.cc

 // Copyright (c) 2011 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 "remoting/protocol/v1_authenticator.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "crypto/rsa_private_key.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/v1_client_channel_authenticator.h"
 #include "remoting/protocol/v1_host_channel_authenticator.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
-const char kAuthenticationTag[] = "authentication";
 const char kAuthTokenTag[] = "auth-token";
 const char kCertificateTag[] = "certificate";
 }  // namespace
 
 V1ClientAuthenticator::V1ClientAuthenticator(
     const std::string& local_jid,
     const std::string& shared_secret)
     : local_jid_(local_jid),
       shared_secret_(shared_secret),
       state_(MESSAGE_READY) {
@@ skipping 23 matching lines @@
   if (remote_cert_.empty()) {
     state_ = REJECTED;
   } else {
     state_ = ACCEPTED;
   }
 }
 
 XmlElement* V1ClientAuthenticator::GetNextMessage() {
   DCHECK_EQ(state_, MESSAGE_READY);
 
-  XmlElement* authentication_tag = new XmlElement(
-      QName(kChromotingXmlNamespace, kAuthenticationTag));
-
+  XmlElement* message = CreateEmptyAuthenticatorMessage();
   std::string token =
       protocol::GenerateSupportAuthToken(local_jid_, shared_secret_);
-
   XmlElement* auth_token_tag = new XmlElement(
       QName(kChromotingXmlNamespace, kAuthTokenTag));
   auth_token_tag->SetBodyText(token);
-  authentication_tag->AddElement(auth_token_tag);
+  message->AddElement(auth_token_tag);
 
   state_ = WAITING_MESSAGE;
-  return authentication_tag;
+  return message;
 }
 
 ChannelAuthenticator*
 V1ClientAuthenticator::CreateChannelAuthenticator() const {
   DCHECK_EQ(state_, ACCEPTED);
   return new V1ClientChannelAuthenticator(remote_cert_, shared_secret_);
 };
 
 V1HostAuthenticator::V1HostAuthenticator(
     const std::string& local_cert,
@@ skipping 24 matching lines @@
           remote_jid_, shared_secret_, auth_token)) {
     state_ = REJECTED;
   } else {
     state_ = MESSAGE_READY;
   }
 }
 
 XmlElement* V1HostAuthenticator::GetNextMessage() {
   DCHECK_EQ(state_, MESSAGE_READY);
 
-  XmlElement* message = new XmlElement(
-      QName(kChromotingXmlNamespace, kAuthenticationTag));
-
+  XmlElement* message = CreateEmptyAuthenticatorMessage();
   buzz::XmlElement* certificate_tag = new XmlElement(
       buzz::QName(kChromotingXmlNamespace, kCertificateTag));
   std::string base64_cert;
   if (!base::Base64Encode(local_cert_, &base64_cert)) {
     LOG(DFATAL) << "Cannot perform base64 encode on certificate";
   }
   certificate_tag->SetBodyText(base64_cert);
   message->AddElement(certificate_tag);
 
   state_ = ACCEPTED;
@@ skipping 22 matching lines @@
 
 Authenticator* V1HostAuthenticatorFactory::CreateAuthenticator(
     const std::string& remote_jid,
     const buzz::XmlElement* first_message) {
   return new V1HostAuthenticator(local_cert_, local_private_key_.get(),
                                  shared_secret_, remote_jid);
 }
 
 }  // namespace remoting
 }  // namespace protocol