| // Copyright 2014 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/client/log_to_server.h" |
| |
| #include "base/macros.h" |
| #include "base/rand_util.h" |
| #include "remoting/base/constants.h" |
| #include "remoting/client/chromoting_stats.h" |
| #include "remoting/client/server_log_entry_client.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; |
| using remoting::protocol::ConnectionToHost; |
| |
| namespace { |
| |
| const char kSessionIdAlphabet[] = |
| "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"; |
| const int kSessionIdLength = 20; |
| |
| const int kMaxSessionIdAgeDays = 1; |
| |
| bool IsStartOfSession(ConnectionToHost::State state) { |
| return state == ConnectionToHost::INITIALIZING || |
| state == ConnectionToHost::CONNECTING || |
| state == ConnectionToHost::AUTHENTICATED || |
| state == ConnectionToHost::CONNECTED; |
| } |
| |
| bool IsEndOfSession(ConnectionToHost::State state) { |
| return state == ConnectionToHost::FAILED || |
| state == ConnectionToHost::CLOSED; |
| } |
| |
| bool ShouldAddDuration(ConnectionToHost::State state) { |
| // Duration is added to log entries at the end of the session, as well as at |
| // some intermediate states where it is relevant (e.g. to determine how long |
| // it took for a session to become CONNECTED). |
| return IsEndOfSession(state) || state == ConnectionToHost::CONNECTED; |
| } |
| |
| } // namespace |
| |
| namespace remoting { |
| |
| namespace client { |
| |
| LogToServer::LogToServer(ServerLogEntry::Mode mode, |
| SignalStrategy* signal_strategy, |
| const std::string& directory_bot_jid) |
| : mode_(mode), |
| signal_strategy_(signal_strategy), |
| directory_bot_jid_(directory_bot_jid) { |
| signal_strategy_->AddListener(this); |
| } |
| |
| LogToServer::~LogToServer() { |
| signal_strategy_->RemoveListener(this); |
| } |
| |
| void LogToServer::LogSessionStateChange( |
| protocol::ConnectionToHost::State state, |
| protocol::ErrorCode error) { |
| DCHECK(CalledOnValidThread()); |
| |
| scoped_ptr<ServerLogEntry> entry( |
| MakeLogEntryForSessionStateChange(state, error)); |
| AddClientFieldsToLogEntry(entry.get()); |
| entry->AddModeField(mode_); |
| |
| MaybeExpireSessionId(); |
| if (IsStartOfSession(state)) { |
| // Maybe set the session ID and start time. |
| if (session_id_.empty()) { |
| GenerateSessionId(); |
| } |
| if (session_start_time_.is_null()) { |
| session_start_time_ = base::TimeTicks::Now(); |
| } |
| } |
| |
| if (!session_id_.empty()) { |
| AddSessionIdToLogEntry(entry.get(), session_id_); |
| } |
| |
| // Maybe clear the session start time and log the session duration. |
| if (ShouldAddDuration(state) && !session_start_time_.is_null()) { |
| AddSessionDurationToLogEntry(entry.get(), |
| base::TimeTicks::Now() - session_start_time_); |
| } |
| |
| if (IsEndOfSession(state)) { |
| session_start_time_ = base::TimeTicks(); |
| session_id_.clear(); |
| } |
| |
| Log(*entry.get()); |
| } |
| |
| void LogToServer::LogStatistics(ChromotingStats* statistics) { |
| DCHECK(CalledOnValidThread()); |
| |
| MaybeExpireSessionId(); |
| |
| scoped_ptr<ServerLogEntry> entry(MakeLogEntryForStatistics(statistics)); |
| AddClientFieldsToLogEntry(entry.get()); |
| entry->AddModeField(mode_); |
| AddSessionIdToLogEntry(entry.get(), session_id_); |
| Log(*entry.get()); |
| } |
| |
| void LogToServer::OnSignalStrategyStateChange(SignalStrategy::State state) { |
| DCHECK(CalledOnValidThread()); |
| |
| if (state == SignalStrategy::CONNECTED) { |
| iq_sender_.reset(new IqSender(signal_strategy_)); |
| SendPendingEntries(); |
| } else if (state == SignalStrategy::DISCONNECTED) { |
| iq_sender_.reset(); |
| } |
| } |
| |
| bool LogToServer::OnSignalStrategyIncomingStanza( |
| const buzz::XmlElement* stanza) { |
| return false; |
| } |
| |
| void LogToServer::Log(const ServerLogEntry& entry) { |
| pending_entries_.push_back(entry); |
| SendPendingEntries(); |
| } |
| |
| void LogToServer::SendPendingEntries() { |
| if (iq_sender_ == NULL) { |
| return; |
| } |
| if (pending_entries_.empty()) { |
| return; |
| } |
| // Make one stanza containing all the pending entries. |
| scoped_ptr<XmlElement> stanza(ServerLogEntry::MakeStanza()); |
| while (!pending_entries_.empty()) { |
| ServerLogEntry& entry = pending_entries_.front(); |
| stanza->AddElement(entry.ToStanza().release()); |
| pending_entries_.pop_front(); |
| } |
| // Send the stanza to the server. |
| scoped_ptr<IqRequest> req = iq_sender_->SendIq( |
| buzz::STR_SET, directory_bot_jid_, stanza.Pass(), |
| IqSender::ReplyCallback()); |
| // We ignore any response, so let the IqRequest be destroyed. |
| return; |
| } |
| |
| void LogToServer::GenerateSessionId() { |
| session_id_.resize(kSessionIdLength); |
| for (int i = 0; i < kSessionIdLength; i++) { |
| const int alphabet_size = arraysize(kSessionIdAlphabet) - 1; |
| session_id_[i] = kSessionIdAlphabet[base::RandGenerator(alphabet_size)]; |
| } |
| session_id_generation_time_ = base::TimeTicks::Now(); |
| } |
| |
| void LogToServer::MaybeExpireSessionId() { |
| if (session_id_.empty()) { |
| return; |
| } |
| |
| base::TimeDelta max_age = base::TimeDelta::FromDays(kMaxSessionIdAgeDays); |
| if (base::TimeTicks::Now() - session_id_generation_time_ > max_age) { |
| // Log the old session ID. |
| scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionIdOld(session_id_)); |
| entry->AddModeField(mode_); |
| Log(*entry.get()); |
| |
| // Generate a new session ID. |
| GenerateSessionId(); |
| |
| // Log the new session ID. |
| entry = MakeLogEntryForSessionIdNew(session_id_); |
| entry->AddModeField(mode_); |
| Log(*entry.get()); |
| } |
| } |
| |
| } // namespace client |
| |
| } // namespace remoting |