This source file includes following definitions.
- directory_bot_jid_
- OnSignalStrategyStateChange
- OnSignalStrategyIncomingStanza
- SendOfflineStatus
- SendOnlineStatus
- SendHostStatus
- CreateHostStatusMessage
- CreateSignature
#include "remoting/host/host_status_sender.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringize_macros.h"
#include "base/time/time.h"
#include "remoting/base/constants.h"
#include "remoting/base/logging.h"
#include "remoting/host/server_log_entry.h"
#include "remoting/jingle_glue/iq_sender.h"
#include "remoting/jingle_glue/signal_strategy.h"
#include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
#include "third_party/libjingle/source/talk/xmpp/constants.h"
using buzz::QName;
using buzz::XmlElement;
namespace remoting {
namespace {
const char kHostStatusTag[] = "host-status";
const char kHostIdAttr[] = "hostid";
const char kExitCodeAttr[] = "exit-code";
const char kHostVersionTag[] = "host-version";
const char kSignatureTag[] = "signature";
const char kStatusAttr[] = "status";
const char kSignatureTimeAttr[] = "time";
}
const char* const HostStatusSender::host_status_strings_[] =
{"OFFLINE", "ONLINE"};
HostStatusSender::HostStatusSender(
const std::string& host_id,
SignalStrategy* signal_strategy,
scoped_refptr<RsaKeyPair> key_pair,
const std::string& directory_bot_jid)
: host_id_(host_id),
signal_strategy_(signal_strategy),
key_pair_(key_pair),
directory_bot_jid_(directory_bot_jid) {
DCHECK(signal_strategy_);
DCHECK(key_pair_.get());
signal_strategy_->AddListener(this);
}
HostStatusSender::~HostStatusSender() {
signal_strategy_->RemoveListener(this);
}
void HostStatusSender::OnSignalStrategyStateChange(
SignalStrategy::State state) {
if (state == SignalStrategy::CONNECTED)
iq_sender_.reset(new IqSender(signal_strategy_));
else if (state == SignalStrategy::DISCONNECTED)
iq_sender_.reset();
}
bool HostStatusSender::OnSignalStrategyIncomingStanza(
const XmlElement* stanza) {
return false;
}
void HostStatusSender::SendOfflineStatus(HostExitCodes exit_code) {
SendHostStatus(OFFLINE, exit_code);
}
void HostStatusSender::SendOnlineStatus() {
SendHostStatus(ONLINE, kSuccessExitCode);
}
void HostStatusSender::SendHostStatus(HostStatus status,
HostExitCodes exit_code) {
SignalStrategy::State state = signal_strategy_->GetState();
if (state == SignalStrategy::CONNECTED) {
HOST_LOG << "Sending host status '"
<< HostStatusToString(status)
<< "' to "
<< directory_bot_jid_;
iq_sender_->SendIq(buzz::STR_SET,
directory_bot_jid_,
CreateHostStatusMessage(status, exit_code),
IqSender::ReplyCallback());
} else {
HOST_LOG << "Cannot send host status to '"
<< directory_bot_jid_
<< " ' because the state of the SignalStrategy is "
<< state;
}
}
scoped_ptr<XmlElement> HostStatusSender::CreateHostStatusMessage(
HostStatus status, HostExitCodes exit_code) {
scoped_ptr<XmlElement> host_status(new XmlElement(
QName(kChromotingXmlNamespace, kHostStatusTag)));
host_status->AddAttr(
QName(kChromotingXmlNamespace, kHostIdAttr), host_id_);
host_status->AddAttr(
QName(kChromotingXmlNamespace, kStatusAttr), HostStatusToString(status));
if (status == OFFLINE) {
host_status->AddAttr(
QName(kChromotingXmlNamespace, kExitCodeAttr),
ExitCodeToString(exit_code));
}
host_status->AddElement(CreateSignature(status, exit_code).release());
scoped_ptr<XmlElement> version_tag(new XmlElement(
QName(kChromotingXmlNamespace, kHostVersionTag)));
version_tag->AddText(STRINGIZE(VERSION));
host_status->AddElement(version_tag.release());
scoped_ptr<XmlElement> log(ServerLogEntry::MakeStanza());
scoped_ptr<ServerLogEntry> log_entry(
ServerLogEntry::MakeForHostStatus(status, exit_code));
log_entry->AddHostFields();
log->AddElement(log_entry->ToStanza().release());
host_status->AddElement(log.release());
return host_status.Pass();
}
scoped_ptr<XmlElement> HostStatusSender::CreateSignature(
HostStatus status, HostExitCodes exit_code) {
scoped_ptr<XmlElement> signature_tag(new XmlElement(
QName(kChromotingXmlNamespace, kSignatureTag)));
int64 time = static_cast<int64>(base::Time::Now().ToDoubleT());
std::string time_str(base::Int64ToString(time));
signature_tag->AddAttr(
QName(kChromotingXmlNamespace, kSignatureTimeAttr), time_str);
std::string message =
signal_strategy_->GetLocalJid() +
" " +
time_str +
" " +
HostStatusToString(status);
if (status == OFFLINE)
message += std::string(" ") + ExitCodeToString(exit_code);
std::string signature(key_pair_->SignMessage(message));
signature_tag->AddText(signature);
return signature_tag.Pass();
}
}