Support LCS signaling address in the Host.

remoting/protocol/jingle_messages.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 "remoting/protocol/jingle_messages.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.h"
@@ skipping 15 matching lines @@
 const char kIceTransportNamespace[] = "google:remoting:ice";
 
 const char kWebrtcTransportNamespace[] = "google:remoting:webrtc";
 
 const char kEmptyNamespace[] = "";
 const char kXmlNamespace[] = "http://www.w3.org/XML/1998/namespace";
 
 const int kPortMin = 1000;
 const int kPortMax = 65535;
 
+const NameMapElement<Address::Channel> kChannelTypes[] = {
+  { Address::LCS, "lcs" },
+  { Address::XMPP, "xmpp" },
+};
+
 const NameMapElement<JingleMessage::ActionType> kActionTypes[] = {
   { JingleMessage::SESSION_INITIATE, "session-initiate" },
   { JingleMessage::SESSION_ACCEPT, "session-accept" },
   { JingleMessage::SESSION_TERMINATE, "session-terminate" },
   { JingleMessage::SESSION_INFO, "session-info" },
   { JingleMessage::TRANSPORT_INFO, "transport-info" },
 };
 
 const NameMapElement<JingleMessage::Reason> kReasons[] = {
   { JingleMessage::SUCCESS, "success" },
@@ skipping 105 matching lines @@
     : name(name),
       candidate(candidate) {
 }
 
 IceTransportInfo::IceCredentials::IceCredentials(std::string channel,
                                               std::string ufrag,
                                               std::string password)
     : channel(channel), ufrag(ufrag), password(password) {
 }
 
+
+//static
+buzz::QName Address::GetQName(Role role, Attribute attr) {
+  std::string attribute_name;
+  bool from = role == Address::FROM;
+  switch (attr) {
+    case Address::JID:
+      attribute_name = (from) ? "from" : "to";
+      break;
+    case Address::ENDPOINT_ID:
+      attribute_name = (from) ? "from-endpoint-id" : "to-endpoint-id";
+      break;
+    case Address::CHANNEL:
+      attribute_name = (from) ? "from-channel" : "to-channel";
+      break;
+    default:
+      NOTREACHED();
+  }
+  return QName(kEmptyNamespace, attribute_name);
+}
+
+Address::Address()
+    : jid(""), endpoint_id(""), channel(Address::XMPP) {}

[Sergey Ulanov, 2016/05/18 07:00:41]

don't need to specify jid and endpoint_id explicitly here.

[kelvinp, 2016/05/18 23:43:28]

Done.

+
+Address::Address(const std::string& jid)
+    : jid(jid), endpoint_id(jid), channel(Address::XMPP) {}
+
+bool Address::ParseXml(const buzz::XmlElement* stanza,
+                       Role role,
+                       std::string* error) {
+  std::string channel_str;
+  jid = stanza->Attr(GetQName(role, Address::JID));
+  channel_str = stanza->Attr(GetQName(role, Address::CHANNEL));
+  endpoint_id = stanza->Attr(GetQName(role, Address::ENDPOINT_ID));
+
+  if (channel_str.empty()) {
+    channel = Address::XMPP;
+  } else if (!NameToValue(kChannelTypes, channel_str, &channel)) {
+    *error = "Unknown channel " + channel_str;
+    return false;
+  }
+
+  if (endpoint_id.empty()) {

[Sergey Ulanov, 2016/05/18 07:00:41]

I think it's better to branch here by channel and verify that endpoint_id is
either set for LCS or not set for XMPP.

Or this can be something like this:
  bool is_lcs = (channel == Address::LCS);
  if (is_lcs == endpoint_id.empty()) {
    boom
  }

[kelvinp, 2016/05/18 23:43:28]

Done.

+    if (channel == Address::LCS) {
+      *error = "Missing |endpoint-id| for the lcs channel";
+      return false;
+    }
+    endpoint_id = jid;
+  } else if (jid.empty()) {

[Sergey Ulanov, 2016/05/18 07:00:41]

I think we always expect to have a valid jid, so this shouldn't be an else
statement. Move it right after we extract JID?

[kelvinp, 2016/05/18 23:43:28]

Acknowledged.

+      *error = "|endpoint-id| is not empty but the |jid| is empty.";

[Sergey Ulanov, 2016/05/18 07:00:41]

indentation. 'git cl format' please

[kelvinp, 2016/05/18 23:43:28]

Done.

+      return false;
+  }
+
+  return true;
+}
+
+void Address::toXml(buzz::XmlElement* iqElement,
+                    Role role) const {
+  if (empty()) {
+    return;
+  }
+
+  const char* channel_str = ValueToName(kChannelTypes, channel);
+  if (!channel_str)
+    LOG(FATAL) << "Invalid channel value " << channel;

[Sergey Ulanov, 2016/05/18 07:00:41]

Don't really need this. This case is already marked as NOTREACHED()  in
ValueToName()

[kelvinp, 2016/05/18 23:43:28]

Done.

+
+  iqElement->AddAttr(GetQName(role, Address::JID), jid);
+
+  if (endpoint_id != jid) {

[Sergey Ulanov, 2016/05/18 07:00:41]

Replace this condition with (channel == Address::LCS)? It's easier to understand
and is faster.

[kelvinp, 2016/05/18 23:43:28]

Done.

+    DCHECK(channel == Address::LCS);
+    iqElement->AddAttr(GetQName(role, Address::ENDPOINT_ID), endpoint_id);
+    iqElement->AddAttr(GetQName(role, Address::CHANNEL), channel_str);
+  }
+}
+
+bool Address::operator==(const Address& other) {
+  return (other.endpoint_id == endpoint_id) &&
+         (other.jid == jid) &&
+         (other.channel == channel);
+}
+
+bool Address::operator!=(const Address& other) {
+  return !(*this == other);
+}
+
+bool Address::empty() const {
+  return jid.empty() && endpoint_id.empty();
+}
+
 // static
 bool JingleMessage::IsJingleMessage(const buzz::XmlElement* stanza) {
   return stanza->Name() == QName(kJabberNamespace, "iq") &&
          stanza->Attr(QName(std::string(), "type")) == "set" &&
          stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != nullptr;
 }
 
 // static
 std::string JingleMessage::GetActionName(ActionType action) {
   return ValueToName(kActionTypes, action);
 }
 
 JingleMessage::JingleMessage() {}
 
-JingleMessage::JingleMessage(const std::string& to,
+JingleMessage::JingleMessage(const Address& to,
                              ActionType action,
                              const std::string& sid)
     : to(to), action(action), sid(sid) {}
 
 JingleMessage::~JingleMessage() {}
 
 bool JingleMessage::ParseXml(const buzz::XmlElement* stanza,
                              std::string* error) {
   if (!IsJingleMessage(stanza)) {
     *error = "Not a jingle message";
     return false;
   }
 
   const XmlElement* jingle_tag =
       stanza->FirstNamed(QName(kJingleNamespace, "jingle"));
   if (!jingle_tag) {
     *error = "Not a jingle message";
     return false;
   }
 
-  from = stanza->Attr(QName(kEmptyNamespace, "from"));
-  to = stanza->Attr(QName(kEmptyNamespace, "to"));
+  if(!from.ParseXml(stanza, Address::FROM, error)) {
+    *error = "Invalid from field";
+    return false;
+  }
+
+  if (!to.ParseXml(stanza, Address::TO, error)) {
+    *error = "Invalid to field.";
+    return false;
+  }
+
   initiator = jingle_tag->Attr(QName(kEmptyNamespace, "initiator"));
 
   std::string action_str = jingle_tag->Attr(QName(kEmptyNamespace, "action"));
   if (action_str.empty()) {
     *error = "action attribute is missing";
     return false;
   }
   if (!NameToValue(kActionTypes, action_str, &action)) {
     *error = "Unknown action " + action_str;
     return false;
@@ skipping 74 matching lines @@
     }
   }
 
   return true;
 }
 
 std::unique_ptr<buzz::XmlElement> JingleMessage::ToXml() const {
   std::unique_ptr<XmlElement> root(
       new XmlElement(QName("jabber:client", "iq"), true));
 
-  DCHECK(!to.empty());
-  root->AddAttr(QName(kEmptyNamespace, "to"), to);
-  if (!from.empty())
-    root->AddAttr(QName(kEmptyNamespace, "from"), from);
+  from.toXml(root.get(), Address::FROM);
+  to.toXml(root.get(), Address::TO);
   root->SetAttr(QName(kEmptyNamespace, "type"), "set");
 
   XmlElement* jingle_tag =
       new XmlElement(QName(kJingleNamespace, "jingle"), true);
   root->AddElement(jingle_tag);
   jingle_tag->AddAttr(QName(kEmptyNamespace, "sid"), sid);
 
   const char* action_attr = ValueToName(kActionTypes, action);
   if (!action_attr)
     LOG(FATAL) << "Invalid action value " << action;
@@ skipping 58 matching lines @@
       error_type(error),
       text(text_value) {
 }
 
 JingleMessageReply::~JingleMessageReply() { }
 
 std::unique_ptr<buzz::XmlElement> JingleMessageReply::ToXml(
     const buzz::XmlElement* request_stanza) const {
   std::unique_ptr<XmlElement> iq(
       new XmlElement(QName(kJabberNamespace, "iq"), true));
-  iq->SetAttr(QName(kEmptyNamespace, "to"),
-              request_stanza->Attr(QName(kEmptyNamespace, "from")));
+
+

[Sergey Ulanov, 2016/05/18 07:00:41]

remove extra empty line

[kelvinp, 2016/05/18 23:43:28]

Done.

+  Address original_from;
+  std::string error_message;
+  original_from.ParseXml(request_stanza, Address::FROM, &error_message);
+  DCHECK(error_message.empty());
+  original_from.toXml(iq.get(), Address::TO);
+
   iq->SetAttr(QName(kEmptyNamespace, "id"),
               request_stanza->Attr(QName(kEmptyNamespace, "id")));
 
   if (type == REPLY_RESULT) {
     iq->SetAttr(QName(kEmptyNamespace, "type"), "result");
     return iq;
   }
 
   DCHECK_EQ(type, REPLY_ERROR);
 
@@ skipping 103 matching lines @@
     result->AddElement(FormatIceCredentials(credentials));
   }
   for (const NamedCandidate& candidate : candidates) {
     result->AddElement(FormatIceCandidate(candidate));
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting