remoting/jingle_glue/iq_sender.cc

   1 // Copyright (c) 2012 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 "remoting/jingle_glue/iq_sender.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/time/time.h"
  15 #include "remoting/jingle_glue/signal_strategy.h"
  16 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
  17 #include "third_party/libjingle/source/talk/xmpp/constants.h"
  18
  19 namespace remoting {
  20
  21 // static
  22 scoped_ptr<buzz::XmlElement> IqSender::MakeIqStanza(
  23     const std::string& type,
  24     const std::string& addressee,
  25     scoped_ptr<buzz::XmlElement> iq_body) {
  26   scoped_ptr<buzz::XmlElement> stanza(new buzz::XmlElement(buzz::QN_IQ));
  27   stanza->AddAttr(buzz::QN_TYPE, type);
  28   if (!addressee.empty())
  29     stanza->AddAttr(buzz::QN_TO, addressee);
  30   stanza->AddElement(iq_body.release());
  31   return stanza.Pass();
  32 }
  33
  34 IqSender::IqSender(SignalStrategy* signal_strategy)
  35     : signal_strategy_(signal_strategy) {
  36   signal_strategy_->AddListener(this);
  37 }
  38
  39 IqSender::~IqSender() {
  40   signal_strategy_->RemoveListener(this);
  41 }
  42
  43 scoped_ptr<IqRequest> IqSender::SendIq(scoped_ptr<buzz::XmlElement> stanza,
  44                                        const ReplyCallback& callback) {
  45   std::string addressee = stanza->Attr(buzz::QN_TO);
  46   std::string id = signal_strategy_->GetNextId();
  47   stanza->AddAttr(buzz::QN_ID, id);
  48   if (!signal_strategy_->SendStanza(stanza.Pass())) {
  49     return scoped_ptr<IqRequest>();
  50   }
  51   DCHECK(requests_.find(id) == requests_.end());
  52   scoped_ptr<IqRequest> request(new IqRequest(this, callback, addressee));
  53   if (!callback.is_null())
  54     requests_[id] = request.get();
  55   return request.Pass();
  56 }
  57
  58 scoped_ptr<IqRequest> IqSender::SendIq(const std::string& type,
  59                                        const std::string& addressee,
  60                                        scoped_ptr<buzz::XmlElement> iq_body,
  61                                        const ReplyCallback& callback) {
  62   return SendIq(MakeIqStanza(type, addressee, iq_body.Pass()), callback);
  63 }
  64
  65 void IqSender::RemoveRequest(IqRequest* request) {
  66   IqRequestMap::iterator it = requests_.begin();
  67   while (it != requests_.end()) {
  68     IqRequestMap::iterator cur = it;
  69     ++it;
  70     if (cur->second == request) {
  71       requests_.erase(cur);
  72       break;
  73     }
  74   }
  75 }
  76
  77 void IqSender::OnSignalStrategyStateChange(SignalStrategy::State state) {
  78 }
  79
  80 bool IqSender::OnSignalStrategyIncomingStanza(const buzz::XmlElement* stanza) {
  81   if (stanza->Name() != buzz::QN_IQ) {
  82     LOG(WARNING) << "Received unexpected non-IQ packet " << stanza->Str();
  83     return false;
  84   }
  85
  86   const std::string& type = stanza->Attr(buzz::QN_TYPE);
  87   if (type.empty()) {
  88     LOG(WARNING) << "IQ packet missing type " << stanza->Str();
  89     return false;
  90   }
  91
  92   if (type != "result" && type != "error") {
  93     return false;
  94   }
  95
  96   const std::string& id = stanza->Attr(buzz::QN_ID);
  97   if (id.empty()) {
  98     LOG(WARNING) << "IQ packet missing id " << stanza->Str();
  99     return false;
 100   }
 101
 102   std::string from = stanza->Attr(buzz::QN_FROM);
 103
 104   IqRequestMap::iterator it = requests_.find(id);
 105
 106   // This is a hack to workaround the issue with the WCS changing IDs
 107   // of IQ responses sent from client to host. Whenever we receive a
 108   // stanza with an unknown ID we try to match it with an outstanding
 109   // request sent to the same peer.
 110   if (it == requests_.end()) {
 111     for (it = requests_.begin(); it != requests_.end(); ++it) {
 112       if (it->second->addressee_ == from) {
 113         break;
 114       }
 115     }
 116   }
 117
 118   if (it == requests_.end()) {
 119     return false;
 120   }
 121
 122   IqRequest* request = it->second;
 123
 124   if (request->addressee_ != from) {
 125     LOG(ERROR) << "Received IQ response from from a invalid JID. Ignoring it."
 126                << " Message received from: " << from
 127                << " Original JID: " << request->addressee_;
 128     return false;
 129   }
 130
 131   requests_.erase(it);
 132   request->OnResponse(stanza);
 133
 134   return true;
 135 }
 136
 137 IqRequest::IqRequest(IqSender* sender, const IqSender::ReplyCallback& callback,
 138                      const std::string& addressee)
 139     : sender_(sender),
 140       callback_(callback),
 141       addressee_(addressee) {
 142 }
 143
 144 IqRequest::~IqRequest() {
 145   sender_->RemoveRequest(this);
 146 }
 147
 148 void IqRequest::SetTimeout(base::TimeDelta timeout) {
 149   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 150       FROM_HERE, base::Bind(&IqRequest::OnTimeout, AsWeakPtr()), timeout);
 151 }
 152
 153 void IqRequest::CallCallback(const buzz::XmlElement* stanza) {
 154   if (!callback_.is_null()) {
 155     IqSender::ReplyCallback callback(callback_);
 156     callback_.Reset();
 157     callback.Run(this, stanza);
 158   }
 159 }
 160
 161 void IqRequest::OnTimeout() {
 162   CallCallback(NULL);
 163 }
 164
 165 void IqRequest::OnResponse(const buzz::XmlElement* stanza) {
 166   // It's unsafe to delete signal strategy here, and the callback may
 167   // want to do that, so we post task to invoke the callback later.
 168   scoped_ptr<buzz::XmlElement> stanza_copy(new buzz::XmlElement(*stanza));
 169   base::ThreadTaskRunnerHandle::Get()->PostTask(
 170       FROM_HERE, base::Bind(&IqRequest::DeliverResponse, AsWeakPtr(),
 171                             base::Passed(&stanza_copy)));
 172 }
 173
 174 void IqRequest::DeliverResponse(scoped_ptr<buzz::XmlElement> stanza) {
 175   CallCallback(stanza.get());
 176 }
 177
 178 }  // namespace remoting