1// 2// Copyright (C) 2011 The Android Open Source Project 3// 4// Licensed under the Apache License, Version 2.0 (the "License"); 5// you may not use this file except in compliance with the License. 6// You may obtain a copy of the License at 7// 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// See the License for the specific language governing permissions and 14// limitations under the License. 15// 16 17#include "update_engine/omaha_request_params.h" 18 19#include <errno.h> 20#include <fcntl.h> 21#include <sys/utsname.h> 22 23#include <map> 24#include <string> 25#include <vector> 26 27#include <base/files/file_util.h> 28#include <base/strings/string_util.h> 29#include <base/strings/stringprintf.h> 30#include <brillo/key_value_store.h> 31#include <brillo/strings/string_utils.h> 32#include <policy/device_policy.h> 33 34#include "update_engine/common/constants.h" 35#include "update_engine/common/hardware_interface.h" 36#include "update_engine/common/platform_constants.h" 37#include "update_engine/common/utils.h" 38#include "update_engine/system_state.h" 39 40#define CALL_MEMBER_FN(object, member) ((object).*(member)) 41 42using std::map; 43using std::string; 44using std::vector; 45 46namespace chromeos_update_engine { 47 48const char OmahaRequestParams::kOsVersion[] = "Indy"; 49 50const char* kChannelsByStability[] = { 51 // This list has to be sorted from least stable to most stable channel. 52 "canary-channel", 53 "dev-channel", 54 "beta-channel", 55 "stable-channel", 56}; 57 58OmahaRequestParams::~OmahaRequestParams() { 59 if (!root_.empty()) 60 test::SetImagePropertiesRootPrefix(nullptr); 61} 62 63bool OmahaRequestParams::Init(const string& in_app_version, 64 const string& in_update_url, 65 bool in_interactive) { 66 LOG(INFO) << "Initializing parameters for this update attempt"; 67 image_props_ = LoadImageProperties(system_state_); 68 mutable_image_props_ = LoadMutableImageProperties(system_state_); 69 70 // Sanity check the channel names. 71 if (!IsValidChannel(image_props_.current_channel)) 72 image_props_.current_channel = "stable-channel"; 73 if (!IsValidChannel(mutable_image_props_.target_channel)) 74 mutable_image_props_.target_channel = image_props_.current_channel; 75 UpdateDownloadChannel(); 76 77 LOG(INFO) << "Running from channel " << image_props_.current_channel; 78 79 os_platform_ = constants::kOmahaPlatformName; 80 if (!image_props_.system_version.empty()) 81 os_version_ = image_props_.system_version; 82 else 83 os_version_ = OmahaRequestParams::kOsVersion; 84 if (!in_app_version.empty()) 85 image_props_.version = in_app_version; 86 87 os_sp_ = image_props_.version + "_" + GetMachineType(); 88 app_lang_ = "en-US"; 89 hwid_ = system_state_->hardware()->GetHardwareClass(); 90 if (CollectECFWVersions()) { 91 fw_version_ = system_state_->hardware()->GetFirmwareVersion(); 92 ec_version_ = system_state_->hardware()->GetECVersion(); 93 } 94 95 if (image_props_.current_channel == mutable_image_props_.target_channel) { 96 // deltas are only okay if the /.nodelta file does not exist. if we don't 97 // know (i.e. stat() returns some unexpected error), then err on the side of 98 // caution and say deltas are not okay. 99 struct stat stbuf; 100 delta_okay_ = (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) && 101 (errno == ENOENT); 102 } else { 103 LOG(INFO) << "Disabling deltas as a channel change to " 104 << mutable_image_props_.target_channel 105 << " is pending, with is_powerwash_allowed=" 106 << utils::ToString(mutable_image_props_.is_powerwash_allowed); 107 // For now, disable delta updates if the current channel is different from 108 // the channel that we're sending to the update server because such updates 109 // are destined to fail -- the current rootfs hash will be different than 110 // the expected hash due to the different channel in /etc/lsb-release. 111 delta_okay_ = false; 112 } 113 114 if (in_update_url.empty()) 115 update_url_ = image_props_.omaha_url; 116 else 117 update_url_ = in_update_url; 118 119 // Set the interactive flag accordingly. 120 interactive_ = in_interactive; 121 return true; 122} 123 124bool OmahaRequestParams::IsUpdateUrlOfficial() const { 125 return (update_url_ == constants::kOmahaDefaultAUTestURL || 126 update_url_ == image_props_.omaha_url); 127} 128 129bool OmahaRequestParams::CollectECFWVersions() const { 130 return base::StartsWith(hwid_, string("SAMS ALEX"), 131 base::CompareCase::SENSITIVE) || 132 base::StartsWith(hwid_, string("BUTTERFLY"), 133 base::CompareCase::SENSITIVE) || 134 base::StartsWith(hwid_, string("LUMPY"), 135 base::CompareCase::SENSITIVE) || 136 base::StartsWith(hwid_, string("PARROT"), 137 base::CompareCase::SENSITIVE) || 138 base::StartsWith(hwid_, string("SPRING"), 139 base::CompareCase::SENSITIVE) || 140 base::StartsWith(hwid_, string("SNOW"), base::CompareCase::SENSITIVE); 141} 142 143bool OmahaRequestParams::SetTargetChannel(const string& new_target_channel, 144 bool is_powerwash_allowed, 145 string* error_message) { 146 LOG(INFO) << "SetTargetChannel called with " << new_target_channel 147 << ", Is Powerwash Allowed = " 148 << utils::ToString(is_powerwash_allowed) 149 << ". Current channel = " << image_props_.current_channel 150 << ", existing target channel = " 151 << mutable_image_props_.target_channel 152 << ", download channel = " << download_channel_; 153 if (!IsValidChannel(new_target_channel)) { 154 string valid_channels = brillo::string_utils::JoinRange( 155 ", ", 156 std::begin(kChannelsByStability), 157 std::end(kChannelsByStability)); 158 if (error_message) { 159 *error_message = base::StringPrintf( 160 "Invalid channel name \"%s\", valid names are: %s", 161 new_target_channel.c_str(), valid_channels.c_str()); 162 } 163 return false; 164 } 165 166 MutableImageProperties new_props; 167 new_props.target_channel = new_target_channel; 168 new_props.is_powerwash_allowed = is_powerwash_allowed; 169 170 if (!StoreMutableImageProperties(system_state_, new_props)) { 171 if (error_message) 172 *error_message = "Error storing the new channel value."; 173 return false; 174 } 175 mutable_image_props_ = new_props; 176 return true; 177} 178 179void OmahaRequestParams::UpdateDownloadChannel() { 180 if (download_channel_ != mutable_image_props_.target_channel) { 181 download_channel_ = mutable_image_props_.target_channel; 182 LOG(INFO) << "Download channel for this attempt = " << download_channel_; 183 } 184} 185 186string OmahaRequestParams::GetMachineType() const { 187 struct utsname buf; 188 string ret; 189 if (uname(&buf) == 0) 190 ret = buf.machine; 191 return ret; 192} 193 194bool OmahaRequestParams::IsValidChannel(const string& channel) const { 195 return GetChannelIndex(channel) >= 0; 196} 197 198void OmahaRequestParams::set_root(const string& root) { 199 root_ = root; 200 test::SetImagePropertiesRootPrefix(root_.c_str()); 201} 202 203int OmahaRequestParams::GetChannelIndex(const string& channel) const { 204 for (size_t t = 0; t < arraysize(kChannelsByStability); ++t) 205 if (channel == kChannelsByStability[t]) 206 return t; 207 208 return -1; 209} 210 211bool OmahaRequestParams::to_more_stable_channel() const { 212 int current_channel_index = GetChannelIndex(image_props_.current_channel); 213 int download_channel_index = GetChannelIndex(download_channel_); 214 215 return download_channel_index > current_channel_index; 216} 217 218string OmahaRequestParams::GetAppId() const { 219 return download_channel_ == "canary-channel" ? image_props_.canary_product_id 220 : image_props_.product_id; 221} 222 223} // namespace chromeos_update_engine 224