| // Copyright 2015 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 "components/cryptauth/remote_device.h" |
| |
| #include "base/base64.h" |
| |
| namespace cryptauth { |
| |
| namespace { |
| |
| // Returns true if both vectors are BeaconSeeds are equal. |
| bool AreBeaconSeedsEqual(const std::vector<BeaconSeed> beacon_seeds1, |
| const std::vector<BeaconSeed> beacon_seeds2) { |
| if (beacon_seeds1.size() != beacon_seeds2.size()) { |
| return false; |
| } |
| |
| for (size_t i = 0; i < beacon_seeds1.size(); ++i) { |
| const BeaconSeed& seed1 = beacon_seeds1[i]; |
| const BeaconSeed& seed2 = beacon_seeds2[i]; |
| if (seed1.start_time_millis() != seed2.start_time_millis() || |
| seed1.end_time_millis() != seed2.end_time_millis() || |
| seed1.data() != seed2.data()) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| } // namespace |
| |
| RemoteDevice::RemoteDevice() {} |
| |
| RemoteDevice::RemoteDevice(const std::string& user_id, |
| const std::string& name, |
| const std::string& public_key, |
| const std::string& bluetooth_address, |
| const std::string& persistent_symmetric_key, |
| std::string sign_in_challenge) |
| : user_id(user_id), |
| name(name), |
| public_key(public_key), |
| bluetooth_address(bluetooth_address), |
| persistent_symmetric_key(persistent_symmetric_key), |
| sign_in_challenge(sign_in_challenge) {} |
| |
| RemoteDevice::RemoteDevice(const RemoteDevice& other) = default; |
| |
| RemoteDevice::~RemoteDevice() {} |
| |
| void RemoteDevice::LoadBeaconSeeds( |
| const std::vector<BeaconSeed>& beacon_seeds) { |
| this->are_beacon_seeds_loaded = true; |
| this->beacon_seeds = beacon_seeds; |
| } |
| |
| std::string RemoteDevice::GetDeviceId() const { |
| std::string to_return; |
| base::Base64Encode(public_key, &to_return); |
| return to_return; |
| } |
| |
| std::string RemoteDevice::GetTruncatedDeviceIdForLogs() const { |
| return RemoteDevice::TruncateDeviceIdForLogs(GetDeviceId()); |
| } |
| |
| bool RemoteDevice::operator==(const RemoteDevice& other) const { |
| // Only compare |beacon_seeds| if they are loaded. |
| bool are_beacon_seeds_equal = false; |
| if (are_beacon_seeds_loaded) { |
| are_beacon_seeds_equal = |
| other.are_beacon_seeds_loaded && |
| AreBeaconSeedsEqual(beacon_seeds, other.beacon_seeds); |
| } else { |
| are_beacon_seeds_equal = !other.are_beacon_seeds_loaded; |
| } |
| |
| return user_id == other.user_id && name == other.name && |
| public_key == other.public_key && |
| bluetooth_address == other.bluetooth_address && |
| persistent_symmetric_key == other.persistent_symmetric_key && |
| sign_in_challenge == other.sign_in_challenge && are_beacon_seeds_equal; |
| } |
| |
| bool RemoteDevice::operator<(const RemoteDevice& other) const { |
| // |public_key| is the only field guaranteed to be set and is also unique to |
| // each RemoteDevice. However, since it can contain null bytes, use |
| // GetDeviceId(), which cannot contain null bytes, to compare devices. |
| return GetDeviceId().compare(other.GetDeviceId()) < 0; |
| } |
| |
| // static |
| std::string RemoteDevice::TruncateDeviceIdForLogs(const std::string& full_id) { |
| if (full_id.length() <= 10) { |
| return full_id; |
| } |
| |
| return full_id.substr(0, 5) |
| + "..." |
| + full_id.substr(full_id.length() - 5, full_id.length()); |
| } |
| |
| } // namespace cryptauth |